Типи задач і заповнені артефакти

{
  "permissions": { "defaultMode": "ask" },
  "source": "documented example",
  "secrets": "never stored here"
}

# TASK_SPEC.md
Goal: оператор може додати необов'язкову нотатку до refund.
Scope: форма, endpoint, storage contract і targeted tests.
Non-goals: payment rules, approval flow, unrelated UI.
Verification: note зберігається та повертається в деталях.
Status: documented example; execution result: Unknown.

# EVIDENCE.md
Criterion: empty-cart request is handled predictably
Signal: one response with agreed error body
Check: <targeted API test — command to verify>
Fail: server error or changed valid-order response
Status: planned documented example; result: Unknown.

# ISSUE_INTAKE_NOTE
Problem: empty items list causes a server error.
Impact: customer cannot complete checkout.
Evidence: reproducible request and service trace.
Requirement: handle the state predictably.
Hypothesis: total calculation reads an absent item.
Open question: expected API status and error body.
Out of scope: checkout redesign.
Status: documented example.

# PLAN.md
Goal: handle empty-cart input without changing valid orders.
1. Reproduce and record failing case.
2. Add domain guard and focused test.
3. Confirm API mapping with contract test.
4. Review diff and adjacent scenarios.
Stop: shared pricing behavior needs a broader decision.
Rollback: revert the single slice.
Status: documented example.

{
  "symptom": "page becomes empty after invalid login",
  "evidence": ["reproduction steps", "<log path>"],
  "hypothesis": "error mapping drops the response",
  "confidence": "Unknown",
  "nextAction": "inspect handler and related test",
  "mode": "read-only documented example"
}

# CODEBASE_INVENTORY.md
## Stack
- Language/framework: <inspect manifests>
## Entry points
- HTTP: <path — verify>
- Jobs: Unknown
## Commands
- Test: <repository script — verify>
## Risk zones
- auth, payments, migrations: inspect before edit
## Open questions
- ownership and runtime deployment: Unknown
Status: documented example.

{
  "symptom": "empty items[] returns server error",
  "evidence": ["request fixture", "service trace"],
  "hypothesis": "total calculation reads absent first item",
  "confidence": "needs verification",
  "nextAction": "add regression case before editing",
  "status": "documented example"
}

# REFACTORING_PLAN.md
Goal: виділити округлення рахунку в одну internal responsibility.
Allowed files: BillingService і focused tests.
Preserve: signature, totals, error codes, side effects.
Steps: inspect callers; extract smallest function; run checks; review diff.
Stop: output or scope changes. Rollback: baseline checkpoint.
Status: documented example.

# CHARACTERIZATION_TESTS.md
Flow: BillingService.calculateInvoice
Case: valid line items -> existing total
Case: invalid line item -> existing validation error
Case: rounding boundary -> record observed value
Side effects: Unknown; inspect logs and collaborators.
Purpose: protect current behavior before structural change.
Status: documented example; tests not executed.

# CONTRACT.md
Scenario: empty refund reason
Given: form is open and reason is blank
When: operator submits
Then: request is not sent and a field error is visible
Compatibility: POST /api/orders/{id}/refund remains unchanged.
Status: documented contract; execution: Unknown.

# research-digest.md
Audience: developer joining the repository
Confirmed: start command is <repo script — verify>
Confirmed: tests live at <path — verify>
Unknown: deployment environment and production permissions
Sources: <file paths and commands>
Status: documented example; no live inspection recorded.

# PR_DESCRIPTION
Intent: add the empty-cart domain guard.
Files: order service and focused test.
Verification: empty-cart regression plus valid-order check.
Out of scope: API redesign, UI changes, unrelated cleanup.
Rollback: revert this slice.
Status: documented example; checks: Unknown.

# HANDOFF_NOTE.md
Done: baseline and one approved slice prepared.
Checked: <commands and results — Unknown>
Risk: shared caller behavior not fully inspected.
Checkpoint: <Git reference>
Next: fresh reviewer checks scope and evidence.
Stop: diff leaves the agreed module.
Status: documented example.

# workflow.md
Capability: inspect one issue and return a Markdown summary.
Input boundary: sanitized issue text only.
Permissions: read-only; no publish or deploy.
Trial: log-only for one controlled case.
Verification: output schema and data boundary review.
Kill switch: disable integration before widening scope.
Status: documented example.

# CONTRACT.md
Role: reviewer-agent
Input: one proposed diff and task scope
Read: changed files, related tests, task spec
Run: targeted checks only
Write: findings with file, evidence, confidence
Stop: scope conflict or missing baseline
Human gate: owner decides merge
Status: documented example.

