بنقرة واحدة
team-shinchan-start
Use when you want to start a new task with the integrated workflow.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
القائمة
Use when you want to start a new task with the integrated workflow.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
Use when you have a large-scale, multi-phase project requiring orchestrated execution.
Use when you need persistent looping until a task is fully complete.
Deterministic adversarial code review for high-stakes scope — independent per-dimension review, a non-skippable per-finding refutation, completeness + interaction critics, and a deterministic 3-lens rubric judge panel. Opt-in main-loop Workflow tier.
Use when the user wants to review accumulated skill feedback, verdict trends, or improvement candidates collected during Stage 4 retrospectives. Trigger on "show skill feedback", "스킬 피드백 보여줘", or finding which skills need /writing-skills work.
Deterministic competitive code tournament — N builders independently solve one task and return patches, an Action-Kamen judge scores them head-to-head, the winner is picked by score and applied. Opt-in main-loop Workflow tier.
Deterministic adversarial debate for high-stakes or irreversible decisions — mandatory refutation plus a scored judge panel. Opt-in main-loop Workflow tier.
| name | team-shinchan:start |
| description | Use when you want to start a new task with the integrated workflow. |
| user-invocable | true |
When this skill is invoked, execute immediately. Do not explain.
This skill is normally invoked standalone. It can also be driven by the bigproject
phase loop (skills/bigproject/SKILL.md Step 5), which executes these same steps on the
main thread with the following inputs already resolved:
DOC_ID — pre-set to {PROJECT_ID}-phase-{N}. Use it verbatim; do NOT generate one.parent_doc_id — the owning {PROJECT_ID}.phase_number — the 1-based phase index.PHASE_CONTEXT — project title + this phase's title/domain/acceptance criteria +
summaries of completed phases.When invoked with injected context:
DOC_ID and write parent_doc_id / phase_number into the
state (see Step 1).PHASE_CONTEXT to Misae so the interview is scoped to this phase.When invoked standalone (no injected context), behave exactly as before.
Read workflow_expiry_days from:
.shinchan-config.yaml in the current project root (key: workflow_expiry_days) — takes priorityplugin.json settings)workflow_expiry_days is 0 or cannot be read → skip expiry entirelyFor each .shinchan-docs/*/WORKFLOW_STATE.yaml where status: active:
Expiry check (skip if workflow_expiry_days == 0):
updated timestamp from WORKFLOW_STATE.yaml(now - updated) / 86400000elapsed >= workflow_expiry_days:
a. Set status: expired in WORKFLOW_STATE.yaml
b. Add event to history:
- timestamp: "{ISO now}"
event: auto_expired
agent: shinnosuke
archived_at: "{ISO now}"
archived_reason: auto_expiry
c. Calculate archive path: .shinchan-docs/archived/{YYYY-MM}/ where YYYY-MM
comes from the current date
d. Attempt: mkdir -p .shinchan-docs/archived/{YYYY-MM}/ && mv .shinchan-docs/{DOC_ID}/ .shinchan-docs/archived/{YYYY-MM}/{DOC_ID}/
e. If mv fails: silently continue (status stays expired, folder stays in place)
f. Do NOT output any paused/expired notification to the user
g. Continue to next workflowNon-expired active workflows are left as-is. Multiple workflows can be active simultaneously.
The workflow guard (workflow-guard.sh) protects the most recently updated active workflow.
Use /team-shinchan:resume to switch the guard target to a different workflow.
DOC_ID was injected (bigproject phase mode), use it verbatim and skip generation. Otherwise: if args contains ISSUE-xxx use it; else {branch}-{next_index} from git branch + ls. When computing {next_index}, ignore directories matching *-phase-* — those belong to a bigproject and are not standalone workflows. Truncate + warn if args > 2000 chars.mkdir -p .shinchan-docs/{DOC_ID}version: 1
doc_id: "{DOC_ID}"
created: "{timestamp}"
updated: "{timestamp}"
current:
stage: requirements
phase: null
owner: misae
status: active
execution_mode: micro-execute # /start default — pins Stage 3 to the per-task (spec→quality→skeptic) review chain. Set to `dag` ONLY when explicitly opting into parallel dag-executor dispatch.
# parent_doc_id / phase_number: ONLY when injected by bigproject phase mode; omit standalone.
# parent_doc_id: "{parent_doc_id}"
# phase_number: {phase_number}
interview: { step: 0, collected_count: 0, last_question: null }
ak_gate:
requirements:
status: pending # pending | in_review | approved | rejected | escalated
retry_count: 0 # 0, 1, or 2 (max)
last_rejection_reasons: [] # list of strings — most recent rejection points
design:
status: pending
retry_count: 0
last_rejection_reasons: []
planning:
status: pending
retry_count: 0
last_rejection_reasons: []
history:
- timestamp: "{timestamp}"
event: workflow_started
agent: shinnosuke
History entry format for AK review (appended after each AK review):
- timestamp: "{ISO timestamp}"
event: ak_review
agent: action_kamen
stage: requirements # or planning
verdict: REJECTED # or APPROVED
retry_count: 0 # which attempt this was (0 = first, 1 = first retry, 2 = second retry)
rejection_reasons:
- "Problem Statement lacks quantified success metrics"
- "FR coverage missing error-handling scenarios"
ak_gate schema notes:
statusvalues:pending(not yet reviewed) |in_review(AK review in progress) |approved(AK approved) |rejected(AK rejected, retries remaining) |escalated(max retries reached, waiting for user)retry_countpersists across session restarts (NFR-2: session-restart safe)- Existing workflows without
ak_gatefield continue to function (backwards-compatible)
Stage rules and transition gates are defined in CLAUDE.md and hooks/workflow-guard.md.
Output greeting (adapt to user's language):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
👦 [Shinnosuke] Hey! Let's build something great~ 💪
📁 Project: {DOC_ID} | 🎯 Stage: Requirements
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
If args contain image/PDF paths (.png, .jpg, .jpeg, .gif, .svg, .pdf, .webp) or reference visual content:
Task(subagent_type="team-shinchan:ume", model="sonnet",
prompt="Analyze visual content for requirements.\nDOC_ID: {DOC_ID}\nExtract: UI components, layout, design patterns, user flows, ambiguities.\nUser request: {args}")
Store result as {vision_context}. Skip if no visual input.
CRITICAL: Sub-agents cannot call AskUserQuestion for the user. The main thread (this skill) drives the interview; Misae designs each question. See agents/misae.md § "Parent-Orchestrated Interview Protocol".
2A.0 — Read interview config (FR-6):
# Read .shinchan-config.yaml if present (project root), else use defaults.
config = read_yaml(".shinchan-config.yaml") if file_exists else {}
skip_threshold = config.get("interview.skip_threshold", 0.85)
done_threshold = config.get("interview.done_threshold", 0.75)
hard_cap = config.get("interview.hard_cap", 10)
gate_loop_enabled = config.get("interview.gate_loop_enabled", True) # NEW
gate_threshold = config.get("interview.gate_threshold", 0.8) # NEW
stagnation_delta = config.get("interview.stagnation_delta", 0.05) # NEW
stagnation_window = config.get("interview.stagnation_window", 2) # NEW
soft_cap = config.get("interview.soft_cap", 6) # NEW
ak_double_check = config.get("interview.ak_double_check", False) # NEW
project_type = config.get("interview.project_type", "greenfield")# NEW
# Sanity check (FR-6, HR-2, HR-3): invalid values → fall back to defaults + warn
warnings = []
if not (0 < done_threshold < skip_threshold <= 1.0) or not (1 <= hard_cap <= 50):
warnings.append("skip/done/hard_cap out of range"); skip_threshold = 0.85; done_threshold = 0.75; hard_cap = 10
if gate_threshold <= done_threshold:
warnings.append("gate_threshold must be > done_threshold"); gate_threshold = 0.8
if soft_cap >= hard_cap:
warnings.append("soft_cap must be < hard_cap"); soft_cap = 6
if stagnation_window < 2:
warnings.append("stagnation_window must be >= 2 (HR-3 DoS protection)"); stagnation_window = 2
if stagnation_delta <= 0:
warnings.append("stagnation_delta must be > 0"); stagnation_delta = 0.05
if project_type not in ("brownfield", "greenfield"):
warnings.append("project_type must be brownfield|greenfield"); project_type = "greenfield"
if warnings:
print("⚠️ [start] .shinchan-config.yaml validation errors — using defaults: " + "; ".join(warnings))
# Write resolved gate_loop_enabled + gate_threshold into WORKFLOW_STATE.current so
# mechanical-check Check D can enforce the gate without reading .shinchan-config.yaml.
write_to_state({"current.gate_loop_enabled": gate_loop_enabled, "current.gate_threshold": gate_threshold})
2A.1 — Interview loop (clarity-gated, hard_cap is the only ceiling):
answers = []
exit_reason = null # populated by Misae's status:done payload
for turn in 1..hard_cap:
result = Task(subagent_type="team-shinchan:misae", model="sonnet", prompt=
"mode: DESIGN_NEXT_QUESTION
DOC_ID: {DOC_ID} | WORKFLOW_STATE: .shinchan-docs/{DOC_ID}/WORKFLOW_STATE.yaml
turn: {turn}
prior_answers: {answers}
user_request: {args}
vision_context: {vision_context or 'None'}
phase_context: {PHASE_CONTEXT or 'None'} # bigproject phase mode: scope questions to this phase
skip_threshold: {skip_threshold}
done_threshold: {done_threshold}
hard_cap: {hard_cap}
gate_loop_enabled: {gate_loop_enabled}
gate_threshold: {gate_threshold}
stagnation_delta: {stagnation_delta}
stagnation_window: {stagnation_window}
soft_cap: {soft_cap}
ak_double_check: {ak_double_check}
project_type: {project_type}
Return the interview-question JSON block per agents/misae.md contract.")
Parse the last ```interview-question ... ``` fenced block in result.
# FR-1 / AC1: zero-turn fast path on first invocation
if turn == 1 and parsed.status == "done" and parsed.reason in {"pre_interview_clear", "user_skip_override"}:
exit_reason = parsed.reason
break # skip the loop entirely; jump to FINALIZE_DRAFT with answers == []
GUARD (parsing / options integrity / FR-4 contract):
Validate ALL of the following before calling AskUserQuestion:
(a) An `interview-question` fenced JSON block exists and parses.
(b) `status` is "ask" or "done".
(c) If status == "ask":
- `question` is a non-empty string (>= 5 chars).
- `options` is an array with >= 2 entries (no upper bound).
- Every option has a `label` that is a non-empty string
(>= 2 chars, NOT whitespace-only, NOT just "A." / "B." prefix).
- `header` is a non-empty string.
- **(FR-4)** `targets_subscore` is one of {"goal_clarity", "constraint_clarity", "success_criteria"}.
- **(FR-4)** `closes_unknown` is a non-empty string ≤ 80 chars.
(d) If status == "done":
- `reason` is one of {"pre_interview_clear", "clarity_threshold_met",
"user_skip_override",
"stagnation_escalate", "soft_cap_escalate",
"no_more_actionable_gaps_escalate", "hard_cap_escalate", # gate_loop_enabled: true
"hard_cap_reached", "no_more_actionable_gaps"}. # legacy (gate_loop_enabled: false)
On ANY validation failure:
Re-invoke Misae with mode=DESIGN_NEXT_QUESTION, appending to the prompt:
"CRITICAL: Your previous response failed validation: {specific reason,
e.g. 'targets_subscore missing or not in {goal_clarity|constraint_clarity|success_criteria}',
'closes_unknown empty or > 80 chars', 'options[1].label was empty',
'no interview-question block found', 'question string too short'}.
Re-read agents/misae.md § Parent-Orchestrated Interview Protocol.
Emit EXACTLY ONE fenced block tagged `interview-question` containing:
non-empty question (>=5 chars), non-empty header, 2 이상 options each
with substantive label, AND (FR-4) `targets_subscore` in
{goal_clarity|constraint_clarity|success_criteria} AND `closes_unknown`
string ≤ 80 chars."
Retry up to 2 times.
On 3rd failure: abort the interview, print the raw Misae output
verbatim to the user, and STOP.
If status == "done":
exit_reason = parsed.reason # propagated to FINALIZE_DRAFT
break
If status == "ask" (and guard passed):
// OPTIONS OVERFLOW HANDLING:
// AskUserQuestion tool allows max 4 options per call.
// When Misae returns > 4 options, paginate:
if options.length <= 4:
user_answer = AskUserQuestion(questions=[{
question, header, options, multiSelect
}])
else:
// Split: first 3 options + "더 많은 선택지 보기"
page1 = options.slice(0, 3)
page1.push({label: "더 많은 선택지 보기", description: "추가 옵션을 확인합니다"})
user_answer = AskUserQuestion(questions=[{
question, header, options: page1, multiSelect: false
}])
if user_answer == "더 많은 선택지 보기":
// Show remaining options (up to 4 per page, repeat if needed)
remaining = options.slice(3)
while remaining.length > 0:
page = remaining.slice(0, 4)
remaining = remaining.slice(4)
if remaining.length > 0:
page = page.slice(0, 3)
page.push({label: "더 많은 선택지 보기", description: "추가 옵션을 확인합니다"})
remaining = options.slice(3 + (pageNum * 3)) // adjust offset
user_answer = AskUserQuestion(questions=[{
question, header, options: page, multiSelect: false
}])
if user_answer != "더 많은 선택지 보기": break
answers.push({turn, question, answer: user_answer})
2A.1b — ESCALATE 3-way prompt (FR-3, gate_loop_enabled: true):
When the loop exits with an ESCALATE reason, do NOT silently proceed and do NOT loop
forever — hand the user a 3-way choice. (clarity_threshold_met / pre_interview_clear
/ user_skip_override skip this block and go straight to 2A.2.)
ESCALATE_REASONS = {"stagnation_escalate", "soft_cap_escalate",
"no_more_actionable_gaps_escalate", "hard_cap_escalate"}
while gate_loop_enabled and exit_reason in ESCALATE_REASONS:
current_score = parsed.clarity_score.get("weighted_overall") or parsed.clarity_score.get("overall", "?")
unresolved = parsed.get("remaining_unknowns") or []
choice = AskUserQuestion(questions=[{
"question": "인터뷰가 [{exit_reason}]로 종료 기준({gate_threshold})을 충족하지 못했습니다.\n"
"현재 weighted_overall: {current_score} (목표 {gate_threshold})\n미해결: {unresolved}",
"header": "인터뷰 에스컬레이션",
"options": [
{"label": "A. 인터뷰 계속 진행", "description": "추가 질문으로 명확도를 더 끌어올립니다 (hard_cap까지)"},
{"label": "B. Open Questions로 기록 후 진행", "description": "미해결 항목을 REQUESTS.md에 남기고 다음 스테이지로"},
{"label": "C. 인터뷰 처음부터 다시", "description": "이전 답변을 초기화하고 재시작"}
],
"multiSelect": false
}])
# HR-1 audit: persist choice + score
write_to_state({"current.interview.escalation_choice": choice})
append_history({"event": "escalation_prompt", "agent": "shinnosuke",
"exit_reason": exit_reason, "weighted_overall": current_score, "escalation_choice": choice})
if choice == "A": # continue — re-enter the interview loop up to hard_cap (NFR-3)
exit_reason = null
resume the 2A.1 loop from turn+1 (do NOT reset answers); re-evaluate on next done
elif choice == "C": # restart
answers = []; exit_reason = null; turn = 0; restart the 2A.1 loop
else: # B — fall through to 2A.2 with exit_reason intact (Open Questions written)
break
2A.2 — Finalize draft (Misae writes REQUESTS.md + runs AK review):
Task(subagent_type="team-shinchan:misae", model="sonnet",
prompt=`mode: FINALIZE_DRAFT
DOC_ID: ${DOC_ID} | WORKFLOW_STATE: .shinchan-docs/${DOC_ID}/WORKFLOW_STATE.yaml
answers: ${JSON.stringify(answers)}
user_request: ${args}
vision_context: ${vision_context or 'None'}
exit_reason: ${exit_reason || 'clarity_threshold_met'}
gate_loop_enabled: ${gate_loop_enabled} | ak_double_check: ${ak_double_check}
Per agents/misae.md: run the materiality audit (step 0, only when exit_reason == clarity_threshold_met and gate_loop_enabled), write REQUESTS.md (include ## Open Questions if exit_reason in the ESCALATE/legacy-gap set), run mechanical check, run AK review loop (max 2 retries). Return finalize-result JSON block.`)
Parse the finalize-result JSON block.
next == "materiality_reject" (gate-loop materiality audit failed) → re-enter the
2A.1 interview loop from turn+1 with failed_item re-added to unresolved_unknowns
(do NOT reset prior answers), then re-run 2A.2. This keeps the gate honest: a PASS score
is necessary but not sufficient — material ambiguity sends it back.next == "closure_reject" (WS-03 4a — Misae withheld analyst-acceptance with a new
actionable gap, main-075 benchmark adoption) → treat exactly like materiality_reject:
re-enter the 2A.1 loop from turn+1 with failed_item re-added to unresolved_unknowns
(do NOT reset answers), then re-run 2A.2. The 2-loop cap in Misae's WS-03 guarantees this
cannot loop forever — after 2 closure loops Misae proceeds and logs the residual gap to
## Open Questions instead of rejecting.restated_goal is present on the result (WS-03 4b — OPTIONAL additive field) → carry it
into the Phase E-2 approval prompt below so the user confirms the one-sentence goal.ak_verdict == "APPROVED" → continue to 2A.3.ak_verdict == "ESCALATED" → show rejection_reasons to user and stop (user decides next step per Misae Phase E-4).2A.3 — Phase E-2 user approval (parent drives AskUserQuestion):
# WS-03 4b: if finalize-result carried restated_goal, prepend it so the user confirms the
# one-sentence goal alongside approval (main-075 benchmark adoption). Optional — omit if absent.
restate_line = ("목표 확인: " + restated_goal + "\n\n") if restated_goal else ""
user_decision = AskUserQuestion(questions=[{
question: restate_line + "REQUESTS.md을 승인하시겠어요?",
header: "최종 승인",
options: [
{label: "A. 승인 — Stage 1.5 (Design)로 진행", description: "요구사항 확정 → Hiroshi와 설계를 진행합니다"},
{label: "B. 수정 필요 — 피드백 제공", description: "어떤 부분을 바꿔야 하는지 알려주세요"}
],
multiSelect: false
}])
If user picked B:
feedback = AskUserQuestion free-form or prompt user to describe changes
Task(misae, mode: REVISE, user_feedback: feedback) // loops back through AK
Repeat 2A.3.
If user picked A (or equivalent):
Task(subagent_type="team-shinchan:misae", model="sonnet",
prompt=`mode: TRANSITION
DOC_ID: ${DOC_ID}
User approved REQUESTS.md. Apply your TRANSITION mode.`)
Single source of truth for the destination stage = the agent's
Mode: TRANSITIONblock. Do NOT name a destination stage in this prompt and do NOT writecurrent.stagefrom the skill — Misae's TRANSITION already targets the design stage. (Naming "planning" here was the v4.45.0 bug that skipped Stage 1.5.) The next step is the design stage (Step 2B); design is only skipped via the explicit Step 2B skip conditions, evaluated in Step 2B.
Misae has performed hidden requirements analysis as part of FINALIZE_DRAFT. Misae's TRANSITION
moves the workflow to stage: design (owner: hiroshi). Once TRANSITION returns, proceed to
Step 2B (Design Stage).
CRITICAL: Sub-agents cannot call AskUserQuestion. Exactly like the requirements interview
(2A), the main thread drives the design interview; Hiroshi designs each decision. See
agents/hiroshi.md § "Design Stage Interview Protocol".
Skip conditions — design is DEFAULT-ON; skip is the narrow exception. Skip ONLY when one of these is unambiguously true (when in doubt, do NOT skip — run the loop):
user_request/args contains the literal token skip-design, ORDesign decisions: none — {reason} style waiver is warranted.A multi-FR feature, anything with ## Open Questions that are design-shaped (layouts, ranges,
contracts, new keys), or any "approach A vs B" is NOT skippable — run the design loop.
When (and only when) a skip condition holds: narrate "Design stage skipped ({which condition})"
and run Task(subagent_type="team-shinchan:hiroshi", prompt="mode: TRANSITION\nDOC_ID: {DOC_ID}\nDesign skipped ({reason}). Apply your TRANSITION mode.") to advance to the next stage — do
NOT write current.stage from the skill (the destination lives in hiroshi.md's TRANSITION). Then
go to Step 2C. Otherwise run the loop below.
2B.0 — Read design interview config (.shinchan-config.yaml, else defaults):
design.soft_cap (default 5), design.hard_cap (default 8).
2B.1 — Design decision loop (design-completeness-gated, hard_cap is the ceiling):
decisions = []
exit_reason = null
for turn in 1..design_hard_cap:
result = Task(subagent_type="team-shinchan:hiroshi", model="opus", prompt=
"mode: DESIGN_NEXT_DECISION
DOC_ID: {DOC_ID} | WORKFLOW_STATE: .shinchan-docs/{DOC_ID}/WORKFLOW_STATE.yaml
REQUESTS.md: .shinchan-docs/{DOC_ID}/REQUESTS.md
turn: {turn}
prior_decisions: {decisions}
user_request: {args}
vision_context: {vision_context or 'None'}
soft_cap: {design_soft_cap} | hard_cap: {design_hard_cap}
Return the design-question JSON block per agents/hiroshi.md contract.")
Parse the last ```design-question ... ``` fenced block in result.
GUARD (mirror 2A.1): a `design-question` block must parse; `status` ∈ {ask, done};
if status == "ask": `question` ≥ 5 chars, `header` non-empty, `options` ≥ 2 each with a
substantive `label`, `decision_id` present, `closes_decision` ≤ 80 chars.
On failure: re-invoke Hiroshi with the specific reason appended, max 2 retries; on 3rd
failure print raw output and STOP.
if status == "done":
exit_reason = parsed.reason; break
if status == "ask" (guard passed):
// Same options-overflow pagination as 2A.1 (>4 options → "더 많은 선택지 보기").
user_answer = AskUserQuestion(questions=[{question, header, options, multiSelect}])
decisions.push({turn, decision: parsed.closes_decision, choice: user_answer})
2B.1b — ESCALATE 3-way prompt (when exit_reason ∈ {soft_cap_escalate, hard_cap_escalate}):
hand the user a choice exactly like 2A.1b — A. 설계 계속 (hard_cap까지), B. Open Questions로 기록 후
진행, C. 처음부터. (design_complete / user_skip_override skip this and go to 2B.2.)
2B.2 — Finalize design (Hiroshi writes DESIGN.md + runs AK review):
Task(subagent_type="team-shinchan:hiroshi", model="opus",
prompt=`mode: FINALIZE_DESIGN
DOC_ID: ${DOC_ID} | REQUESTS.md: .shinchan-docs/${DOC_ID}/REQUESTS.md
decisions: ${JSON.stringify(decisions)}
exit_reason: ${exit_reason || 'design_complete'}
Per agents/hiroshi.md: write DESIGN.md (## Open Questions only if escalated), run the
design-stage AK review loop (max 2 retries). Return finalize-design-result JSON block.`)
Parse the finalize-design-result block.
ak_verdict == "APPROVED" → continue to 2B.3.ak_verdict == "ESCALATED" → show rejection_reasons to user and stop.2B.3 — User approval of DESIGN.md (parent drives AskUserQuestion):
user_decision = AskUserQuestion(questions=[{
question: "DESIGN.md(설계)를 승인하시겠어요?",
header: "설계 승인",
options: [
{label: "A. 승인 — Stage 2 (Planning)로 진행", description: "이 설계대로 Nene가 계획 수립"},
{label: "B. 수정 필요 — 피드백 제공", description: "어떤 설계를 바꿔야 하는지 알려주세요"}
],
multiSelect: false
}])
If B: Task(hiroshi, mode: REVISE, user_feedback: feedback) → repeat 2B.3.
If A: Task(subagent_type="team-shinchan:hiroshi", model="opus",
prompt="mode: TRANSITION\nDOC_ID: {DOC_ID}\nUser approved DESIGN.md. Apply your TRANSITION mode.")
Destination stage is defined by hiroshi.md's
Mode: TRANSITION(→ planning) — do not restate it here or writecurrent.stagefrom the skill.
Once TRANSITION returns, proceed to Step 2C.
Shinnosuke 호출 전에 사용자에게 직접 알린다:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
👦 [Shinnosuke] Stage 1.5 완료 ✅ 설계 확정됨 (DESIGN.md)
→ Stage 2: Planning 시작합니다. Nene가 설계대로 Phase를 구성합니다.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Then invoke Shinnosuke:
Task(subagent_type="team-shinchan:shinnosuke", model="opus",
prompt="Continue from Stage 2 via /team-shinchan:start.
DOC_ID: {DOC_ID} | REQUESTS.md: approved | DESIGN.md: approved (architecture settled in Stage 1.5).
Stages 1 + 1.5 DONE. Start Stage 2 (Planning) via Nene, then Stage 3 (Execution), then Stage 4 (Completion).
CRITICAL: After Stage 3, you MUST execute Stage 4 — write RETROSPECTIVE.md, IMPLEMENTATION.md, and run final Action Kamen review. See 'Stage 4: Completion' section in agents/shinnosuke.md.
## Learning-capture vs heavy completion (main-076 FR-7)
Learning/eval capture is the EXECUTION stage's definition-of-done — hooks/session-wrap.sh writes
a deterministic skeleton each execution Stop and nudges the retrospective ONCE per stage. The
heavy IMPLEMENTATION.md + comprehensive Action Kamen final review is a SEPARATE, push-gated
formal completion. Never lump the two: skipping the heavy completion must not skip learning
capture, and a captured learning does not substitute for the formal review.
## Micro-Task Execution (RULE 2.7) — MANDATORY, this is the /start default
WORKFLOW_STATE.current.execution_mode is `micro-execute`. Stage 3 MUST run via the
micro-execute path — do NOT fall back to the standard Phase Loop and do NOT use the
dag-executor (that path skips the per-task review chain and is opt-in only).
When invoking Nene for Stage 2 planning, request MICRO-TASK FORMAT for PROGRESS.md
(agents/nene.md 'Micro-Task Plan Format' — NOT the DAG Plan Schema). Nene plans AGAINST the
approved DESIGN.md (architecture is already decided — do NOT re-decide it). Each phase should be
broken into 2-3 minute tasks with exact file paths, complete code, and verification commands.
In Stage 3, use the micro-execute pattern (RULE 2.7): for EACH micro-task, dispatch a fresh
implementer subagent → spec-compliance review → code-quality review → independent skeptic
refutation. Never skip any of these four steps. See skills/micro-execute/SKILL.md for the
full execution protocol.
Nene's summary: {nene_result_summary}")
The executing stage has two dispatch modes, selected by current.execution_mode in
WORKFLOW_STATE.yaml (set in Step 1):
micro-execute (DEFAULT for /start) — each task runs through the full per-task review
chain: implementer → spec-compliance review → code-quality review → independent skeptic
refutation (skills/micro-execute/SKILL.md). This is the accuracy backbone; do NOT bypass it.
Stage 2B already requests MICRO-TASK FORMAT from Nene so PROGRESS.md feeds this mode directly.dag (OPT-IN ONLY) — the DAG-driven dispatch below. Faster via parallelism, but its only
per-task gate is the verify shell command exit code — it does NOT run the spec/quality/skeptic
review chain. Use ONLY when the user explicitly opts in (sets execution_mode: dag) and accepts
the weaker per-task verification. Never the silent default.⚠️ Routing rule: if
execution_modeismicro-executeor absent → use micro-execute (RULE 2.7). Only whenexecution_mode: dagis explicitly set do you follow the DAG protocol below.
execution_mode: dag only)When opted in, the executing stage drives implementation as a topologically-ordered task DAG
using src/dag-executor.js instead of an ad-hoc sequential loop (FR-9). The
requirements → planning → executing → done stage machine is preserved; only the executing
stage's dispatch logic changes.
Protocol for the executing stage:
src/dag-executor.js parsePlan() reads the six-field schema —
id / depends_on / touches / verify / estimate / scope — from PLAN.md or a structured object).topoSort() orders tasks by depends_on and throws on a circular dependency before any
task is dispatched (no partial execution).buildConflictGraph() + connectedComponents() compute the static conflict graph from
touches[]: tasks in the same component serialize; disjoint components dispatch in parallel
up to executor.concurrency_cap (.shinchan-config.yaml, default 4) — mapped onto the
Workflow parallel() primitive.verify command must exit 0 to be
marked DONE; an absent/NL-only verify is FAILED (never a silent SKIP), and downstream
dependents become BLOCKED.plan_meta.integration_test)
runs; if absent it warns but does not block.evaluateCompletionGate()) enforces strict ALL-PASS — zero
FAILED/SKIP, all DONE, integration passing — and blocks the executing → done stage
transition otherwise.Serial-fallback / escape hatch (high coupling): when the conflict graph collapses to a
single connected component (every task shares a resource), execution is fully serial and the
executor logs an NFR-5 warning (serial_fallback: true in .shinchan-config.yaml). This mirrors
the gate_loop_enabled-style escape so operators can inspect plan granularity rather than chase
phantom parallelism.
See src/dag-executor.js and docs/dag-executor.md for the module contract.