[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6K5J0KKWB62H8NXPS5MTYGT":3,"skill-same:01M6K5J0KKWB62H8NXPS5MTYGT":66},{"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":18,"publishedAt":37,"linkOnly":38,"markdownContent":39,"markdownBody":40,"frontMatter":41,"refName":43,"commitSha":44,"skillDirectory":45,"forksCount":46,"repositoryHtmlUrl":47,"repositoryHomepageUrl":48,"ownerHtmlUrl":49,"ownerBlogUrl":50,"ownerDescription":51,"updatedAt":52,"install":53,"resources":65},"01M6K5J0KKWB62H8NXPS5MTYGT","cat",null,"Subagent-driven development as the explicit combination of \u002Fsubagent-driven-development (sequential, review-gated execution) and \u002Fdispatching-parallel-agents (independent fan-out). Opens with one combined pre-dispatch question to set the execution mode and the edit-approval mode, then dispatches accordingly.","laurac8r\u002Fclaude-damn","laurac8r","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F23003243?v=4","01M6K5HCAJJR4Q5BCBRRZF8E5D","Laura Kaminskiy","01M6K5HCEQRFFJFK32A0VR7AS3",3,"MIT","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Fcat\u002FSKILL.md",[],[5,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36],"approval","parallel-agents","mode","true","with","driven","as","gated","dispatch","review","execution mode","edit","question","parallel","subagent","execution","SET","development","2026-11-10 10:12:30",false,"---\nname: cat\ndescription:\n   Subagent-driven development as the explicit combination of\n   \u002Fsubagent-driven-development (sequential, review-gated execution) and\n   \u002Fdispatching-parallel-agents (independent fan-out). Opens with one combined\n   pre-dispatch question to set the execution mode and the edit-approval mode,\n   then dispatches accordingly.\nuser-invocable: true\n---\n\n## What `\u002Fcat` Is\n\n`\u002Fcat` authorizes subagent dispatch for the work at hand, as the **explicit\ncombination of two superpowers skills**:\n\n- **`\u002Fsubagent-driven-development`** — sequential plan execution: a fresh\n  implementer subagent per task, with two-stage review (spec compliance first,\n  then code quality) before the next task starts.\n- **`\u002Fdispatching-parallel-agents`** — independent fan-out: one concurrent agent\n  per independent problem domain, integrated and suite-verified together.\n\nYou do **not** silently guess which shape fits. You ask the user up front, then\ndispatch on their answer.\n\n## Pre-Dispatch Question\n\nBefore dispatching anything, ask **one combined `AskUserQuestion`** covering two\northogonal axes — both axes in a **single** `AskUserQuestion` call (multiple\nquestions in one call), not two sequential calls. Wait for both answers before\nany dispatch.\n\n**Axis 1 — Execution mode** (how subagents are sequenced):\n\n| Preset                           | Drives                                                                              | Use when                                                                            |\n| -------------------------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |\n| **Full parallel**                | `\u002Fdispatching-parallel-agents`                                                      | 2+ independent tasks — no shared state, no sequential dependencies                  |\n| **Hybrid** (plan-gated parallel) | `\u002Fdispatching-parallel-agents` within phases, `\u002Fsubagent-driven-development` across | a plan with one or more parallelizable phases plus dependent tasks between them     |\n| **Strict sequential**            | `\u002Fsubagent-driven-development`                                                      | each task needs the spec-then-quality review loop to pass before the next can start |\n\n**Axis 2 — Edit approval** (who clears each edit). The real distinction is\nwhether edits are auto-accepted or you approve each one — **not** background vs\nforeground. Backgrounded subagents surface permission prompts too, so\n\"background\" does not mean \"silent\":\n\n| Mode               | Semantics                                                                                                                                                                                                                                           |\n| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Auto-accept**    | edits auto-accepted — no per-edit gate. Subagents run in the background; fastest, the default for large fan-outs. Requires auto-accept-edits to be ON.                                                                                              |\n| **Manual-approve** | you approve each edit interactively. Subagents are dispatched in the **foreground** (all independent agents at once; dependent tasks still serialize), so the approval stream stays coherent instead of interleaving across many background agents. |\n\nIf the user picks **Auto-accept** but hasn't enabled auto-accept-edits, prompt\nthem to turn it on (press `a` or `\u002Fallowed-tools`) and wait for them to enable\nit before dispatching — otherwise even backgrounded dispatch stops on every edit\nfor approval.\n\n## Dispatch\n\nMap the chosen execution mode to its source skill and follow it. These are bare\ninvocations on their own line — they load and run the composed skill:\n\n\u003C!-- prettier-ignore -->\n- **Full parallel** →\n  \u002Fdispatching-parallel-agents\n- **Strict sequential** →\n  \u002Fsubagent-driven-development\n- **Hybrid** → apply the **Full parallel** dispatch (above) within each\n  independent phase, and the **Strict sequential** dispatch (above) across the\n  dependent tasks. Switch on dependency: a task that needs a prior task's output\n  — or its review to pass — is sequential; everything else in that phase fans\n  out. Don't force one shape onto the wrong work.\n\n### Edit-approval × execution-mode\n\nManual-approve is **orthogonal** to execution mode: it changes _how_ edits are\napproved (foreground, per-edit), not _how many_ subagents run at once. \"All\nsubagents dispatched at once\" is the parallel\u002Fhybrid manifestation; under Strict\nsequential it does not collapse the review-gated, one-at-a-time loop. Your\nper-edit approval is **separate from** `\u002Fsubagent-driven-development`'s\ntwo-stage spec-then-quality review — approving a diff does not stand in for that\nreview; the reviewer subagents still run.\n\n| Execution mode \\ Approval | Auto-accept                             | Manual-approve                                                            |\n| ------------------------- | --------------------------------------- | ------------------------------------------------------------------------- |\n| **Full parallel**         | all agents concurrent, background       | all agents dispatched at once, foreground, approve each edit              |\n| **Hybrid**                | parallel phases background; rest serial | parallel phases dispatched at once foreground; dependent parts serialized |\n| **Strict sequential**     | one task at a time, background          | one task at a time, foreground, approve that task's edits                 |\n\n## No Shortcut for \"Trivial\" Edits\n\nWhen the user chose `\u002Fcat` (directly, or via a composition like `\u002Fsuper-cat`,\n`\u002Fsuper-duper-cat`), they authorized subagent dispatch as the execution model.\nDo NOT substitute inline `Edit`\u002F`Write` tool calls on the main agent because\nedits seem small, mechanical, or repetitive — fresh-subagent-per-task isolation\n(whether sequential via `\u002Fsubagent-driven-development` or concurrent via\n`\u002Fdispatching-parallel-agents`) IS the skill's value, not an optional ceremony.\n\n**Manual-approve is not a license for inline edits.** Foreground\u002Fmanual-approve\nchanges WHO APPROVES each edit (you, interactively) — not WHO MAKES it (still\nthe dispatched subagent). \"I'm approving every diff in the foreground anyway, so\nI may as well edit directly\" is the same shortcut as every row below, wearing a\nnew hat. The execution model the user chose holds in every approval mode.\n\nIf the tasks are truly below the threshold for subagent dispatch (e.g., a single\n1-line typo fix), surface the tradeoff to the user explicitly and ask before\nshort-circuiting. Never skip silently.\n\n**Rationalization counter:**\n\n| Excuse                                                                               | Reality                                                                                                                                                                                                                    |\n| ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| \"Dispatching subagents for 5-line edits is overkill\"                                 | The user picked `\u002Fcat` explicitly. Respect the choice. Isolation is the point, not speed.                                                                                                                                  |\n| \"Parallel `Edit` calls are faster than parallel agents\"                              | Speed is one rationale for `\u002Fdispatching-parallel-agents` but not the only one — context isolation prevents bleed between independent investigations. If you want inline edits, the user should pick a different workflow. |\n| \"The output will just say 'done', it's the same thing\"                               | Same output ≠ same process. Fresh-context-per-task is the value; skipping it defeats the skill.                                                                                                                            |\n| \"Subagents + review loops take too long\"                                             | That's the cost the user agreed to when they invoked `\u002Fcat`. If the budget is tight, ask — don't decide unilaterally.                                                                                                      |\n| \"Manual-approve makes context isolation moot — I'm hand-approving every diff anyway\" | Approval mode and execution model are orthogonal. You approve the edit; the subagent still makes it. Foreground ≠ inline. Dispatch anyway.                                                                                 |\n\n**Red flag — STOP:** if you catch yourself writing \"I'll do this directly\ninstead of dispatching because [trivial\u002Ffast\u002Fsimple\u002Fforeground]\", you are\nviolating `\u002Fcat`. Dispatch the subagent.\n","## What `\u002Fcat` Is\n\n`\u002Fcat` authorizes subagent dispatch for the work at hand, as the **explicit\ncombination of two superpowers skills**:\n\n- **`\u002Fsubagent-driven-development`** — sequential plan execution: a fresh\n  implementer subagent per task, with two-stage review (spec compliance first,\n  then code quality) before the next task starts.\n- **`\u002Fdispatching-parallel-agents`** — independent fan-out: one concurrent agent\n  per independent problem domain, integrated and suite-verified together.\n\nYou do **not** silently guess which shape fits. You ask the user up front, then\ndispatch on their answer.\n\n## Pre-Dispatch Question\n\nBefore dispatching anything, ask **one combined `AskUserQuestion`** covering two\northogonal axes — both axes in a **single** `AskUserQuestion` call (multiple\nquestions in one call), not two sequential calls. Wait for both answers before\nany dispatch.\n\n**Axis 1 — Execution mode** (how subagents are sequenced):\n\n| Preset                           | Drives                                                                              | Use when                                                                            |\n| -------------------------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |\n| **Full parallel**                | `\u002Fdispatching-parallel-agents`                                                      | 2+ independent tasks — no shared state, no sequential dependencies                  |\n| **Hybrid** (plan-gated parallel) | `\u002Fdispatching-parallel-agents` within phases, `\u002Fsubagent-driven-development` across | a plan with one or more parallelizable phases plus dependent tasks between them     |\n| **Strict sequential**            | `\u002Fsubagent-driven-development`                                                      | each task needs the spec-then-quality review loop to pass before the next can start |\n\n**Axis 2 — Edit approval** (who clears each edit). The real distinction is\nwhether edits are auto-accepted or you approve each one — **not** background vs\nforeground. Backgrounded subagents surface permission prompts too, so\n\"background\" does not mean \"silent\":\n\n| Mode               | Semantics                                                                                                                                                                                                                                           |\n| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Auto-accept**    | edits auto-accepted — no per-edit gate. Subagents run in the background; fastest, the default for large fan-outs. Requires auto-accept-edits to be ON.                                                                                              |\n| **Manual-approve** | you approve each edit interactively. Subagents are dispatched in the **foreground** (all independent agents at once; dependent tasks still serialize), so the approval stream stays coherent instead of interleaving across many background agents. |\n\nIf the user picks **Auto-accept** but hasn't enabled auto-accept-edits, prompt\nthem to turn it on (press `a` or `\u002Fallowed-tools`) and wait for them to enable\nit before dispatching — otherwise even backgrounded dispatch stops on every edit\nfor approval.\n\n## Dispatch\n\nMap the chosen execution mode to its source skill and follow it. These are bare\ninvocations on their own line — they load and run the composed skill:\n\n\u003C!-- prettier-ignore -->\n- **Full parallel** →\n  \u002Fdispatching-parallel-agents\n- **Strict sequential** →\n  \u002Fsubagent-driven-development\n- **Hybrid** → apply the **Full parallel** dispatch (above) within each\n  independent phase, and the **Strict sequential** dispatch (above) across the\n  dependent tasks. Switch on dependency: a task that needs a prior task's output\n  — or its review to pass — is sequential; everything else in that phase fans\n  out. Don't force one shape onto the wrong work.\n\n### Edit-approval × execution-mode\n\nManual-approve is **orthogonal** to execution mode: it changes _how_ edits are\napproved (foreground, per-edit), not _how many_ subagents run at once. \"All\nsubagents dispatched at once\" is the parallel\u002Fhybrid manifestation; under Strict\nsequential it does not collapse the review-gated, one-at-a-time loop. Your\nper-edit approval is **separate from** `\u002Fsubagent-driven-development`'s\ntwo-stage spec-then-quality review — approving a diff does not stand in for that\nreview; the reviewer subagents still run.\n\n| Execution mode \\ Approval | Auto-accept                             | Manual-approve                                                            |\n| ------------------------- | --------------------------------------- | ------------------------------------------------------------------------- |\n| **Full parallel**         | all agents concurrent, background       | all agents dispatched at once, foreground, approve each edit              |\n| **Hybrid**                | parallel phases background; rest serial | parallel phases dispatched at once foreground; dependent parts serialized |\n| **Strict sequential**     | one task at a time, background          | one task at a time, foreground, approve that task's edits                 |\n\n## No Shortcut for \"Trivial\" Edits\n\nWhen the user chose `\u002Fcat` (directly, or via a composition like `\u002Fsuper-cat`,\n`\u002Fsuper-duper-cat`), they authorized subagent dispatch as the execution model.\nDo NOT substitute inline `Edit`\u002F`Write` tool calls on the main agent because\nedits seem small, mechanical, or repetitive — fresh-subagent-per-task isolation\n(whether sequential via `\u002Fsubagent-driven-development` or concurrent via\n`\u002Fdispatching-parallel-agents`) IS the skill's value, not an optional ceremony.\n\n**Manual-approve is not a license for inline edits.** Foreground\u002Fmanual-approve\nchanges WHO APPROVES each edit (you, interactively) — not WHO MAKES it (still\nthe dispatched subagent). \"I'm approving every diff in the foreground anyway, so\nI may as well edit directly\" is the same shortcut as every row below, wearing a\nnew hat. The execution model the user chose holds in every approval mode.\n\nIf the tasks are truly below the threshold for subagent dispatch (e.g., a single\n1-line typo fix), surface the tradeoff to the user explicitly and ask before\nshort-circuiting. Never skip silently.\n\n**Rationalization counter:**\n\n| Excuse                                                                               | Reality                                                                                                                                                                                                                    |\n| ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| \"Dispatching subagents for 5-line edits is overkill\"                                 | The user picked `\u002Fcat` explicitly. Respect the choice. Isolation is the point, not speed.                                                                                                                                  |\n| \"Parallel `Edit` calls are faster than parallel agents\"                              | Speed is one rationale for `\u002Fdispatching-parallel-agents` but not the only one — context isolation prevents bleed between independent investigations. If you want inline edits, the user should pick a different workflow. |\n| \"The output will just say 'done', it's the same thing\"                               | Same output ≠ same process. Fresh-context-per-task is the value; skipping it defeats the skill.                                                                                                                            |\n| \"Subagents + review loops take too long\"                                             | That's the cost the user agreed to when they invoked `\u002Fcat`. If the budget is tight, ask — don't decide unilaterally.                                                                                                      |\n| \"Manual-approve makes context isolation moot — I'm hand-approving every diff anyway\" | Approval mode and execution model are orthogonal. You approve the edit; the subagent still makes it. Foreground ≠ inline. Dispatch anyway.                                                                                 |\n\n**Red flag — STOP:** if you catch yourself writing \"I'll do this directly\ninstead of dispatching because [trivial\u002Ffast\u002Fsimple\u002Fforeground]\", you are\nviolating `\u002Fcat`. Dispatch the subagent.\n",{"name":5,"description":7,"user-invocable":42},true,"main","9635fb649979617cf684ea860dcaeb4eb272aa7d","skills\u002Fcat",1,"https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn","https:\u002F\u002Flaurac8r.github.io\u002Fclaude-damn\u002F","https:\u002F\u002Fgithub.com\u002Flaurac8r","https:\u002F\u002Fwww.webcatgirl.com\u002F","SWE | Python, Java, Typescript, Cloud, AI, ML | Open-source, large-language model, and decision model enthusiast","2026-09-10 01:18:30",{"source":8,"skillName":5,"commands":54,"prompt":64,"zipAvailable":42},[55,58,61],{"tool":56,"command":57},"npx","npx skills add laurac8r\u002Fclaude-damn --skill cat",{"tool":59,"command":60},"bunx","bunx skills add laurac8r\u002Fclaude-damn --skill cat",{"tool":62,"command":63},"pnpm","pnpm dlx skills add laurac8r\u002Fclaude-damn --skill cat","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Fcat\u002FSKILL.md",[],[67,104,128,142,154,170],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":84,"publishedAt":37},"01M6K5V5PPEYZGPW80S9QAF7WZ","visual-aid","Use when the user asks for a quick visual aid, visual explainer, concept card, one-pager, poster, cheat sheet, infographic, visual summary, summary card, or mini explainer page — especially from input like a block of text, attached images, an attached song (lyrics\u002Faudio), a web link, a CSV\u002Fdataset, a math formula, a code snippet to walk through, a tutorial's steps, a timeline, or an A-vs-B comparison. Triggers include \"make me a quick visual aid\", \"turn this into a one-pager \u002F cheat sheet \u002F explainer\", \"summarize this visually\", \"give me a visual of\", \"explain this on a single page\", \"make a concept card for\", \"whip up a page about\", \"build a mini page that shows\", \"something I can paste into a doc explaining X\", or any request to render a topic\u002Ftext\u002Flink\u002Fimage-set\u002Fsong\u002Fdata into a standalone page. Prefer this skill over frontend-design when the ask is an explanatory single-file page (not a production UI), over playground when the output is static information display (not an interactive configurator), and over a Markdown\u002Fcode answer when the user explicitly wants a *page* (HTML). Produces a single self-contained HTML file that opens on double-click without a server.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Fvisual-aid\u002FSKILL.md",[73,78,81],{"categoryNo":74,"categoryName":75,"taxonomyType":76,"taxonomyTypeDesc":77},"01JBSEEDCAT000000000000009","前端开发","SCENARIO","使用场景",{"categoryNo":79,"categoryName":80,"taxonomyType":76,"taxonomyTypeDesc":77},"01JBSEEDCAT000000000000015","视觉设计",{"categoryNo":82,"categoryName":83,"taxonomyType":76,"taxonomyTypeDesc":77},"01JBSEEDCAT000000000000016","图像与多媒体",[85,86,87,88,35,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103],"visual","visual aid","frontend","design","Audio","visual explainer","up","images","formula","infographic","click","card","render","information","quick","song","standalone","frontend-design","static",{"skillNo":105,"name":106,"nameZh":6,"description":107,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":108,"categories":109,"keywords":110,"publishedAt":37},"01M6K5TZZ34SBMQMN2EX11XMYS","tesseract","Use when you've been poking at the same file, concept, or problem across many sessions and want to step outside time to see its whole arc — or when you want to leave a note for next-session-you. Triggers: 'I've been going in circles on X', 'what have I learned about X', 'what did past-me say about X', 'I keep rediscovering this'.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftesseract\u002FSKILL.md",[],[106,111,112,113,114,115,116,117,85,118,119,120,121,122,123,124,125,22,126,127],"sessions","file","session","use","say","me","time","across","anchor","triggers","learned","problem","keep","you","morse","concept","for",{"skillNo":129,"name":130,"nameZh":6,"description":131,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":132,"categories":133,"keywords":134,"publishedAt":37},"01M6K5TSVWXGRFMQTSM8VFSRDS","tdd","Invoke test-driven development as an explicit one-at-a-time micro-cycle — one test, one piece of functionality, refactor, then repeat for the next behavior","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd\u002FSKILL.md",[],[130,135,36,136,137,138,139,140,117,25,24,22,141,127],"test","micro","refactor","behavior","cycle","next","at",{"skillNo":143,"name":144,"nameZh":6,"description":145,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":146,"categories":147,"keywords":148,"publishedAt":37},"01M6K5TP1KX237V9FDZ8PMNXH5","tdd-cat","TDD workflow with subagent-driven-development — \u002Ftdd composed with \u002Fcat, plus the A\u002FB TDD execution-mode axis (split-phase vs micro-cycle) asked as a third question in \u002Fcat's combined pre-dispatch question","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd-cat\u002FSKILL.md",[],[130,5,149,150,36,136,34,151,33,31,27,152,139,25,24,23,153,22,21],"tdd cat","workflow","tdd workflow","task","split",{"skillNo":155,"name":156,"nameZh":6,"description":157,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":158,"categories":159,"keywords":160,"publishedAt":37},"01M6K5TGDERXT82MS7SB3ZGA3V","task-list","TaskCreate \u002F TaskUpdate \u002F render the current TaskList in response to `\u002Ftask-list` (with or without flags). The skill body executes immediately on the syntax — no permission-seeking, no echoing the list back as plain text.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftask-list\u002FSKILL.md",[],[161,152,162,163,164,165,166,167,168,25,97,23,22,169],"list","task list","update","text","syntax","flags","back","permission","display",{"skillNo":171,"name":172,"nameZh":6,"description":173,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":174,"categories":175,"keywords":176,"publishedAt":37},"01M6K5T8CER0BAPJVJDG5F5GD0","sync","Sync files between two local directories, repos, or git worktrees. Five modes (plan\u002Finteractive\u002Fpush\u002Fpull\u002Fmirror), .gitignore-aware, Claude-workflow allowlist via --claude, dropbox-restore-style per-directory prompts.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Fsync\u002FSKILL.md",[],[172,150,177,178,179,180,181,182,183,184,185,186,187,188,189,190,22,21,191,192],"delete","pull","push","plan","interactive","git worktrees","files","restore","gitignore","local","dry","directories","yes","limit","mirror","modes"]