status: failed
job: test
classification: Unknown
first_signal: <log line>
reproduced_locally: Unknown
secrets_removed: true
next_action: inspect focused test and environment
approval_required: true
status_record: documented example

# commands.md
Build: <repository build command>
Package: <clean packaging command>
Run: <local smoke command>
Expected: artifact exists and endpoint responds as specified.
Failure owner: <role>
Release action: human approval required.
Status: commands are a documented example; execution: Unknown.

# workflow.md
Gate: targeted verification for changed API contract
Signal: test status and response assertion
Mode: advisory until baseline is established
Block when: contract assertion fails
Evidence: command, status, relevant output
Owner: <team role>
Recovery: inspect, rerun only with reason, or disable with approval
Status: documented example.

# AI_CODING_POLICY.md
Allowed: read-only discovery, bounded drafts, targeted checks.
Controlled: edits in protected paths and shared workflow assets.
Forbidden: secrets in prompts, unapproved deploys, bypassing review.
Approval: owner of the affected boundary.
Evidence: task spec, diff, checks and review note.
Status: documented policy example; enforcement: Unknown.

# CAPSTONE_BRIEF.md
Problem: make one repository workflow easier to verify.
Audience: developer reviewing a bounded change.
Core flow: intake -> plan -> implementation -> evidence.
In scope: one representative scenario and its checks.
Out of scope: full product, deployment and scale claims.
Demo evidence: commands and outputs — Unknown.
Status: documented example.

# VALUE_PROPOSITION.md
User: reviewer of a bounded repository change
Problem: evidence is scattered across notes and command output
Alternative: manual search through the diff and task thread
Promise: produce one reviewable evidence outline before implementation
Proof signal: reviewer can locate scope, checks and Unknowns in one pass
Status: documented example; user validation is Unknown.

# USER_JTBD.md
User: reviewer of one repository workflow
Trigger: a small change has unclear evidence boundaries
Job: understand scope, checks and Unknowns before deciding next step
Desired outcome: complete one review pass without repeating discovery
Constraints: no production claims or secret values
Status: documented example; observed user behavior is Unknown.

# SUCCESS_METRIC.md
Name: evidence-location completion rate
Definition: share of review passes where scope, checks and Unknowns are found in one pass
Baseline: Unknown
Target: define before implementation; measured outcome: Unknown
Window: bounded capstone review session
Guardrail: do not trade evidence quality for speed
Status: documented example; no measured outcome is claimed.

# RELEASE_SLICE.md
Core flow: intake -> AI-assisted outline -> human review -> evidence note
In scope: one flow, one metric and one reviewer checklist
Non-goals: autonomous merge, deployment and broad roadmap
Dependencies: repository baseline and agreed evidence format
Release criteria: reviewer can reproduce the outline and locate Unknowns
Status: documented example; no release or deployment is claimed.

# CONTROLLED_VIBE_CODING.md
Goal: implement one bounded capstone change
Allowed paths: <explicit files>
Expected diff: one behavior; no unrelated cleanup
Check: targeted verification and human diff review
Stop when: scope drifts or oracle is missing
Status: documented example; execution result: Unknown.

# IMPLEMENTATION_SPRINT_PLAN.md
Outcome: one reviewable capstone increment
Slices: contract -> implementation -> verification -> review
Checkpoint: inspect diff and status after each slice
Exit: DONE, CONTINUE WITH APPROVAL or HOLD
Status: documented example; sprint execution: Unknown.

# DEMO.md
Audience: reviewer or capstone evaluator
Core flow: <bounded scenario>
Entry point: <safe command or manual start>
Steps: <observable actions and expected signals>
Known limits: <unsupported cases and Unknowns>
Status: documented example; demo outcome: Unknown.

# DEMO_QUALITY_GATE.md
Blocking: startup, core output and acceptance evidence
Advisory: polish and deferred edge cases
Evidence: <commands or anchors>
Decision: GO / HOLD / REDO
Status: documented example; gate result: Unknown.

# DEMO_READINESS.md
Start: <safe command or manual entry point>
Inputs: <fixtures without secrets>
Expected signal: <observable output>
Fallback: <static or manual path>
Deployment boundary: no publish/deploy claim
Status: documented example; readiness result: Unknown.

# EVIDENCE_LOG.md
Claim: <what is being checked>
Source: <file, command or observation>
Result: <observed result or Unknown>
Decision: <continue / revise / HOLD>
Status: documented example; no deployment or production claim.

# CAPSTONE_DEFENSE_HANDOFF.md
Problem: <bounded problem>
Demo path: <observable steps>
Evidence: <links or anchors>
Known limits: <Unknowns and unsupported cases>
Decision requested: GO / HOLD / feedback
Status: documented example; defense outcome: Unknown.

