cyc-stack 0.0.0-stage → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (111) hide show
  1. package/.agents/plugins/marketplace.json +12 -0
  2. package/.claude-plugin/marketplace.json +14 -0
  3. package/.claude-plugin/plugin.json +17 -0
  4. package/.codex-plugin/plugin.json +33 -0
  5. package/.cursor-plugin/marketplace.json +13 -0
  6. package/.cursor-plugin/plugin.json +19 -0
  7. package/INSTALL.md +153 -0
  8. package/LICENSE +21 -0
  9. package/README.md +436 -2
  10. package/bin/cyc.mjs +294 -0
  11. package/catalog/playbooks.json +20 -0
  12. package/docs/README.md +30 -0
  13. package/docs/assets/cyc-method-library.svg +39 -0
  14. package/docs/assets/cyc-overview.svg +44 -0
  15. package/docs/assets/cyc-readme-banner-mobile.svg +31 -0
  16. package/docs/assets/cyc-readme-banner.svg +39 -0
  17. package/docs/assets/cyc-workflow-diagram.svg +415 -0
  18. package/docs/code-quality.md +42 -0
  19. package/docs/context.md +40 -0
  20. package/docs/cyc-method-map.md +58 -0
  21. package/docs/cyc-workflow.md +188 -0
  22. package/docs/engineering/code-standards.md +103 -0
  23. package/docs/engineering/domain-design.md +81 -0
  24. package/docs/engineering/failure-handling.md +105 -0
  25. package/docs/impact-analysis.md +70 -0
  26. package/docs/installation.md +198 -0
  27. package/docs/onboarding-recovery.md +75 -0
  28. package/docs/principles.md +49 -0
  29. package/docs/project-tools.md +108 -0
  30. package/docs/response-standard.md +202 -0
  31. package/docs/runtime.md +249 -0
  32. package/docs/skill-contract.md +70 -0
  33. package/docs/skill-craft.md +23 -0
  34. package/docs/validation.md +39 -0
  35. package/docs/work-assessments.md +180 -0
  36. package/hooks/claude.json +10 -0
  37. package/hooks/codex.json +28 -0
  38. package/hooks/cursor.json +8 -0
  39. package/methods/cyc-build/SKILL.md +65 -0
  40. package/methods/cyc-build/references/file-writes.md +11 -0
  41. package/methods/cyc-challenge/SKILL.md +48 -0
  42. package/methods/cyc-context/SKILL.md +76 -0
  43. package/methods/cyc-context/references/evidence.md +27 -0
  44. package/methods/cyc-context/references/templates.md +54 -0
  45. package/methods/cyc-context/scripts/evidence.mjs +61 -0
  46. package/methods/cyc-correct/SKILL.md +43 -0
  47. package/methods/cyc-deliver/SKILL.md +52 -0
  48. package/methods/cyc-design/SKILL.md +50 -0
  49. package/methods/cyc-design/frontend-design/SKILL.md +43 -0
  50. package/methods/cyc-design/frontend-design/references/color.md +77 -0
  51. package/methods/cyc-design/frontend-design/references/craft-rules.md +61 -0
  52. package/methods/cyc-design/frontend-design/references/decision-sheet.md +110 -0
  53. package/methods/cyc-design/frontend-design/references/experience-review.md +58 -0
  54. package/methods/cyc-design/frontend-design/references/generic-tells.md +76 -0
  55. package/methods/cyc-design/frontend-design/references/layout-archetypes.md +188 -0
  56. package/methods/cyc-design/frontend-design/references/reference-standards.md +38 -0
  57. package/methods/cyc-design/frontend-design/references/typography.md +51 -0
  58. package/methods/cyc-design/frontend-design/references/ux-foundations.md +45 -0
  59. package/methods/cyc-design/frontend-design/references/visual-material.md +42 -0
  60. package/methods/cyc-error-ledger/SKILL.md +53 -0
  61. package/methods/cyc-error-ledger/references/entry-format.md +38 -0
  62. package/methods/cyc-explore/SKILL.md +41 -0
  63. package/methods/cyc-frame/SKILL.md +49 -0
  64. package/methods/cyc-impact/SKILL.md +64 -0
  65. package/methods/cyc-reflect/SKILL.md +48 -0
  66. package/methods/cyc-remember/SKILL.md +53 -0
  67. package/methods/cyc-scout/SKILL.md +67 -0
  68. package/methods/cyc-setup/SKILL.md +60 -0
  69. package/methods/cyc-teach/SKILL.md +40 -0
  70. package/methods/cyc-understand/SKILL.md +40 -0
  71. package/methods/cyc-understand/references/diagnose.md +53 -0
  72. package/methods/cyc-verify/SKILL.md +87 -0
  73. package/methods/cyc-verify/references/recipe.md +53 -0
  74. package/package.json +91 -4
  75. package/plugin.json +40 -0
  76. package/rules/cyc-delivery.mdc +33 -0
  77. package/scripts/baseline-worker.mjs +10 -0
  78. package/scripts/catalog.mjs +29 -0
  79. package/scripts/claude-project-hook.mjs +12 -0
  80. package/scripts/context-review.mjs +600 -0
  81. package/scripts/host-activation.mjs +66 -0
  82. package/scripts/install.mjs +387 -0
  83. package/scripts/onboarding.mjs +110 -0
  84. package/scripts/packet.mjs +107 -0
  85. package/scripts/project-tools.mjs +196 -0
  86. package/scripts/recovery.mjs +66 -0
  87. package/scripts/response-gate.mjs +105 -0
  88. package/scripts/response-hook.mjs +237 -0
  89. package/scripts/response-mode.mjs +12 -0
  90. package/scripts/run-gate.mjs +264 -0
  91. package/scripts/runtime.mjs +1832 -0
  92. package/scripts/source-hash-worker.mjs +5 -0
  93. package/scripts/source-snapshot.mjs +405 -0
  94. package/scripts/test-output.mjs +268 -0
  95. package/scripts/work-review.mjs +326 -0
  96. package/skills/cyc/SKILL.md +132 -0
  97. package/skills/cyc/references/playbooks/bug-fix.md +13 -0
  98. package/skills/cyc/references/playbooks/evaluate.md +13 -0
  99. package/skills/cyc/references/playbooks/experience.md +7 -0
  100. package/skills/cyc/references/playbooks/explore.md +9 -0
  101. package/skills/cyc/references/playbooks/feature.md +14 -0
  102. package/skills/cyc/references/playbooks/handoff.md +11 -0
  103. package/skills/cyc/references/playbooks/investigation.md +7 -0
  104. package/skills/cyc/references/playbooks/performance.md +7 -0
  105. package/skills/cyc/references/playbooks/plan.md +11 -0
  106. package/skills/cyc/references/playbooks/refactor.md +12 -0
  107. package/skills/cyc/references/playbooks/reflect.md +11 -0
  108. package/skills/cyc/references/playbooks/resume.md +11 -0
  109. package/skills/cyc/references/playbooks/review.md +9 -0
  110. package/skills/cyc/references/playbooks/teach.md +11 -0
  111. package/skills/cyc/references/playbooks/verify.md +7 -0
