[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6JJSW73QAVSAWD2QBGJ1MCE":3,"skill-same:01M6JJSW73QAVSAWD2QBGJ1MCE":77},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":28,"publishedAt":48,"linkOnly":49,"markdownContent":50,"markdownBody":51,"frontMatter":52,"refName":55,"commitSha":56,"skillDirectory":57,"forksCount":58,"repositoryHtmlUrl":59,"repositoryHomepageUrl":60,"ownerHtmlUrl":61,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":62,"install":63,"resources":76},"01M6JJSW73QAVSAWD2QBGJ1MCE","crefactor",null,"Structured refactoring with behavioral equivalence enforcement. Tests must pass before AND after. Any test change requires explicit approval. Writes characterization tests for low-coverage code.","joshft\u002Fcorrectless","joshft","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F2847920?v=4","01M6JJGJ1WCYFH1BKGPZJ0Z4YD","josh","01M6JJGJ69XYFA6MTDXSH5BG42",66,"MIT","https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fcrefactor\u002FSKILL.md",[18,23],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",{"categoryNo":24,"categoryName":25,"taxonomyType":26,"taxonomyTypeDesc":27},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",[5,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47],"write","for","with","tests","enforcement","behavioral","coverage","context","edit","test","read","grep","before and after","refactoring","Bash","artifacts","code","architecture","change","2026-11-10 10:12:30",false,"---\nname: crefactor\ndescription: Structured refactoring with behavioral equivalence enforcement. Tests must pass before AND after. Any test change requires explicit approval. Writes characterization tests for low-coverage code.\nallowed-tools: Read, Grep, Glob, Bash(*), Write(.correctless\u002Fartifacts\u002F*), Write(.correctless\u002FARCHITECTURE.md), Write(.correctless\u002FAGENT_CONTEXT.md), Edit(.correctless\u002FARCHITECTURE.md), Edit(.correctless\u002FAGENT_CONTEXT.md)\ninteraction_mode: hybrid\n---\n\n# \u002Fcrefactor — Structured Refactoring\n\n> **Shared constraints apply.** Before executing, read `_shared\u002Fconstraints.md` from the parent of this skill's base directory. All constraints there apply to this skill.\n\nYou are the refactor orchestrator. Refactoring has a fundamentally different risk model than new features. The spec isn't \"build X\" — it's \"same behavior, different structure.\" The test suite IS the spec. If tests pass before and after, the refactor is correct. If a test had to change, that's a behavioral change disguised as a refactor — flag it.\n\n## Philosophy\n\nEvery step exists because agents silently break behavior during refactors. The most dangerous thing an agent does is \"fix\" a test to match restructured code — this erases the behavioral contract. The gate on test changes is the critical invariant of this workflow.\n\n## Progress Visibility (MANDATORY)\n\nRefactoring can take 15-60+ minutes depending on scope. The user must see progress throughout.\n\n**Before starting**, create a task list:\n1. Capture refactor intent\n2. Assess test coverage on affected code\n3. Write characterization tests (if needed)\n4. Snapshot behavioral contract (baseline)\n5. Plan refactor phases\n6. Execute refactor (per-phase verification)\n7. QA review\n8. Final verification\n9. Architecture update (if applicable)\n\n**Between each phase**, print a 1-line status: \"Coverage assessment: {N} tests covering {M}% of refactored files. {Adequate \u002F Characterization tests needed}...\" When spawning agents, announce what they're doing. When agents complete, announce results immediately.\n\nMark each task complete as it finishes.\n\n## Step 1: Capture Refactor Intent\n\n**First-run check**: If `.correctless\u002FARCHITECTURE.md` contains `{PROJECT_NAME}` or `{PLACEHOLDER}` markers, or if `.correctless\u002Fconfig\u002Fworkflow-config.json` does not exist, tell the user: \"Correctless isn't fully set up yet. I can do a quick scan of your codebase right now to populate .correctless\u002FARCHITECTURE.md and .correctless\u002FAGENT_CONTEXT.md, or you can run `\u002Fcsetup` for the full experience.\" If they want the quick scan: glob for key directories, populate .correctless\u002FARCHITECTURE.md, then continue. This improves refactor planning and architecture update suggestions.\n\n### Checkpoint Resume\n\nAfter capturing the refactor intent (below), check for `.correctless\u002Fartifacts\u002Fcheckpoint-crefactor-{slug}.json` (derive slug from the intent filename). If no intent file exists yet, no checkpoint can exist — proceed normally. Also check that the checkpoint branch matches the current branch — ignore checkpoints from other branches.\n\n- **If found and \u003C72 hours old**: Read `completed_phases`. Before skipping, verify each phase:\n  - After `coverage-assessed`: refactor intent artifact exists\n  - After `characterization-tests`: characterization test files exist and pass\n  - After `phase-N` (refactor phases): run test suite — tests must pass\n  - After `qa`: `.correctless\u002Fartifacts\u002Fqa-findings-refactor-{slug}.json` exists\n  If verification passes: \"Found checkpoint from {timestamp} — {completed phases} already done. Resuming from {next phase}.\" Skip completed phases. If verification fails (e.g., tests no longer pass after a refactor phase): restart from the phase that failed.\n- **If found but >72 hours old**: \"Stale checkpoint found (from {date}). Starting fresh.\"\n- **If not found**: Start from the beginning as normal.\n\nAfter each major phase (`coverage-assessed`, `characterization-tests`, `phase-1`, `phase-2`, ..., `qa`) completes, write\u002Fupdate the checkpoint:\n```json\n{\n  \"skill\": \"crefactor\",\n  \"slug\": \"{refactor-slug}\",\n  \"branch\": \"{current-branch}\",\n  \"completed_phases\": [\"coverage-assessed\", \"characterization-tests\", \"phase-1\"],\n  \"current_phase\": \"phase-2\",\n  \"timestamp\": \"ISO\"\n}\n```\nClean up the checkpoint file when the refactor completes successfully.\n\nFirst, check for an active workflow: `.correctless\u002Fhooks\u002Fworkflow-advance.sh status 2>\u002Fdev\u002Fnull`. If a TDD workflow is active on this branch, warn the user: \"There's an active workflow on this branch. Running \u002Fcrefactor here may conflict. Consider finishing the current feature or using a separate branch.\"\n\nAsk the user:\n- **What** are you refactoring? (specific files, modules, layers)\n- **Why?** (extract domain layer, reduce duplication, migrate library, improve testability)\n- **What should NOT change?** (external behavior, API contracts, database schema)\n\nWrite the intent to `.correctless\u002Fartifacts\u002Frefactor-intent-{slug}.md`:\n```markdown\n# Refactor Intent: {Title}\n\n## What: {description of structural change}\n## Why: {motivation}\n## Scope: {files\u002Fmodules affected}\n## Behavioral Contract: All existing tests must pass unchanged.\n## Exceptions: {any known intentional behavior changes, if any}\n```\n\nPresent to user for approval before proceeding.\n\n## Step 2: Assess Test Coverage\n\nRun the test suite with coverage on the files being refactored:\n```bash\n{coverage command from workflow-config.json} -- {files being refactored}\n```\n\nAnalyze results:\n- **Which functions\u002Fmodules being refactored have tests?**\n- **What's the coverage percentage on those specific files?**\n- **Are there integration tests that exercise the code paths being changed?**\n\n### Coverage Decision\n\n- **Adequate coverage** (tests exist for the code being refactored, key paths are exercised): Print \"Coverage is adequate — {N} tests cover the refactored code at {M}% coverage. Proceeding with existing tests as the behavioral contract.\" Skip to Step 4.\n\n- **Low coverage** (\u003C50% on refactored files, or key code paths untested): Print \"Coverage is low — {M}% on refactored files. Writing characterization tests to make this refactor safe.\" Proceed to Step 3.\n\n- **Zero tests**: Print \"No tests cover the code being refactored. Characterization tests are mandatory — refactoring without a safety net is not a refactor, it's a rewrite.\" Proceed to Step 3.\n\n## Step 3: Write Characterization Tests (if needed)\n\nSpawn a **characterization test agent** as a separate forked subagent:\n\n> You are the characterization test agent. Your job is to capture the CURRENT behavior of the code being refactored — including quirks and bugs. Characterization tests assert reality, not intent.\n>\n> For each function\u002Fmodule being refactored:\n> 1. Read the code carefully\n> 2. Write tests that exercise: normal inputs, edge cases, error paths, side effects\n> 3. Each test asserts what the code CURRENTLY does — even if that behavior looks like a bug\n> 4. If a function returns null on empty input and you don't know if that's intentional, write a test asserting it returns null. The refactor will tell us if that behavior changes.\n> 5. Run the tests — they MUST pass against the current code (by definition)\n>\n> Name characterization tests clearly: `describe('characterization: UserService')` or `TestCharacterization_UserService`\n>\n> The characterization test agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Write(test files matching patterns.test_file), Bash(test and build commands)`\n\nAfter the agent completes:\n- Verify all characterization tests pass\n- Present to user: \"I wrote {N} characterization tests covering {files}. These capture current behavior — including any bugs. Review before proceeding?\"\n- User approves. These become the behavioral contract.\n\n## Step 4: Snapshot Behavioral Contract\n\nRun the full test suite (including any new characterization tests):\n```bash\n{test_verbose command from workflow-config.json}\n```\n\nRecord:\n- Total test count\n- All passing test names\n- Test file checksums (to detect modifications)\n\nStore in `.correctless\u002Fartifacts\u002Frefactor-baseline-{slug}.json`:\n```json\n{\n  \"test_count\": N,\n  \"all_passing\": true,\n  \"test_names\": [\"TestA\", \"TestB\", ...],\n  \"git_commit_before\": \"abc123\",\n  \"timestamp\": \"ISO\"\n}\n```\n\nThe `git_commit_before` allows the verification agent to detect test file changes via `git diff --name-only {commit_before} HEAD` filtered against test patterns.\n\nPrint: \"Baseline captured — {N} tests all passing. This is the behavioral contract.\"\n\n## Step 5: Plan the Refactor\n\nAnalyze the scope and create a phased plan:\n- **Identify dependencies**: which files depend on each other? What order minimizes breakage?\n- **Break into phases**: each phase should leave tests passing. A phase that breaks tests forces you to fix everything in that phase before you can verify the next one.\n- **Identify risk points**: which changes are most likely to break behavior? Those go in separate phases with extra verification.\n\nPresent the plan:\n```\nRefactor Plan:\nPhase 1: {description} — affects {files}\nPhase 2: {description} — affects {files}\nPhase 3: {description} — affects {files}\n\nEach phase: restructure → run tests → verify equivalence. Halt on failure.\n```\n\nUser approves before execution.\n\n## Step 6: Execute with Agent Separation\n\nFor each phase, spawn TWO agents:\n\n**Refactor agent** (forked subagent):\n> You are the refactor agent. Restructure the code as described in the phase plan. Focus on structure, not behavior. Do NOT modify test files. If you believe a test is wrong, halt and report — do not \"fix\" it.\n>\n> The refactor agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Edit(source files only — NOT test files), Write(source files only — NOT test files), Bash(test and build commands)`. Explicitly exclude files matching `patterns.test_file` from Edit and Write. If the agent attempts to edit a test file, the orchestrator must intercept and trigger the test-change gate.\n\n**Verification agent** (forked subagent, spawned AFTER refactor agent completes):\n> You are the verification agent. You did NOT write the refactored code. Your job is to verify behavioral equivalence.\n>\n> 1. Run the full test suite. Compare against baseline ({N} tests, all passing).\n> 2. If any test fails: HALT. Report which tests failed and what the refactor agent changed. This is a behavioral change, not a structural one.\n> 3. Check for test file modifications: `git diff --name-only` filtered against test file patterns from `workflow-config.json`. If ANY test file was modified: HALT. Report which test files changed.\n> 4. If test count decreased: HALT. Tests were removed.\n> 5. Run coverage on refactored files — did coverage decrease? Flag if so.\n> 6. If all checks pass: \"Phase {N} verified — {M} tests passing, behavioral equivalence confirmed.\"\n>\n> The verification agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Bash(git diff*, git status*, test and build commands)` — NO Edit or Write. This is a read-only verification role.\n\n**Between phases**, announce: \"Phase {N} complete — {M}\u002F{total} tests passing. Starting phase {N+1}...\"\n\n### The Critical Gate: Test Changes\n\nIf the verification agent detects a test file modification:\n\n1. **HALT** the refactor.\n2. Show the diff of the test file.\n3. Present: \"Test `{file}` was modified during the refactor. This means behavior changed, not just structure. Possible reasons:\n   - The test was testing implementation details (e.g., mock internals) rather than behavior — this test should be rewritten, not silently changed\n   - The refactor intentionally changes behavior — document why\n   - The refactor accidentally broke something — fix it\n\n   Is this test change intentional?\"\n\n   Present the options:\n\n   ```\n     1. Approve behavioral change (recommended) — the test correctly reflects new behavior\n     2. Reject — revert this test change, find another approach\n     3. Split into separate PR — this behavioral change deserves its own review\n\n     Or type your own: ___\n   ```\n\n4. User must approve with a reason. Log the approval in the refactor intent artifact.\n5. Update the baseline with the new test checksums before proceeding.\n\n**Exception**: Characterization tests that captured a known bug may be updated if the refactor intentionally fixes that bug — but the user must state this explicitly.\n\n## Step 7: QA Review\n\n**Context enforcement (mandatory):** Before spawning the QA agent, check context usage. The QA agent runs as a forked subagent (clean context), but the orchestrator must stay coherent to process findings and manage fix rounds. If above 70%: tell the human \"Context is at {N}%. The QA agent will run in fresh context, but I need to be coherent to process findings. Run `\u002Fcompact` before I spawn QA, or I may miss issues in the findings.\" If above 85%: \"Context is critically full ({N}%). I must stop here. Run `\u002Fcompact` and then re-run `\u002Fcrefactor` — the checkpoint will resume from this phase.\"\n\nAfter all phases complete, spawn a **QA agent** (forked subagent):\n\n> You are the QA agent for this refactor. You did NOT participate in the refactoring. Your job is to find regressions the test suite didn't catch.\n>\n> 1. Read the refactor intent document\n> 2. Read the git diff of all changes\n> 3. Check: did the refactor stay within its stated scope? Are there changes outside the declared files?\n> 4. Check `.correctless\u002Fantipatterns.md` — does the refactored code introduce any known bug patterns?\n> 5. Look for behavioral drift: API response shapes, error messages, log formats, config behavior — things that tests might not cover but downstream consumers depend on\n> 6. Check for deleted code that was reachable — dead code removal is fine, but removing code that's called from outside the refactored module is a behavioral change\n> 7. Present findings\n>\n> The QA agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Bash(git*, test commands)` — NO Edit or Write.\n\nQA findings follow the same format as `\u002Fctdd` QA — each finding needs an instance fix AND class fix (or N\u002FA with reason). Persist findings to `.correctless\u002Fartifacts\u002Fqa-findings-refactor-{slug}.json` (the orchestrator writes this, not the QA agent).\n\n## Step 8: Final Verification\n\nRun the full test suite one more time. Compare against baseline:\n- Test count: must be >= baseline\n- All original tests: must pass\n- Coverage: must be >= baseline on refactored files\n\nPrint: \"Refactor complete — {N} tests passing (baseline was {M}). Behavioral equivalence verified.\"\n\n## Step 9: Architecture Update\n\nIf the refactor changed the project structure significantly:\n- Suggest .correctless\u002FARCHITECTURE.md updates for moved\u002Frenamed components\n- Suggest .correctless\u002FAGENT_CONTEXT.md updates for changed paths\n- If patterns changed (e.g., \"repository layer\" moved from `src\u002Fdb\u002F` to `internal\u002Frepo\u002F`), update PAT-xxx entries\n\n## Full Mode Additions\n\nRead `.correctless\u002Fconfig\u002Fworkflow-config.json`. If `workflow.intensity` is set:\n\n- **Mutation testing**: Run mutation testing on the refactored code. Surviving mutants may reveal tests that no longer exercise the refactored paths effectively — the structure change may have moved behavior away from what tests cover.\n- **Cross-spec impact**: Read all specs in `.correctless\u002Fspecs\u002F`. Does the structural change affect how other features' invariants are satisfied?\n- **Drift detection**: Did the refactor resolve or introduce architectural drift? Update `.correctless\u002Fmeta\u002Fdrift-debt.json` accordingly.\n\n## After Refactoring\n\nWrite the refactor summary to `.correctless\u002Fartifacts\u002Frefactor-summary-{slug}.md`:\n```markdown\n# Refactor Summary: {Title}\n\n## Intent: {what was refactored and why}\n## Baseline: {N} tests passing before refactor\n## Result: {N} tests passing after refactor\n## Test Changes: {list of approved test changes with reasons, or \"none\"}\n## Characterization Tests: {N written, if applicable}\n## QA Findings: {count and summary}\n## Coverage: {before}% → {after}% on refactored files\n```\n\nTell the user: \"Refactor complete — {N} tests passing, behavioral equivalence verified. Summary written to `.correctless\u002Fartifacts\u002Frefactor-summary-{slug}.md`.\"\n\nIf the refactor was part of an active feature workflow (check `workflow-advance.sh status`), the user should continue that workflow. If standalone, the refactor is done — suggest updating .correctless\u002FARCHITECTURE.md and committing.\n\n**Note:** `\u002Fcrefactor` does NOT use the TDD state machine. It is a standalone workflow. Do not call `workflow-advance.sh done\u002Fverified\u002Fdocumented`. The refactor intent document and summary artifact serve as the audit trail instead of a spec + verification report.\n\n## Claude Code Feature Integration\n\n### Task Lists\nSee \"Progress Visibility\" section above — task creation and narration are mandatory.\n\n### Token Tracking\n\nLog token usage following the shared constraints (`_shared\u002Fconstraints.md`). Skill-specific values:\n- `skill`: \"crefactor\"\n- `phase`: \"{characterization-tests|phase-N-refactor|phase-N-verify|qa}\"\n- `agent_role`: \"{test-agent|refactor-agent|verification-agent|qa-agent}\"\n\n### Background Tasks\n- Run coverage analysis in the background while the refactor agent works\n- Run mutation testing (at high+ intensity) in the background during QA\n\n## Code Analysis (MCP Integration)\n\nIf `mcp.serena` is `true` in `workflow-config.json`, use Serena MCP for symbol-level code analysis during refactoring:\n\n- Use `find_symbol` instead of grepping for function\u002Ftype names\n- Use `find_referencing_symbols` to trace callers and dependencies before moving code\n- Use `get_symbols_overview` for structural overview of a module\n- Use `replace_symbol_body` for precise symbol-level edits during refactor phases\n- Use `search_for_pattern` for regex searches with symbol context\n\n**Fallback table** — if Serena is unavailable, fall back silently to text-based equivalents:\n\n| Serena Operation | Fallback |\n|-----------------|----------|\n| `find_symbol` | Grep for function\u002Ftype name |\n| `find_referencing_symbols` | Grep for symbol name across source files |\n| `get_symbols_overview` | Read directory + read index files |\n| `replace_symbol_body` | Edit tool |\n| `search_for_pattern` | Grep tool |\n\n### Context7 — Library Documentation\n\nIf `mcp.context7` is `true` in `workflow-config.json`, use Context7 when checking whether a dependency migration path exists during refactoring:\n\n- Use `resolve-library-id` + `get-library-docs` to check if the target library version has a migration guide\n- Useful when refactoring involves upgrading a dependency (e.g., \"does library-x v3 have a codemod for v2 → v3?\")\n\n## Autonomous Defaults\n\nWhen running in autonomous mode (`mode: autonomous` in prompt context), use these defaults instead of pausing for human input.\nWhen dispatched by `\u002Fcauto`, return autonomous decisions in the `AUTONOMOUS_DECISIONS_START`\u002F`AUTONOMOUS_DECISIONS_END` format provided in the task prompt.\n\n- **AD-001**: Refactoring plan — generate and apply plan (default). Rationale: the plan is derived from dependency analysis and presented for verification before execution.\n- **AD-002**: Test change approval — `escalate: always`. Default if deferred: skip test changes. Rationale: test changes during refactoring risk hiding behavioral changes disguised as structural cleanup.\n\n## If Something Goes Wrong\n\n- **Agent crashes mid-refactor**: Re-run `\u002Fcrefactor`. The refactor intent document (`.correctless\u002Fartifacts\u002Frefactor-intent-{slug}.md`) and baseline (`.correctless\u002Fartifacts\u002Frefactor-baseline-{slug}.json`) persist — the skill can pick up context from these. However, partially completed refactor phases may need manual review.\n- **Rate limit hit**: Wait 2-3 minutes and re-run.\n- **Tests fail after a refactor phase**: This is working as designed — the verification agent caught a behavioral change. Fix the issue or revert the phase.\n- **Want to start over**: Revert uncommitted changes with `git checkout .` and re-run from Step 1.\n\n## Constraints\n\n- **The test suite is the primary spec.** Tests passing is necessary but not sufficient — the QA agent checks for behavioral drift that tests don't cover (API shapes, log formats, error messages). Tests failing is always a blocker.\n- **Never silently modify tests.** Every test change requires explicit human approval with a stated reason.\n- **Characterization tests capture reality, not intent.** A characterization test that asserts a bug is still correct — it tells you the refactor changed behavior.\n- **Phase by phase.** Large refactors must be broken into phases that leave tests passing. No \"I'll fix the tests after I'm done restructuring.\"\n- **Agent separation is mandatory.** The refactor agent does not verify. The verification agent did not refactor. Same principle as RED\u002FGREEN in TDD.\n","# \u002Fcrefactor — Structured Refactoring\n\n> **Shared constraints apply.** Before executing, read `_shared\u002Fconstraints.md` from the parent of this skill's base directory. All constraints there apply to this skill.\n\nYou are the refactor orchestrator. Refactoring has a fundamentally different risk model than new features. The spec isn't \"build X\" — it's \"same behavior, different structure.\" The test suite IS the spec. If tests pass before and after, the refactor is correct. If a test had to change, that's a behavioral change disguised as a refactor — flag it.\n\n## Philosophy\n\nEvery step exists because agents silently break behavior during refactors. The most dangerous thing an agent does is \"fix\" a test to match restructured code — this erases the behavioral contract. The gate on test changes is the critical invariant of this workflow.\n\n## Progress Visibility (MANDATORY)\n\nRefactoring can take 15-60+ minutes depending on scope. The user must see progress throughout.\n\n**Before starting**, create a task list:\n1. Capture refactor intent\n2. Assess test coverage on affected code\n3. Write characterization tests (if needed)\n4. Snapshot behavioral contract (baseline)\n5. Plan refactor phases\n6. Execute refactor (per-phase verification)\n7. QA review\n8. Final verification\n9. Architecture update (if applicable)\n\n**Between each phase**, print a 1-line status: \"Coverage assessment: {N} tests covering {M}% of refactored files. {Adequate \u002F Characterization tests needed}...\" When spawning agents, announce what they're doing. When agents complete, announce results immediately.\n\nMark each task complete as it finishes.\n\n## Step 1: Capture Refactor Intent\n\n**First-run check**: If `.correctless\u002FARCHITECTURE.md` contains `{PROJECT_NAME}` or `{PLACEHOLDER}` markers, or if `.correctless\u002Fconfig\u002Fworkflow-config.json` does not exist, tell the user: \"Correctless isn't fully set up yet. I can do a quick scan of your codebase right now to populate .correctless\u002FARCHITECTURE.md and .correctless\u002FAGENT_CONTEXT.md, or you can run `\u002Fcsetup` for the full experience.\" If they want the quick scan: glob for key directories, populate .correctless\u002FARCHITECTURE.md, then continue. This improves refactor planning and architecture update suggestions.\n\n### Checkpoint Resume\n\nAfter capturing the refactor intent (below), check for `.correctless\u002Fartifacts\u002Fcheckpoint-crefactor-{slug}.json` (derive slug from the intent filename). If no intent file exists yet, no checkpoint can exist — proceed normally. Also check that the checkpoint branch matches the current branch — ignore checkpoints from other branches.\n\n- **If found and \u003C72 hours old**: Read `completed_phases`. Before skipping, verify each phase:\n  - After `coverage-assessed`: refactor intent artifact exists\n  - After `characterization-tests`: characterization test files exist and pass\n  - After `phase-N` (refactor phases): run test suite — tests must pass\n  - After `qa`: `.correctless\u002Fartifacts\u002Fqa-findings-refactor-{slug}.json` exists\n  If verification passes: \"Found checkpoint from {timestamp} — {completed phases} already done. Resuming from {next phase}.\" Skip completed phases. If verification fails (e.g., tests no longer pass after a refactor phase): restart from the phase that failed.\n- **If found but >72 hours old**: \"Stale checkpoint found (from {date}). Starting fresh.\"\n- **If not found**: Start from the beginning as normal.\n\nAfter each major phase (`coverage-assessed`, `characterization-tests`, `phase-1`, `phase-2`, ..., `qa`) completes, write\u002Fupdate the checkpoint:\n```json\n{\n  \"skill\": \"crefactor\",\n  \"slug\": \"{refactor-slug}\",\n  \"branch\": \"{current-branch}\",\n  \"completed_phases\": [\"coverage-assessed\", \"characterization-tests\", \"phase-1\"],\n  \"current_phase\": \"phase-2\",\n  \"timestamp\": \"ISO\"\n}\n```\nClean up the checkpoint file when the refactor completes successfully.\n\nFirst, check for an active workflow: `.correctless\u002Fhooks\u002Fworkflow-advance.sh status 2>\u002Fdev\u002Fnull`. If a TDD workflow is active on this branch, warn the user: \"There's an active workflow on this branch. Running \u002Fcrefactor here may conflict. Consider finishing the current feature or using a separate branch.\"\n\nAsk the user:\n- **What** are you refactoring? (specific files, modules, layers)\n- **Why?** (extract domain layer, reduce duplication, migrate library, improve testability)\n- **What should NOT change?** (external behavior, API contracts, database schema)\n\nWrite the intent to `.correctless\u002Fartifacts\u002Frefactor-intent-{slug}.md`:\n```markdown\n# Refactor Intent: {Title}\n\n## What: {description of structural change}\n## Why: {motivation}\n## Scope: {files\u002Fmodules affected}\n## Behavioral Contract: All existing tests must pass unchanged.\n## Exceptions: {any known intentional behavior changes, if any}\n```\n\nPresent to user for approval before proceeding.\n\n## Step 2: Assess Test Coverage\n\nRun the test suite with coverage on the files being refactored:\n```bash\n{coverage command from workflow-config.json} -- {files being refactored}\n```\n\nAnalyze results:\n- **Which functions\u002Fmodules being refactored have tests?**\n- **What's the coverage percentage on those specific files?**\n- **Are there integration tests that exercise the code paths being changed?**\n\n### Coverage Decision\n\n- **Adequate coverage** (tests exist for the code being refactored, key paths are exercised): Print \"Coverage is adequate — {N} tests cover the refactored code at {M}% coverage. Proceeding with existing tests as the behavioral contract.\" Skip to Step 4.\n\n- **Low coverage** (\u003C50% on refactored files, or key code paths untested): Print \"Coverage is low — {M}% on refactored files. Writing characterization tests to make this refactor safe.\" Proceed to Step 3.\n\n- **Zero tests**: Print \"No tests cover the code being refactored. Characterization tests are mandatory — refactoring without a safety net is not a refactor, it's a rewrite.\" Proceed to Step 3.\n\n## Step 3: Write Characterization Tests (if needed)\n\nSpawn a **characterization test agent** as a separate forked subagent:\n\n> You are the characterization test agent. Your job is to capture the CURRENT behavior of the code being refactored — including quirks and bugs. Characterization tests assert reality, not intent.\n>\n> For each function\u002Fmodule being refactored:\n> 1. Read the code carefully\n> 2. Write tests that exercise: normal inputs, edge cases, error paths, side effects\n> 3. Each test asserts what the code CURRENTLY does — even if that behavior looks like a bug\n> 4. If a function returns null on empty input and you don't know if that's intentional, write a test asserting it returns null. The refactor will tell us if that behavior changes.\n> 5. Run the tests — they MUST pass against the current code (by definition)\n>\n> Name characterization tests clearly: `describe('characterization: UserService')` or `TestCharacterization_UserService`\n>\n> The characterization test agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Write(test files matching patterns.test_file), Bash(test and build commands)`\n\nAfter the agent completes:\n- Verify all characterization tests pass\n- Present to user: \"I wrote {N} characterization tests covering {files}. These capture current behavior — including any bugs. Review before proceeding?\"\n- User approves. These become the behavioral contract.\n\n## Step 4: Snapshot Behavioral Contract\n\nRun the full test suite (including any new characterization tests):\n```bash\n{test_verbose command from workflow-config.json}\n```\n\nRecord:\n- Total test count\n- All passing test names\n- Test file checksums (to detect modifications)\n\nStore in `.correctless\u002Fartifacts\u002Frefactor-baseline-{slug}.json`:\n```json\n{\n  \"test_count\": N,\n  \"all_passing\": true,\n  \"test_names\": [\"TestA\", \"TestB\", ...],\n  \"git_commit_before\": \"abc123\",\n  \"timestamp\": \"ISO\"\n}\n```\n\nThe `git_commit_before` allows the verification agent to detect test file changes via `git diff --name-only {commit_before} HEAD` filtered against test patterns.\n\nPrint: \"Baseline captured — {N} tests all passing. This is the behavioral contract.\"\n\n## Step 5: Plan the Refactor\n\nAnalyze the scope and create a phased plan:\n- **Identify dependencies**: which files depend on each other? What order minimizes breakage?\n- **Break into phases**: each phase should leave tests passing. A phase that breaks tests forces you to fix everything in that phase before you can verify the next one.\n- **Identify risk points**: which changes are most likely to break behavior? Those go in separate phases with extra verification.\n\nPresent the plan:\n```\nRefactor Plan:\nPhase 1: {description} — affects {files}\nPhase 2: {description} — affects {files}\nPhase 3: {description} — affects {files}\n\nEach phase: restructure → run tests → verify equivalence. Halt on failure.\n```\n\nUser approves before execution.\n\n## Step 6: Execute with Agent Separation\n\nFor each phase, spawn TWO agents:\n\n**Refactor agent** (forked subagent):\n> You are the refactor agent. Restructure the code as described in the phase plan. Focus on structure, not behavior. Do NOT modify test files. If you believe a test is wrong, halt and report — do not \"fix\" it.\n>\n> The refactor agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Edit(source files only — NOT test files), Write(source files only — NOT test files), Bash(test and build commands)`. Explicitly exclude files matching `patterns.test_file` from Edit and Write. If the agent attempts to edit a test file, the orchestrator must intercept and trigger the test-change gate.\n\n**Verification agent** (forked subagent, spawned AFTER refactor agent completes):\n> You are the verification agent. You did NOT write the refactored code. Your job is to verify behavioral equivalence.\n>\n> 1. Run the full test suite. Compare against baseline ({N} tests, all passing).\n> 2. If any test fails: HALT. Report which tests failed and what the refactor agent changed. This is a behavioral change, not a structural one.\n> 3. Check for test file modifications: `git diff --name-only` filtered against test file patterns from `workflow-config.json`. If ANY test file was modified: HALT. Report which test files changed.\n> 4. If test count decreased: HALT. Tests were removed.\n> 5. Run coverage on refactored files — did coverage decrease? Flag if so.\n> 6. If all checks pass: \"Phase {N} verified — {M} tests passing, behavioral equivalence confirmed.\"\n>\n> The verification agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Bash(git diff*, git status*, test and build commands)` — NO Edit or Write. This is a read-only verification role.\n\n**Between phases**, announce: \"Phase {N} complete — {M}\u002F{total} tests passing. Starting phase {N+1}...\"\n\n### The Critical Gate: Test Changes\n\nIf the verification agent detects a test file modification:\n\n1. **HALT** the refactor.\n2. Show the diff of the test file.\n3. Present: \"Test `{file}` was modified during the refactor. This means behavior changed, not just structure. Possible reasons:\n   - The test was testing implementation details (e.g., mock internals) rather than behavior — this test should be rewritten, not silently changed\n   - The refactor intentionally changes behavior — document why\n   - The refactor accidentally broke something — fix it\n\n   Is this test change intentional?\"\n\n   Present the options:\n\n   ```\n     1. Approve behavioral change (recommended) — the test correctly reflects new behavior\n     2. Reject — revert this test change, find another approach\n     3. Split into separate PR — this behavioral change deserves its own review\n\n     Or type your own: ___\n   ```\n\n4. User must approve with a reason. Log the approval in the refactor intent artifact.\n5. Update the baseline with the new test checksums before proceeding.\n\n**Exception**: Characterization tests that captured a known bug may be updated if the refactor intentionally fixes that bug — but the user must state this explicitly.\n\n## Step 7: QA Review\n\n**Context enforcement (mandatory):** Before spawning the QA agent, check context usage. The QA agent runs as a forked subagent (clean context), but the orchestrator must stay coherent to process findings and manage fix rounds. If above 70%: tell the human \"Context is at {N}%. The QA agent will run in fresh context, but I need to be coherent to process findings. Run `\u002Fcompact` before I spawn QA, or I may miss issues in the findings.\" If above 85%: \"Context is critically full ({N}%). I must stop here. Run `\u002Fcompact` and then re-run `\u002Fcrefactor` — the checkpoint will resume from this phase.\"\n\nAfter all phases complete, spawn a **QA agent** (forked subagent):\n\n> You are the QA agent for this refactor. You did NOT participate in the refactoring. Your job is to find regressions the test suite didn't catch.\n>\n> 1. Read the refactor intent document\n> 2. Read the git diff of all changes\n> 3. Check: did the refactor stay within its stated scope? Are there changes outside the declared files?\n> 4. Check `.correctless\u002Fantipatterns.md` — does the refactored code introduce any known bug patterns?\n> 5. Look for behavioral drift: API response shapes, error messages, log formats, config behavior — things that tests might not cover but downstream consumers depend on\n> 6. Check for deleted code that was reachable — dead code removal is fine, but removing code that's called from outside the refactored module is a behavioral change\n> 7. Present findings\n>\n> The QA agent should have `allowed-tools` restricted to: `Read, Grep, Glob, Bash(git*, test commands)` — NO Edit or Write.\n\nQA findings follow the same format as `\u002Fctdd` QA — each finding needs an instance fix AND class fix (or N\u002FA with reason). Persist findings to `.correctless\u002Fartifacts\u002Fqa-findings-refactor-{slug}.json` (the orchestrator writes this, not the QA agent).\n\n## Step 8: Final Verification\n\nRun the full test suite one more time. Compare against baseline:\n- Test count: must be >= baseline\n- All original tests: must pass\n- Coverage: must be >= baseline on refactored files\n\nPrint: \"Refactor complete — {N} tests passing (baseline was {M}). Behavioral equivalence verified.\"\n\n## Step 9: Architecture Update\n\nIf the refactor changed the project structure significantly:\n- Suggest .correctless\u002FARCHITECTURE.md updates for moved\u002Frenamed components\n- Suggest .correctless\u002FAGENT_CONTEXT.md updates for changed paths\n- If patterns changed (e.g., \"repository layer\" moved from `src\u002Fdb\u002F` to `internal\u002Frepo\u002F`), update PAT-xxx entries\n\n## Full Mode Additions\n\nRead `.correctless\u002Fconfig\u002Fworkflow-config.json`. If `workflow.intensity` is set:\n\n- **Mutation testing**: Run mutation testing on the refactored code. Surviving mutants may reveal tests that no longer exercise the refactored paths effectively — the structure change may have moved behavior away from what tests cover.\n- **Cross-spec impact**: Read all specs in `.correctless\u002Fspecs\u002F`. Does the structural change affect how other features' invariants are satisfied?\n- **Drift detection**: Did the refactor resolve or introduce architectural drift? Update `.correctless\u002Fmeta\u002Fdrift-debt.json` accordingly.\n\n## After Refactoring\n\nWrite the refactor summary to `.correctless\u002Fartifacts\u002Frefactor-summary-{slug}.md`:\n```markdown\n# Refactor Summary: {Title}\n\n## Intent: {what was refactored and why}\n## Baseline: {N} tests passing before refactor\n## Result: {N} tests passing after refactor\n## Test Changes: {list of approved test changes with reasons, or \"none\"}\n## Characterization Tests: {N written, if applicable}\n## QA Findings: {count and summary}\n## Coverage: {before}% → {after}% on refactored files\n```\n\nTell the user: \"Refactor complete — {N} tests passing, behavioral equivalence verified. Summary written to `.correctless\u002Fartifacts\u002Frefactor-summary-{slug}.md`.\"\n\nIf the refactor was part of an active feature workflow (check `workflow-advance.sh status`), the user should continue that workflow. If standalone, the refactor is done — suggest updating .correctless\u002FARCHITECTURE.md and committing.\n\n**Note:** `\u002Fcrefactor` does NOT use the TDD state machine. It is a standalone workflow. Do not call `workflow-advance.sh done\u002Fverified\u002Fdocumented`. The refactor intent document and summary artifact serve as the audit trail instead of a spec + verification report.\n\n## Claude Code Feature Integration\n\n### Task Lists\nSee \"Progress Visibility\" section above — task creation and narration are mandatory.\n\n### Token Tracking\n\nLog token usage following the shared constraints (`_shared\u002Fconstraints.md`). Skill-specific values:\n- `skill`: \"crefactor\"\n- `phase`: \"{characterization-tests|phase-N-refactor|phase-N-verify|qa}\"\n- `agent_role`: \"{test-agent|refactor-agent|verification-agent|qa-agent}\"\n\n### Background Tasks\n- Run coverage analysis in the background while the refactor agent works\n- Run mutation testing (at high+ intensity) in the background during QA\n\n## Code Analysis (MCP Integration)\n\nIf `mcp.serena` is `true` in `workflow-config.json`, use Serena MCP for symbol-level code analysis during refactoring:\n\n- Use `find_symbol` instead of grepping for function\u002Ftype names\n- Use `find_referencing_symbols` to trace callers and dependencies before moving code\n- Use `get_symbols_overview` for structural overview of a module\n- Use `replace_symbol_body` for precise symbol-level edits during refactor phases\n- Use `search_for_pattern` for regex searches with symbol context\n\n**Fallback table** — if Serena is unavailable, fall back silently to text-based equivalents:\n\n| Serena Operation | Fallback |\n|-----------------|----------|\n| `find_symbol` | Grep for function\u002Ftype name |\n| `find_referencing_symbols` | Grep for symbol name across source files |\n| `get_symbols_overview` | Read directory + read index files |\n| `replace_symbol_body` | Edit tool |\n| `search_for_pattern` | Grep tool |\n\n### Context7 — Library Documentation\n\nIf `mcp.context7` is `true` in `workflow-config.json`, use Context7 when checking whether a dependency migration path exists during refactoring:\n\n- Use `resolve-library-id` + `get-library-docs` to check if the target library version has a migration guide\n- Useful when refactoring involves upgrading a dependency (e.g., \"does library-x v3 have a codemod for v2 → v3?\")\n\n## Autonomous Defaults\n\nWhen running in autonomous mode (`mode: autonomous` in prompt context), use these defaults instead of pausing for human input.\nWhen dispatched by `\u002Fcauto`, return autonomous decisions in the `AUTONOMOUS_DECISIONS_START`\u002F`AUTONOMOUS_DECISIONS_END` format provided in the task prompt.\n\n- **AD-001**: Refactoring plan — generate and apply plan (default). Rationale: the plan is derived from dependency analysis and presented for verification before execution.\n- **AD-002**: Test change approval — `escalate: always`. Default if deferred: skip test changes. Rationale: test changes during refactoring risk hiding behavioral changes disguised as structural cleanup.\n\n## If Something Goes Wrong\n\n- **Agent crashes mid-refactor**: Re-run `\u002Fcrefactor`. The refactor intent document (`.correctless\u002Fartifacts\u002Frefactor-intent-{slug}.md`) and baseline (`.correctless\u002Fartifacts\u002Frefactor-baseline-{slug}.json`) persist — the skill can pick up context from these. However, partially completed refactor phases may need manual review.\n- **Rate limit hit**: Wait 2-3 minutes and re-run.\n- **Tests fail after a refactor phase**: This is working as designed — the verification agent caught a behavioral change. Fix the issue or revert the phase.\n- **Want to start over**: Revert uncommitted changes with `git checkout .` and re-run from Step 1.\n\n## Constraints\n\n- **The test suite is the primary spec.** Tests passing is necessary but not sufficient — the QA agent checks for behavioral drift that tests don't cover (API shapes, log formats, error messages). Tests failing is always a blocker.\n- **Never silently modify tests.** Every test change requires explicit human approval with a stated reason.\n- **Characterization tests capture reality, not intent.** A characterization test that asserts a bug is still correct — it tells you the refactor changed behavior.\n- **Phase by phase.** Large refactors must be broken into phases that leave tests passing. No \"I'll fix the tests after I'm done restructuring.\"\n- **Agent separation is mandatory.** The refactor agent does not verify. The verification agent did not refactor. Same principle as RED\u002FGREEN in TDD.\n",{"name":5,"description":7,"allowed-tools":53,"interaction_mode":54},"Read, Grep, Glob, Bash(*), Write(.correctless\u002Fartifacts\u002F*), Write(.correctless\u002FARCHITECTURE.md), Write(.correctless\u002FAGENT_CONTEXT.md), Edit(.correctless\u002FARCHITECTURE.md), Edit(.correctless\u002FAGENT_CONTEXT.md)","hybrid","main","74f9ef3f5acae9c857f6be6dd86cdc3b10830c90","skills\u002Fcrefactor",4,"https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless","https:\u002F\u002Fjoshft.github.io\u002Fcorrectless\u002F","https:\u002F\u002Fgithub.com\u002Fjoshft","2026-11-07 02:53:35",{"source":8,"skillName":5,"commands":64,"prompt":74,"zipAvailable":75},[65,68,71],{"tool":66,"command":67},"npx","npx skills add joshft\u002Fcorrectless --skill crefactor",{"tool":69,"command":70},"bunx","bunx skills add joshft\u002Fcorrectless --skill crefactor",{"tool":72,"command":73},"pnpm","pnpm dlx skills add joshft\u002Fcorrectless --skill crefactor","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fcrefactor\u002FSKILL.md",true,[],[78,98,120,138,154,167],{"skillNo":79,"name":80,"nameZh":6,"description":81,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":82,"categories":83,"keywords":85,"publishedAt":48},"01M6JJW224Q40TCVMTKRZPDHDY","cwtf","Audit the workflow itself. Use when you suspect agents shortcut or after a bug escapes despite the workflow running. Checks phase execution, rule coverage, and agent thoroughness.","https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fcwtf\u002FSKILL.md",[84],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},[80,86,87,44,88,89,43,40,90,91,39,29,37,35,92,93,94,95,96,97],"workflow","git","audit","execution","find","jq","autonomous","use","wtf","bug","you","shortcut",{"skillNo":99,"name":100,"nameZh":6,"description":101,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":102,"categories":103,"keywords":108,"publishedAt":48},"01M6JJVT9M4KGWQ99V0CSF6WZ5","cverify","Verify implementation matches spec. Check rule coverage, undocumented dependencies, architecture compliance. Writes verification report and drift debt. Run after \u002Fctdd completes.","https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fcverify\u002FSKILL.md",[104,105],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},{"categoryNo":106,"categoryName":107,"taxonomyType":26,"taxonomyTypeDesc":27},"01JBSEEDCAT000000000000037","律师与法务",[100,109,86,46,110,87,111,112,43,39,29,37,35,113,114,115,116,117,118,119],"go","run","verification","Meta","diff","ruff","drift","verify implementation","cargo","stryker","ctdd",{"skillNo":121,"name":122,"nameZh":6,"description":123,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":124,"categories":125,"keywords":126,"publishedAt":48},"01M6JJVP2E6BHHKF3SCMDXG0S2","cupdate-arch","Update .correctless\u002FARCHITECTURE.md after features land. Use after \u002Fcdocs or when the codebase structure has changed.","https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fcupdate-arch\u002FSKILL.md",[],[127,128,129,46,130,87,131,43,132,40,39,29,37,93,133,134,135,136,137],"arch","cupdate arch","docs","update","land","Rules","structure","codebase","features","codebase structure","cdocs",{"skillNo":139,"name":140,"nameZh":6,"description":141,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":142,"categories":143,"keywords":144,"publishedAt":48},"01M6JJVJVZ72KVWN1K3RWQK0YJ","ctriage","Bulk triage deferred findings backlog. Presents findings one at a time with disposition options.","https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fctriage\u002FSKILL.md",[],[140,145,112,43,146,40,91,147,39,29,37,148,149,150,151,152,31,153],"triage","json","one at a time","interactive","options","backlog","time","bulk","at",{"skillNo":155,"name":119,"nameZh":6,"description":156,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":157,"categories":158,"keywords":160,"publishedAt":48},"01M6JJVCYCNYD4GHK33DZE9DXA","Enforced TDD workflow. Write failing tests from spec rules, then implement. Use after \u002Fcreview approves a spec.","https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fctdd\u002FSKILL.md",[159],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},[119,161,162,163,86,44,164,43,132,40,39,29,37,93,165,32,166],"spec","implement","tdd","tdd workflow","task","creview",{"skillNo":168,"name":169,"nameZh":6,"description":170,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":171,"categories":172,"keywords":173,"publishedAt":48},"01M6JJV7S3EQG3GHQ56DD8P1SA","csummary","Feature summary. Use after \u002Fcdocs to see what the workflow caught, or mid-feature to check progress.","https:\u002F\u002Fgithub.com\u002Fjoshft\u002Fcorrectless\u002Fblob\u002Fmain\u002Fskills\u002Fcsummary\u002FSKILL.md",[],[169,86,87,44,43,40,174,39,29,37,92,93,175,176,177,178,137],"check","what the","summary","feature","progress"]