# HANDOFF_PACKAGE.md
Summary: <bounded problem, user and scope>
Demo: <DEMO.md anchor>
Evidence log: <EVIDENCE_LOG.md anchor>
Readiness: <DEMO_READINESS.md anchor>
Decision: GO / HOLD / feedback
Status: documented example; handoff outcome: Unknown.

# SUBMISSION_PACKAGE.md
Problem: <bounded problem>
Core flow: <one observable scenario>
Start: <safe command or manual entry point>
Expected signal: <observable output>
Evidence: <diff, checks and notes>
Known limits: <unsupported cases and Unknowns>
Status: documented example; submission and reproducibility result: Unknown.

# REPRO_AUDIT.md
Starting state: <clean checkout or documented baseline>
Prerequisites: <versions, commands and safe fixtures>
Steps: <ordered reproduction actions>
Expected: <observable signal>
Observed: <result or Unknown>
Environment gaps: <missing permissions, data or dependencies>
Decision: <reproducible / needs verification / HOLD>
Status: documented example; audit execution: Unknown.

# DEFENSE_NARRATIVE.md
Audience: <reviewer or evaluator>
Problem: <bounded problem and user>
Claim: <what this capstone slice demonstrates>
Path: <actions and expected signals>
Evidence anchors: <files, commands or notes>
Known limits: <Unknowns and unsupported cases>
Decision requested: <GO / HOLD / feedback>
Status: documented example; defense outcome: Unknown.

# CAPSTONE_RUBRIC.md
Dimension: <problem / flow / scope / verification / evidence / communication>
Expected signal: <observable criterion>
Evidence required: <file, command or demo anchor>
Status scale: <not shown / partial / shown / needs verification>
Weight: <agreed value or Unknown>
Decision boundary: <GO / HOLD / remediation>
Status: documented example; rubric application and score: Unknown.

# REMEDIATION_BACKLOG.md
Source review: <mentor/reviewer note or Unknown>
Priority: <Must fix / Should fix / Later>
Finding: <observed gap>
Evidence: <anchor or Unknown>
Owner: <role or Unknown>
Acceptance signal: <observable check>
Status: Needs verification
Boundary: this backlog does not prove mentor approval or completed remediation.

# PORTFOLIO_PACKAGE.md
Title: <capstone name>
Problem and audience: <bounded context>
Role/contribution: <verified contribution or Unknown>
Core flow: <short observable scenario>
Selected evidence: <submission, demo, checks and review anchors>
Evaluation: <rubric summary or Unknown>
Review outcome: <observed decision or Unknown>
Limitations: <unsupported claims and open questions>
Next step: <remediation item or bounded follow-up>
Status: documented example; portfolio publication and external validation: Unknown.

# AI_NATIVE_POSITIONING.md
Problem: <bounded problem or workflow>
Ownership: <decisions and responsibilities>
AI assistance: <where tools helped>
Evidence: <verified source or Unknown>
Boundary: <claims not supported by this record>
Status: documented example; hiring outcome: Unknown.

# PROOF_OF_WORK_BANK.md
Claim: <one concrete statement>
Source: <file, diff, command or review note>
Signal: <observed result or Unknown>
Contribution: <what I owned>
Boundary: <what this does not prove>
Status: documented example; external validation: Unknown.

# CAREER_NARRATIVE.md
Level frame: <Junior / Middle / Senior>
Context: <problem and audience>
Ownership: <decisions and contribution>
Trade-offs: <choice and deferred alternative>
Evidence: <anchors or Unknown>
Next step: <bounded follow-up>
Status: documented example; seniority validation: Unknown.

# AI_NATIVE_RESUME.md
Headline: <bounded capability>
Evidence-backed outcome: <observable signal or Unknown>
Contribution: <what I owned>
Repository link: <verified link or Unknown>
Profile summary: <consistent narrative>
AI disclosure: <transparent assistance boundary>
Status: documented example; review and hiring outcome: Unknown.

# PORTFOLIO_DEFENSE.md
Problem: <bounded problem and audience>
My decisions: <framing, trade-offs and checks>
AI assistance: <generated or assisted parts>
Evidence path: <anchors and expected signals>
Unknowns: <open questions>
Decision requested: <feedback / next check>
Status: documented example; interview and hiring outcome: Unknown.

# TARGET_ROLE_STRATEGY.md
Role families: <target roles and responsibility>
Constraints: <location, format, level, time>
Evidence: <verified proof-of-work or Unknown>
Search hypotheses: <source and priority signal>
Next action: <one bounded manual check>
Boundary: applications, recruiter responses, interviews and hiring outcome are Unknown.
Status: documented example.