@@ -0,0 +1,132 @@
1
+ ---
2
+ name: cyc
3
+ description: "Run a software task through CYC: a fast scout, a build, and a verify loop that repeats until the project's real checks pass, then a concise handoff. Use when the user says \"cyc\", \"run this through cyc\", or, in a project with CYC installed, asks for a feature, bug fix, refactor, performance improvement, review, or verification, or asks to explain how code works, plan or compare approaches, resume interrupted work, prepare a handoff, or set up CYC."
4
+ ---
5
+
6
+ # CYC
7
+
8
+ You own the outcome. Keep normal work short without dropping context reuse, review, or retained learning. Follow Scout and the compact [work assessment contract](../../docs/work-assessments.md) when `run next` requires it; load deeper methods only for the relevant question. A short route still owes every required outcome.
9
+
10
+ **One entry point.** Users invoke only `/cyc` and describe their outcome. Select the playbook and supporting methods yourself; never ask the user to choose a skill or present the internal catalog as a menu. Ask only about consequential missing requirements. For `/cyc` without a task, ask what they want to accomplish. For setup requests, use the linked Setup method. Supporting methods are internal instructions loaded by file path, not public slash commands; load only what the current step needs.
11
+
12
+ ## Frontend work
13
+
14
+ For new websites, composed interfaces or visual redesigns, apply the [frontend design method](../../methods/cyc-design/frontend-design/SKILL.md) and its three gates. Before any page markup, `design/decisions.md` exists with a named layout archetype (never the centered hero and card grid), a named typeface pair, seven palette values derived from the subject, a signature element and a rejection condition; for several sites, its set-divergence table is filled first. Build renders the signature section and scores it against the generic-tells list (three or more tells fails) before extending the page. Verify scores the finished page at desktop and phone width and runs the experience review; a working page that still reads as a default page has an unmet criterion. A lightweight stack or simple scope does not lower the target. Combine host or platform design guidance into that one sheet rather than accumulating style checklists. Carry it through Scout, Build and Verify, including fast routes with no separate Design stage. Narrow UI repairs preserve the existing identity and use only relevant checks; review-only requests remain review-only.
15
+
16
+ ## The flow
17
+
18
+ Choose from the requested outcome and permissions, not isolated words: "review this bug fix; don't edit" is Review, not Bug fix; "explain this refactor" is Investigation, not Refactor. `cyc route` is a keyword suggestion only. Read the selected playbook before starting. The four-stage flow below applies to implementation routes; on every route, `run next` owns the stage order. A route without Build does not authorize product edits. A quick explanation or local copy correction need not become a controller run unless the user or project requires one; keep the applicable evidence and delivery standards. If it changes project files, record why no run applies with `packet --advisory "<reason>"`; Stop blocks unexplained changes made without a run.
19
+
20
+ ```text
21
+ scout → build → verify ⟲ repair within budget → deliver → reply
22
+ ```
23
+
24
+ 1. **Scout.** Pick the playbook from the table below (usually `feature` or `bug-fix`) and open its page. Read the project's context index first, `docs/context/INDEX.md`, and then only the component docs whose Covers match the paths you will touch (`node <cli> investigate --path <paths>` does the match and checks their evidence), plus the error ledger for that area; each row's `Last AI change` and `Lessons` cells say whether the doc is worth opening. Do not read every doc, and do not start from the code when a matched doc exists. Then follow [Scout](../../methods/cyc-scout/SKILL.md): focused searches, matched component history and ledger lookup, freshness checks, and a short plan. Identify existing functionality and choose reuse, extend, repair, or create. Explain consequential behavior changes and trade-offs; ask only for unresolved decisions that affect the solution. Fill every field with what you found; unedited placeholders are rejected. Aim for a first useful edit within a couple of minutes without skipping critical unknowns.
25
+ 2. **Start the run with its plan.** Save a JSON object under `.cyc/runtime/` with these fields:
26
+ - `goal`, `playbook`, `criteria` (`[{"id":"c1","description":"..."}]`, with optional unique `clauses: [{"id":"...","description":"..."}]`), `allowedPaths`, and `session`;
27
+ - `evidenceVersion: 1` and `requirements`: the original authorized outcome text, kept separately from the short plan. Preserve every original outcome ID and material clause. Use `reviewPolicy: "fresh-required"` for high-risk work when a fresh reviewer is available; otherwise select `"self-allowed"` and disclose the actual fallback. Unversioned inputs remain the compatibility interface for older clients, not the updated workflow;
28
+ - `plan`: one or two sentences;
29
+ - `scout`: `{"context":{"status":"used|none","evidence":"...","freshness":"...","sources":[]},"approach":{"kind":"reuse|extend|repair|create","evidence":"..."},"alignment":{"status":"clear|confirmed","evidence":"..."},"consumers":[{"id":"direct","description":"...","check":"..."}]}`. `context.sources` are matched history (context docs, decisions, ledger entries); with `status: "none"`, list the code you read as `context.read` instead. Omit `context` only when the project has no `docs/context/INDEX.md` and no ledger: the controller then records that there was no history to consult.
30
+
31
+ Run `node <cli> run start --file START.json`. It records Scout in the same call, so do not record Scout again (a second record would land at Build), and writes the finish input to `.cyc/runs/<ID>/finish-template.json`, shown first in its output as `finishTemplate`. You fill that file in at the end, so you do not need `run next` for it. If the scout is invalid, no run is created. If you started without `scout`, `run start` returned its template: save it under `.cyc/runs/<ID>/` and record it with `run record --summary "<plan>" --assessment <scout.json>`. A file preserves multiline text, quotes, and literal shell characters; do not interpolate rich text into shell arguments. Simple `--goal`/`--criterion`/`--scope` arguments remain supported; see the [input examples](../../docs/runtime.md#structured-input-without-shell-quoting).
32
+
33
+ The session comes from the CYC gate context (in Cursor, your conversation's tag; as a subagent, a stable ID you were given; 4–80 characters). Use the actual task scope as literal file or directory prefixes in `allowedPaths`; it also bounds captured originals when Git cannot recover them. Translate brief-style globs into the permitted files or already-authorized directory prefixes (for example `["src/parser.py", "tests/test_parser.py"]`), without broadening task permissions. Glob matching is unsupported; bracketed routes such as `src/[id]` are literal names.
34
+
35
+ Start before editing. Later commands find the active run themselves; pass `--run <ID>` only when several runs are active. The CLI is `.cyc/engine/bin/cyc.mjs`, or [bin/cyc.mjs](../../bin/cyc.mjs) for plugin installs. No `.cyc/config.json` yet? Run [Setup](../../methods/cyc-setup/SKILL.md) first.
36
+ 3. **Build.** Follow [Build](../../methods/cyc-build/SKILL.md). Work in small slices: features and bug fixes use red then green; refactors keep characterization tests green on original and candidate code. Keep named consumers consistent. Record failed fixes in the selected ledger immediately, with evidence and the next hypothesis; if `run next`'s `ledgerPath` does not exist yet, create it in the [entry format](../../methods/cyc-error-ledger/references/entry-format.md). Reread the diff and fix shortfalls. `run finish` records Build and lists the files you changed; `run record` remains for step-by-step work. Finalize authorized context/index and ledger edits before final verification. Verified facts keep their evidence and limits; unverified hypotheses and undecided proposals stay labeled in run-local notes.
37
+ 4. **Prove, verify, and deliver in one call.** Use [Verify](../../methods/cyc-verify/SKILL.md)'s applicable checks: task criteria, affected consumers, rejected cases, and the real journey/recipe.
38
+ - **Test proof.** New regression tests must detect the original defect. `run finish` runs `prove-red` itself when the proof is missing or outdated: tests for bug fixes and features must fail on the run-start code, and refactor tests must pass on it. A change with no testable behavior records `testProof: {"status":"exempt","reason":"..."}`, in FINISH.json or its assessment. With TAP (`node --test`, `tap`), mocha, or jest output, the proof names the new tests that fail on the original code, including output longer than the 32,000 characters kept. It does so even when an older test in the same suite already failed there, because it compares failing test names. Other output gives a per-check result: at least one new test fails on the original. In `criterionEvidence` and the reply, say a specific case failed before the fix only if the proof named it or you ran it on the original code yourself. Otherwise quote `proofClaim` from the finish result.
39
+ - **Versioned evidence.** For `evidenceVersion: 1`, fill `criterionChecks` from the template: one named scenario/observation per original criterion or clause, its configured `check`, `receipt: "current-verification"`, `result: "passed"`, `origin: "agent-reported"`, and actual evidence. The controller binds the command receipt after verification; it does not claim to have observed a named passing assertion. Run `prove-red` before finalizing a non-exempt proof and add `proofReview` using the returned failure IDs, categories, reasons and existing boundary for behavioral claims. See [versioned evidence](../../docs/work-assessments.md#versioned-evidence-records).
40
+ - **Review.** Review the current diff against the senior bar below for intent, consumers, and conventions, and resolve or justify dismissing every finding. Tests alone cannot replace review. Each finding is `{"id":"f1","status":"resolved|dismissed|open","evidence":"<how it was resolved, or why it is dismissed>"}`; an open finding blocks verification.
41
+ - **Finish.** Copy `finishTemplate` to `FINISH.json` and replace every `<...>` with what you found: `summary`, `assessment`, `criterionEvidence` (each criterion ID mapped to its evidence), and `acceptFailures` (see below). The template asks only for what you must judge: `errorHistory` appears for bug fixes, and `learning` is yours to add when you recorded something reusable. Left out, the controller records none and says so. If the template lists an `acceptFailures` entry, that check already failed in the project's run-start baseline: replace its reason with why it is unrelated, or delete the entry and fix the check. Placeholders left in are refused. Add `artifacts` only to override the changed-file list. Run `run finish --file FINISH.json`; the [input examples](../../docs/runtime.md#structured-input-without-shell-quoting) show the envelope. It records Build if needed, proves the new tests, runs the configured checks, records both stages, and completes the run. It refuses an incomplete assessment before running anything.
42
+ - **If the proof or a check fails**, finish stops and says which. Read the receipt, then run `run retry --stage build --reason "<what the failure showed>"` before editing, so the repair is recorded as a build artifact. Do not rerun checks on unchanged files to reproduce a failure, because repeated identical failures exhaust the run.
43
+
44
+ Changes after a passing review require returning to Verify. `run prove-red`, `run verify`, `run record`, and `run complete` remain available for step-by-step use.
45
+ 5. **Deliver the reply.** Follow [Deliver](../../methods/cyc-deliver/SKILL.md). Learning is proportionate: for a small change with nothing reusable, leave `learning` out rather than writing context docs to fill the field. Bug fixes and runs with failures still record error history. With a run-local ledger, `errorHistory.reason` becomes that entry when you have not written it. `run finish` records on the Deliver handoff which component docs under `docs/context/` the change touched (`contextDocs`, also in `review.md`). If the change touched a component that has a doc and you did not update that doc, run `node <cli> context review --run <ID> --write` after finish: it appends the entry from the run's own record (what changed, what was learned, the decisive check, the files with hashes) and refreshes the index; then write the packet with `cyc packet`, since files changed after finish. Otherwise leave the doc to the batched `cyc context review`, which proposes entries for every completed run no doc records yet. See [Context](../../methods/cyc-context/SKILL.md).
46
+
47
+ Reply with the result first, then the criteria evidence and what was not checked. For code work, name the decisive regression test and link the generated `.cyc/runs/ID/review.md`; reuse it for an authorized PR. Under CYC presentation, follow the [response standard](../../docs/response-standard.md): include one useful visual even within the 1,000-character default. Every value in that visual must be observed this run; a "before" value comes from running the original code, never from reading it.
48
+
49
+ Before sending, reread your reply: it answers the request, is understandable, its visual adds information, and it states the limits. In Claude Code and Codex, a completed `run finish` has already written the review packet from the run's record (`packet.written` in its result), and the Stop gate checks the reply's length, visual, and blocked prefix itself; do not run `cyc packet` after it. Run `node <cli> packet --session <ID> --passed "<criterion> :: <evidence>" --artifact <files> --reviewed` yourself when no run completed (a blocked run, or an advisory change with `--advisory`), when you changed files after finish, and always in Cursor, with `--response <file>` holding the exact reply. Draft the reply in `.cyc/runtime/reply.md`, run `node <cli> check-reply .cyc/runtime/reply.md --session <ID>` to see its character count and visual before sending, and send that text unchanged; a rejected reply costs a whole turn, and the check costs one command. `cyc packet --response .cyc/runtime/reply.md` checks the same when you write the packet yourself. If this session's run ended blocked, halted, paused, or stopped, the packet marks itself blocked from the run's record: start the reply with "Blocked:" or "Not ready:" and say what stops completion. After a rejected reply, revise it; rerun the packet only if you wrote it yourself. Codex/Claude packet preflight also checks this hook request's run statuses. For a readiness diagnosis, or in Cursor, use `readiness --session <ID>`; without mapped hook state it needs the actual request start as `--since ISO_TIMESTAMP`, and it remains an explicit diagnostic. A completed replacement does not hide a stopped original. Respect project delivery settings; `delivery.presentation: "project"` delegates formatting to project rules.
50
+
51
+ **Other stages.** Playbooks such as plan, explore, teach, handoff, resume, reflect, and evaluate use stages beyond these four. The playbook page links each stage's method, and `run next` returns the current one as `skillFile` (an absolute path; `skill` is the same file relative to the CYC engine, not the project). Load that method for the current stage only, then record the stage with `run record --run <ID>`.
52
+
53
+ Store assessment JSON beneath the actual run directory. At finish, `finishTemplate` holds the required fields; for other stages, `run next` returns them as a fill-in `assessmentTemplate`. The contract docs are needed only for unusual cases. Advisory and legacy runs retain ordinary handoffs; do not add implementation paperwork to an explanation. The shared review is generated from evidence, not a second manually maintained report. Context and ledger edits after final verification invalidate source evidence like other edits.
54
+
55
+ Before an executable run, check that the project has real `verification.commands`. If the list is empty, `run start` uses the project's declared test command and reports it as `verificationSource`; disclose that in the reply. An npm `pretest` or `posttest` hook runs as its own check around the test script, so a red posttest (lint, a template check) cannot hide the tests. The declared sources are package.json `scripts.test`, a Makefile `test` target, pytest configuration, go.mod, and Cargo.toml. If the project declares none, run [Setup](../../methods/cyc-setup/SKILL.md) steps 3-7 **before** `run start`, which refuses code playbooks without checks. On an unattended run, configure the commands the project itself defines and disclose them. Never edit `.cyc/config.json` after a run starts: that halts the run. Reuse established setup for ordinary tasks rather than rerunning onboarding checks before each change.
56
+
57
+ In Codex/Claude, missing injected CYC gate context is a setup gap: use [Setup](../../methods/cyc-setup/SKILL.md)'s host check and supported trust/reload flow. Never invent a Cursor tag or use an old state token as a substitute. A current prompt observation with `canStartTask: true` permits the first task while Stop is pending; final activation is observed after the turn ends. Existing authorization permits local repairs while activation is pending, but does not turn them into hook-verified delivery.
58
+
59
+ ## Explain progress
60
+
61
+ Use enough engineering detail for the developer to assess the reasoning. A stage name or "retrying" is insufficient: name the affected mechanism and evidence. For a return to earlier work, explain which assumption or implementation failed, why the chosen destination can repair it, and which results must be re-established. Plain language should clarify technical substance, not remove it; see the [detailed workflow and recovery routes](../../docs/cyc-workflow.md).
62
+
63
+ Engineering understanding is part of every stage. During Scout, explain the affected flow and why the approach fits; during Build, explain consequential changes to state, boundaries, or consumers; during recovery, explain what the failure rules out and the next hypothesis; during Verify, connect results to behavior and limits; during Deliver, leave a usable before/after explanation and pointers for maintenance. Adapt depth to the engineer and task. Combine these for small work; do not turn them into a lecture, quiz, or additional approval gate. Follow the [engineering understanding standard](../../docs/response-standard.md#engineering-understanding-throughout-the-work). Supplying an explanation is not proof the engineer understands it.
64
+
65
+ Keep the engineer informed at meaningful discoveries, decisions, and verification results. Usually use one or two short paragraphs: describe the concrete behavior, add a sentence explaining the engineering mechanism, then explain the change or next check. Select what matters now; do not repeat every part in every update. Say what information was lost or behavior changed, rather than just "found the bug." Connect technical terms to their effect. Distinguish suspected causes from confirmed findings and focused checks from full verification.
66
+
67
+ Explain consequential choices and what they protect without narrating every tool call or writing a design review. During longer work, give a useful update about every minute, naming what remains unresolved. Communicate as work proceeds; do not add a reporting stage or delay useful edits. When delegating, pass this guidance along and consolidate findings into coherent user updates. See the [progress standard and example](../../docs/response-standard.md#progress-updates) when needed; it applies to supporting methods too.
68
+
69
+ ## The senior bar
70
+
71
+ Every change is judged as a senior reviewer would. The [engineering principles](../../docs/principles.md) give each rule's trigger and the sign that it was skipped:
72
+
73
+ 1. Make the smallest change that solves the problem. No speculative options, layers, or guards.
74
+ 2. Fix the cause where it starts. A guard is a fix only if the state it handles is legitimate.
75
+ 3. A test that cannot fail proves nothing. `run prove-red` checks it against the run-start code.
76
+ 4. Test behavior callers can observe, not internals.
77
+ 5. Match the codebase. Reuse its helpers and patterns; never fork one.
78
+ 6. Put the domain in data (a state machine or table), not in growing branches.
79
+ 7. Validate at boundaries and trust internal types.
80
+ 8. Migrate every caller, then delete the old path.
81
+ 9. After two failures on one assumption, test the assumption before a third fix.
82
+ 10. Claim only what you observed this run.
83
+ 11. Leave the code easier to read than you found it.
84
+
85
+ ## Rigor
86
+
87
+ The quality bar is always the highest. Only the process scales:
88
+
89
+ - **Normal:** the flow above.
90
+ - **High risk** (auth, permissions, payments, data migrations, deletes, public APIs): run one focused [Challenge](../../methods/cyc-challenge/SKILL.md) pass on the plan before building. Before finishing, get a fresh-context review when the host can start a subagent: give it the diff, the original criteria, the [principles](../../docs/principles.md), and paths to the affected data contracts and existing producers/consumers; omit your implementation rationale, and ask for findings it can demonstrate. Resolve or dismiss each with evidence and record `reviewer: "fresh-context"`. If no subagent is available, record `self` and say so in the reply. Use additional agents only for specific independent questions that warrant them. Capture a review before dispatch with `run review-capture --run ID --file CAPTURE.json` (`{"reviewer":"fresh-context","scope":["affected/path"]}`; omit scope for whole covered source). After the actual review, call `run review-record --run ID --file REVIEW.json` with `reviewId`, review `evidence`, `findings` and observable `identity` or null. Put the returned ID in `semanticReview.receipts`. Record self/peer scopes the same way when combining coverage. These are agent-reported provenance records, not identity attestation. Record the source and scope actually reviewed. After later changes, review the affected delta or identify that coverage as self-reviewed or unverified; do not describe mixed coverage as a fresh review of the entire final candidate. A matching source fingerprint establishes which bytes were reviewed, not that the code is correct.
91
+
92
+ ## When things go wrong
93
+
94
+ For a failed command, blocked/paused run, or interrupted task, use `node <cli> run recover --run ID`. This is read-only guidance from current files and retained run evidence. Explain the observed failure, what remains in place, what evidence needs rechecking, and the next justified action; see [recovery guidance](../../docs/onboarding-recovery.md). Raw error output is supporting evidence, not the whole explanation. Do not infer a missing service from an ordinary nonzero exit. The report cannot authorize a state transition, erase failures, or certify completion.
95
+
96
+ - A bug or error log: search the [error ledger](../../methods/cyc-error-ledger/SKILL.md) first. Don't change code for a bug you haven't reproduced.
97
+ - A check was already failing before you started and is unrelated, for example lint or a template check on files you did not touch: list it in FINISH.json as `"acceptFailures": [{"check": "<id>", "reason": "<why it is unrelated>"}]` (or run `run accept-failure` after `prove-red`). For bug fixes and features, the proof's control run is the baseline; other runs need `verification.baseline`. The run can still complete only if that check fails exactly as it did on the run-start code: the same exit code, the same output lines apart from timings, and no file you changed named in it. For a TAP, mocha, or jest suite, that means all of these:
98
+ - no test fails that did not fail then;
99
+ - every old failure keeps its error, and its stack does not run through source you changed;
100
+ - no new non-test line appears. When verification fails, `failedAtRunStart` lists the failing checks that also failed before the run, so decide for each: accept it if it is unrelated, or fix it if your change caused it. Do not retry unchanged. Name it in the reply as a pre-existing failure. A check that passed before and fails now is a regression and is refused.
101
+ - A consumer the plan missed breaks: add it to the plan, fix it, and verify again.
102
+ - Two fixes fail the same way: stop and question the shared assumption before a third.
103
+ - The user says "not it": follow [Correct](../../methods/cyc-correct/SKILL.md) and ask what's missing before revising.
104
+ - Blocked by something outside your control: record `--status blocked` with the controller, then `cyc packet` marks the review blocked from that run; tell the user the one thing you need. With no run, pass `--blocker "<what stops completion>"` to `cyc packet` and include that text in the reply.
105
+
106
+ Preserve findings through the [context lifecycle](../../docs/work-assessments.md#learning-lifecycle-and-final-file-order): retain verified technical knowledge with evidence and limits; claim adopted decisions only with actual acceptance. Keep unverified hypotheses and undecided proposals explicit in run-local notes. Record failures immediately and close resolved ledger entries before final verification. Later promotion needs a scoped follow-up; do not silently change a completed run's verified source.
107
+
108
+ ## Playbooks
109
+
110
+ Use the [project tools](../../docs/project-tools.md) automatically when relevant: Scout/Understand discover matching context and recipes with `investigate`; Build uses a narrow recipe for feedback; Verify runs applicable authorized supplementary recipes and the controller's required checks. `run next` supplies stage-specific tool hints. Missing or inapplicable recipes fall back to project evidence; matched paths do not authorize side effects, and old receipts do not replace current verification.
111
+
112
+ | Intent | Playbook |
113
+ | --- | --- |
114
+ | Explain current behavior or reasons | [Investigation](references/playbooks/investigation.md) |
115
+ | Compare possible directions | [Explore](references/playbooks/explore.md) |
116
+ | Organize a multi-stage change | [Plan](references/playbooks/plan.md) |
117
+ | Add or change behavior | [Feature](references/playbooks/feature.md) |
118
+ | Repair broken behavior | [Bug fix](references/playbooks/bug-fix.md) |
119
+ | Preserve behavior while changing structure | [Refactor](references/playbooks/refactor.md) |
120
+ | Improve measured speed or cost | [Performance](references/playbooks/performance.md) |
121
+ | Assess existing work | [Review](references/playbooks/review.md) |
122
+ | Establish whether criteria hold | [Verify](references/playbooks/verify.md) |
123
+ | Improve an end-to-end user experience | [Experience](references/playbooks/experience.md) |
124
+ | Explain and support learning | [Teach](references/playbooks/teach.md) |
125
+ | Prepare a reviewable result | [Handoff](references/playbooks/handoff.md) |
126
+ | Recover an interrupted task | [Resume](references/playbooks/resume.md) |
127
+ | Extract supported lessons | [Reflect](references/playbooks/reflect.md) |
128
+ | Compare skill or workflow effectiveness | [Evaluate](references/playbooks/evaluate.md) |
129
+
130
+ ## Autonomy
131
+
132
+ Just do: read, search, run tests, edit files in scope, build prototypes. Always ask first: commits and pushes (unless asked), publishing, deleting user data, global installs, sending messages. The delivery gate won't let you finish while your run is still open; a run that ends blocked is reported as blocked, never as done.
@@ -0,0 +1,13 @@
1
+ # Bug fix
2
+
3
+ Use when behavior contradicts what's intended. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [build](../../../../methods/cyc-build/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ 1. **Check history.** Search the [error ledger](../../../../methods/cyc-error-ledger/SKILL.md) for this symptom; a past entry may name the cause or fixes that already failed.
6
+ 2. **Reproduce.** Run the failing test, request, or script and capture the actual output. If it won't reproduce quickly, use the [diagnose procedure](../../../../methods/cyc-understand/references/diagnose.md) from [Understand](../../../../methods/cyc-understand/SKILL.md). Don't change code for a bug you haven't reproduced.
7
+ 3. **Find the cause.** Trace from the symptom to the first place the code does something wrong. Ask whether the triggering state is legitimate; a guard at the symptom is a fix only if it is. Look for the same fault elsewhere.
8
+ 4. **Write the regression test** from the reproduction, asserting the behavior callers observe. Watch it fail for the reported reason.
9
+ 5. **Fix the cause** with the smallest change. Record any failed attempt in the ledger as it happens.
10
+ 6. **Prove the test.** `run prove-red --run <ID>`. It must fail on the run-start code. If it passes there, the test doesn't capture the bug, so strengthen it.
11
+ 7. **Review the diff** against the [senior bar](../../../../docs/principles.md), then `run finish`. Close the ledger entry with the cause, the fix, and the guard.
12
+
13
+ **Acceptance:** the original reproduction now passes, the regression test is proven to fail against the unfixed code, every configured check passes, and the ledger entry names the cause, fix, and guard. If reproduction is impossible, say so, and distinguish a plausible mitigation from a verified fix.
@@ -0,0 +1,13 @@
1
+ # Evaluate CYC
2
+
3
+ Use to determine whether a skill, prompt, or workflow change actually helps. Stages: [frame](../../../../methods/cyc-frame/SKILL.md) → [understand](../../../../methods/cyc-understand/SKILL.md) → [explore](../../../../methods/cyc-explore/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [reflect](../../../../methods/cyc-reflect/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ State the behavior being tested, representative tasks, baseline, candidate, success criteria, and cost measures before examining outcomes. Include negative cases where a plausible answer should fail and cases where extra process would be unnecessary. Prefer representative tasks from the target project and freeze its outcome checks before production. Source-only task fixtures live under `evals/`; they are not included in the runtime distribution. Distinguish proposed evaluations from completed runs.
6
+
7
+ Separate behavior preservation from task completion. An untouched refactor baseline can pass every behavior check while missing the requested structural change; a review example can reproduce a defect while its explanation misstates the cause. Use semantic inspection for those claims. Controller completion, report length, and test count are observations, not correctness scores. When every condition succeeds, report the tie and seek harder unseen tasks instead of adding points for your preferred workflow's artifacts.
8
+
9
+ Run comparisons in isolated disposable project copies with equivalent starting artifacts and permissions. Keep expected answers and reserved evaluation data out of the producing agent's context. Separate development feedback from a final reserved assessment; repeatedly revealing held-out failures makes that material development data. Where feasible, have an independent reviewer score anonymized artifacts against the same rubric.
10
+
11
+ Capture raw outputs, actual check results, attempts, time/cost when available, and intervention needs. Do not silently add paid runs or external side effects beyond the authorized budget. If the candidate games the metric or weakens the task, count that as failure rather than improvement.
12
+
13
+ **Acceptance:** a reproducible comparison with a defensible conclusion, including a valid inconclusive result. A small sample cannot establish universal improvement.
@@ -0,0 +1,7 @@
1
+ # Experience
2
+
3
+ Use to improve a whole user journey, not one component. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [explore](../../../../methods/cyc-explore/SKILL.md) → [build](../../../../methods/cyc-build/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ In the scout pass, walk the current journey end to end and find every screen and state it touches. Explore two or three genuinely different approaches, prototyping on the real page when the answer is visual, and recommend one. Build it so the whole journey holds together, not just the changed step. Verify in the real app with the [verify recipe](../../../../methods/cyc-verify/references/recipe.md) (journey, console, layout shift, accessibility) as well as the configured checks.
6
+
7
+ **Acceptance:** the full journey works in the real app, the recipe observations are recorded, and every configured check passes. A step that could not be exercised in a real browser is reported as unverified, not passed.
@@ -0,0 +1,9 @@
1
+ # Explore
2
+
3
+ Use when the desired outcome is recognizable but the approach or product premise remains unsettled. Stages: [frame](../../../../methods/cyc-frame/SKILL.md) → [understand](../../../../methods/cyc-understand/SKILL.md) → [explore](../../../../methods/cyc-explore/SKILL.md) → [challenge](../../../../methods/cyc-challenge/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ Frame who benefits, what improvement matters, and which constraints are firm before generating alternatives. Compare meaningfully different approaches. Give each the same criteria, expected impact, tradeoffs, uncertainty, and cheapest useful experiment. A small sketch or disposable prototype is appropriate when seeing behavior resolves a real decision. Keep prototype artifacts isolated and label their limitations; a prototype does not establish production readiness.
6
+
7
+ If every option fails the same criterion, return to the premise rather than producing more superficial variants. Record observed experiment outcomes separately from predicted advantages. Do not treat a proposed direction as user-approved, or advance into full implementation merely because one option looks promising.
8
+
9
+ **Acceptance:** a supported recommendation or a crisp decision the user must make.
@@ -0,0 +1,14 @@
1
+ # Feature
2
+
3
+ Use for new or changed behavior. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [build](../../../../methods/cyc-build/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ 1. **Scout in one pass.** Find the entry point, every reader and writer of the data you'll change, and existing code to reuse. Write a plan of ten lines or fewer naming the data shape, the files, the consumers to keep consistent, and the checks.
6
+ 2. **Settle the data shape first.** Choose the structure that keeps invalid states out (a state machine, table, or typed model) before writing logic. For high-risk changes, [challenge](../../../../methods/cyc-challenge/SKILL.md) the plan now.
7
+ 3. **Build in tested slices.** For each slice, write a test of observable behavior, see it fail for the right reason, make it pass, and move on. Use the project's existing helpers and conventions.
8
+ 4. **Keep consumers consistent.** Update every caller you found. Add consumers you discover late to the plan and the Verify assessment; revisit Scout if they change the approach.
9
+ 5. **Prove the tests.** `run prove-red --run <ID>`. At least one new test must fail on the run-start code; tests that guard existing behavior may pass there.
10
+ 6. **Review the diff** against the [senior bar](../../../../docs/principles.md). For user-facing changes, also run the [verify recipe](../../../../methods/cyc-verify/references/recipe.md) in the real app. Then `run finish`.
11
+
12
+ Follow the [implementation assessment contract](../../../../docs/work-assessments.md): Scout records context freshness, existing-capability choice, and alignment; Verify records semantic review and consumer checks; Deliver records learning and error history. Reuse the generated review artifact through developer review and any authorized PR.
13
+
14
+ **Acceptance:** the requested behavior, new tests proven to catch the change (at least one fails without it), every configured check passing, and named consumers still correct. Annotating a pre-existing failure never makes a failed command pass.
@@ -0,0 +1,11 @@
1
+ # Prepare a handoff
2
+
3
+ Use when a result needs to be ready for a reviewer, teammate, or later session. Stages: [understand](../../../../methods/cyc-understand/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ Inspect actual changes and current verification evidence. Reconcile them with the requested scope and impact map. Identify unresolved failures, unverified environments, and decisions the recipient must understand.
6
+
7
+ Use [Remember](../../../../methods/cyc-remember/SKILL.md) for a durable checkpoint and [Deliver](../../../../methods/cyc-deliver/SKILL.md) for a readable summary. Reuse the implementation run's generated `.cyc/runs/ID/review.md`, refreshing with `run review` when necessary; do not create a competing account. Include artifact locations, validation, known limits, and next actions only when needed. Reuse that final behavior/evidence in a PR description without requiring the conversation history. Prepare the artifact before any required publication approval.
8
+
9
+ Existing green evidence must be rechecked if the relevant files changed. Publishing, opening a pull request, sending messages, and merging remain separate actions governed by the user's request and host permissions; the playbook does not grant them.
10
+
11
+ **Acceptance:** a recipient-ready artifact with accurate status. A useful blocked handoff remains incomplete work, clearly labelled.
@@ -0,0 +1,7 @@
1
+ # Investigation
2
+
3
+ Use to explain how or why something behaves as it does, without changing it. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ In the scout pass, search for the entry point and trace the path through the code, reading only what the question needs, and run the code when reading is ambiguous. Deliver the answer as a short chain of file:line hops, with observed facts separated from inferences. For deeper questions, [Understand](../../../../methods/cyc-understand/SKILL.md) has the full procedure.
6
+
7
+ **Acceptance:** the question is answered with cited file:line evidence, inferences are labeled, and no product files changed. What could not be established is stated.
@@ -0,0 +1,7 @@
1
+ # Performance
2
+
3
+ Use to make something measurably faster or cheaper. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [build](../../../../methods/cyc-build/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ In the scout pass, measure a baseline with a repeatable command and find where the time actually goes (profile or trace, not guesswork). Pick the change the measurement points to. After building, rerun the same measurement under the same conditions and report baseline, result, and delta. Verify that behavior is unchanged with the configured checks. A change that doesn't move the measurement gets reverted.
6
+
7
+ **Acceptance:** a measured improvement under the same conditions as the baseline, with the command, sample size, and run-to-run variation reported, and every configured check passing. A delta within that variation is not an improvement.
@@ -0,0 +1,11 @@
1
+ # Plan
2
+
3
+ Use for work spanning several components, milestones, or dependencies. Stages: [frame](../../../../methods/cyc-frame/SKILL.md) → [understand](../../../../methods/cyc-understand/SKILL.md) → [impact](../../../../methods/cyc-impact/SKILL.md) → [design](../../../../methods/cyc-design/SKILL.md) → [challenge](../../../../methods/cyc-challenge/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ Investigate current behavior and run impact analysis before selecting the sequence. Identify shared interfaces, stored-data transitions, deployment dependencies, and places where work can proceed independently.
6
+
7
+ Break the result into reviewable increments, each with an observable outcome, affected areas, prerequisite, verification method, and recovery point. Front-load experiments that could invalidate the design. Separate preparation, implementation, rollout, and external approvals when the project actually requires them. Avoid speculative estimates presented as commitments.
8
+
9
+ Planning does not claim the planned checks have run. When a key assumption remains untested, propose the bounded investigation needed before expensive execution. A planning-only request ends with the plan; it does not authorize building, publishing, or merging it.
10
+
11
+ **Acceptance:** a feasible dependency-aware plan that preserves scope and can be handed to an implementer.
@@ -0,0 +1,12 @@
1
+ # Refactor
2
+
3
+ Use to improve structure while preserving behavior. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [build](../../../../methods/cyc-build/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ 1. **Find the contract.** Identify the boundary whose behavior must not change and every caller of what you'll restructure. If the cleanup reveals a missing feature or a real bug, split it out; this run changes structure only.
6
+ 2. **Capture behavior first.** Write or find characterization tests at that boundary that would fail if its behavior changed. Type checks and lint do not capture behavior.
7
+ 3. **Check the capture on the original.** Run the characterization tests before changing production code; they must pass. Keep that observation. The controller's `run prove-red` receipt comes after the refactor, when both code and test changes exist; invoking it with only test changes is refused.
8
+ 4. **Subtract, then reshape.** Remove dead code and one-caller wrappers first, then move in small steps, rerunning the tests after each. Migrate every caller and delete the old API in the same change.
9
+ 5. **Keep only improvements.** Revert any step that doesn't make the code easier to read or change.
10
+ 6. **Prove and review the final candidate.** Check the final diff and file formatting, then run `run prove-red --run <ID>`: refactor tests must pass on the run-start code. Review against the [senior bar](../../../../docs/principles.md), then `run finish`.
11
+
12
+ **Acceptance:** the same observable behavior, characterization tests proven against the original code, every configured check passing, and callers updated consistently.
@@ -0,0 +1,11 @@
1
+ # Reflect and improve
2
+
3
+ Use to learn from completed work, failed attempts, or repeated user corrections. Stages: [remember](../../../../methods/cyc-remember/SKILL.md) → [reflect](../../../../methods/cyc-reflect/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ Gather original interventions, artifact outcomes, actual checks, and effort/rework evidence. Use secondary conversation reports cautiously; repeated summaries of one event do not create independent examples.
6
+
7
+ Distinguish user preferences, project conventions, reusable procedures, executable checks, and temporary workarounds. Tie each proposed improvement to a specific mismatch and observed consequence. Preserve authorship and whether a suggestion was adopted. Include where the lesson does not apply and a practical evaluation that could disprove its usefulness.
8
+
9
+ Apply skill or instruction changes only when the user's request includes implementation. Do not silently convert local habits into global policy. If the apparent improvement rests only on model praise or self-reported success, seek outcome evidence or narrow the conclusion.
10
+
11
+ **Acceptance:** a small set of supported proposals, or an honest finding that evidence is insufficient.
@@ -0,0 +1,11 @@
1
+ # Continue a task
2
+
3
+ Use after an interruption, context change, or transfer between tools. Stages: [remember](../../../../methods/cyc-remember/SKILL.md) → [understand](../../../../methods/cyc-understand/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ Load the latest durable checkpoint and `run recover --run ID` for the original task's run. This read-only report gives current constraints, original criteria, remaining budget, historical receipts and one next action. Reconstruct decisions and the affected code path with [Remember](../../../../methods/cyc-remember/SKILL.md). Do not create a new run just to reset recovery budgets or confuse a successful context recap with completion of the original task.
6
+
7
+ Compare checkpoint hashes and repository state with the current workspace. Identify user edits, external changes, missing tools, and stale verification. Preserve current work; do not reset files just to match the old record. Revisit only the assumptions and evidence affected by drift. Continue the original run rather than starting a replacement: a paused run resumes with `run resume --run <ID>`, and a run in progress continues from the stage `run next --run <ID>` reports. This keeps interruption from resetting budgets or erasing failure history. A separate `resume` playbook run only records the reconstruction itself.
8
+
9
+ If the requested outcome includes finishing the original task, continue the appropriate underlying workflow rather than stopping after a summary. Missing records require a narrowly scoped reconstruction and explicit uncertainty. An earlier assistant's completion claim is a lead to check, not evidence by itself.
10
+
11
+ **Acceptance:** the state is reconstructed sufficiently to take a justified next step.
@@ -0,0 +1,9 @@
1
+ # Review
2
+
3
+ Use to assess existing work and find what matters. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [challenge](../../../../methods/cyc-challenge/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ In the scout pass, read the change and find its consumers and criteria. Challenge it from separate angles (spec, consumers, edges, premise) and try to prove each finding. Verify the findings that can be checked by running something. Do not modify the work under review unless fixing is in scope.
6
+
7
+ When the change alters a business rule or state transition, use the [domain design examples](../../../../docs/engineering/domain-design.md) to inspect invariant ownership and the affected writers/readers. When it changes rejection, I/O or partial effects, use the [failure handling examples](../../../../docs/engineering/failure-handling.md) to inspect failure identity, committed/unknown outcomes and retry safety. Load only applicable guidance, preserve legitimate exceptions and existing contracts, and support findings with concrete consequences; neither guide requires a new layer or error convention.
8
+
9
+ **Acceptance:** prioritized findings worth acting on, each with its concrete consequence, evidence and whether it was reproduced, plus what was examined and dismissed. Group related causes without hiding material issues. No findings is a valid result when the evidence supports it.
@@ -0,0 +1,11 @@
1
+ # Teach
2
+
3
+ Use for learning rather than merely receiving a completed artifact. Stages: [frame](../../../../methods/cyc-frame/SKILL.md) → [understand](../../../../methods/cyc-understand/SKILL.md) → [teach](../../../../methods/cyc-teach/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ Establish what the learner wants to understand and whether they want explanation, guided practice, or explanation alongside implementation. Inspect their real project before teaching from it.
6
+
7
+ Use [Understand](../../../../methods/cyc-understand/SKILL.md) to establish accurate behavior and [Teach](../../../../methods/cyc-teach/SKILL.md) to build a mental model with a concrete example. Show relevant decisions and tradeoffs without attributing inferred rationale to an author. Offer practice only when useful or requested, and adapt feedback to the learner's actual response. Existing authorization to build can coexist with explanations; a teaching-only request does not authorize modifying the application.
8
+
9
+ When confusion persists, change the example or expose an overlooked prerequisite. Preserve the distinction between what was explained and what was assessed.
10
+
11
+ **Acceptance:** for an explanation, accurate, accessible material addressing the question. For demonstrated learning, actual learner work. Waiting for that work is a valid blocked state; never invent mastery or complete the exercise merely to advance the chain.
@@ -0,0 +1,7 @@
1
+ # Verify
2
+
3
+ Use to establish whether existing work meets its criteria. Stages: [scout](../../../../methods/cyc-scout/SKILL.md) → [verify](../../../../methods/cyc-verify/SKILL.md) → [deliver](../../../../methods/cyc-deliver/SKILL.md).
4
+
5
+ In the scout pass, list each criterion and the consumers the work affects, and find or write a check that would fail if each were broken. Run the configured checks and the [verify recipe](../../../../methods/cyc-verify/references/recipe.md). A failed criterion is reported, not quietly fixed, unless fixing is in scope.
6
+
7
+ **Acceptance:** every criterion reported as passed, failed, or unverified, each with its evidence.