# JOB_FIT_GAP_MAP.md
Role/source: <vacancy and URL or Unknown>
Requirement status: Fit / Partial / Gap / Unknown
Evidence: <source or Unknown>
Confidence: <high/medium/low>
Next check: <bounded action>
Boundary: this is not an external assessment and does not prove hiring fit.
Status: documented example.

# APPLICATION_TAILORING.md
Target role: <role or Unknown>
Source claim: <verified experience or Unknown>
Role relevance: <why it matters>
Tailored wording: <bounded claim>
Not claimed: <missing metric, employer, outcome or review>
Human check: <required before external submission>
Status: documented example; application and hiring outcome: Unknown.

# APPLICATION_TRACKER.md
Role: <target role>
Source: <URL or Unknown>
Status: Research / Draft / Ready for review / Unknown
Next action: <one bounded action>
Evidence: <anchor or Unknown>
Privacy: no credentials, secrets or unnecessary personal data.
Boundary: tracker status does not prove submission, interview, response or employment.
Status: documented example.

# ASSESSMENT_FEEDBACK_LOOP.md
Assessment/source: <prompt, review note or Unknown>
Timebox and allowed tools: <bounded constraints>
Expected signal: <observable criterion>
Observed result: <result or Unknown>
Feedback status: received / requested / Unknown
Gap: <verified finding or personal hypothesis>
Next action: <one remediation step>
Boundary: assessment, interview, pass/fail and hiring outcome are Unknown unless separately evidenced.
Status: documented example.

# RISK_MAP.md
Area: BillingService.calculateInvoice
Business criticality: high — confirm with owner
Change risk: high — shared callers are Unknown
Evidence: <paths, tests, runtime observations>
Safe next step: characterize one bounded flow
Do not do: broad rewrite or dependency upgrade
Status: documented example.

# MODERNIZATION_BASELINE.md
Module: BillingService.calculateInvoice
Revision: <baseline commit — fill with evidence>
Inputs: customer, period, line items
Outputs: total and validation errors
Invariants: rounding and error codes remain unchanged
Checks: <focused command — Unknown until executed>
Unknowns: callers relying on internal ordering
Status: documented example.

# MIGRATION_PLAN.md
Mode: migration
Source: current runtime and dependency state — repository evidence required
Target: target runtime/framework state — compatibility Unknown
Pilot: one read-only endpoint in an isolated branch/worktree
Entry gates: baseline, migration type map, compatibility matrix, rollback owner and checkpoint
Validation: source/target representative cases, config/startup and integrity checks
Decision: HOLD until gates and recovery procedure are verified
Status: documented example.

# MIGRATION_TYPES.md
| Work item | Type | Coupled with | Evidence gate | Owner | Status |
| --- | --- | --- | --- | --- | --- |
| framework change | code/dependency | config, behavior | changelog and focused checks | role | Unknown |
| record transition | schema/data | target code, recovery | integrity and parity cases | role | HOLD |
| environment key mapping | configuration | startup, secret references | config validation | role | Unknown |
Decision: classify and order before execution.
Status: documented example.

# DATA_CONFIG_MIGRATION.md
Data: source representation -> target representation; inventory and compatibility window required
Configuration: versioned keys/defaults per environment; secret values excluded
Sequence: expand compatible readers -> bounded migration -> validate -> switch -> contract
Validation: counts, invariants, representative reads/writes and startup — Unknown until executed
Recovery: approved backout or forward-fix with owner; HOLD if state rollback is not verified
Status: documented example.

# ROLLBACK.md
Scope: one bounded pilot slice in an isolated branch/worktree
Trigger: behavior discrepancy, integrity failure, or unavailable recovery evidence
Checkpoint: source revision plus versioned config/state checkpoint
Actions: stop affected traffic -> restore code -> restore config -> backout state or choose forward-fix
Verification: representative behavior and invariants — Unknown until executed
Decision: HOLD until recovery steps are verified
Status: documented example.

# MIGRATION_VALIDATION_REPORT.md
Baseline: source revision and target revision must be recorded before comparison
Cases: representative inputs, outputs, errors, side effects, integrity, configuration and startup
Evidence: matching test, fixture, command or log anchor for each dimension
Observed: Unknown; no source-to-target validation was executed
Decision: HOLD while evidence or oracle is missing
Status: documented example.

# POST_MIGRATION_NOTES.md
Scope: bounded pilot and observation window — Unknown until defined
Decision: GO, HOLD, NARROW or ROLLBACK based on evidence
Observations: expected versus observed behavior, data/configuration and operational signals
Residual risk: record each Unknown with an owner and next bounded action
Handoff: summarize evidence anchors and lessons without secret values
Status: documented example; no post-migration outcome is claimed.