@thanhthi2895/luna-ai 2.16.2

package/agentic/opencode/.opencode/skills/cook/references/subagent-patterns.md

@@ -0,0 +1,76 @@
+# Subagent Patterns
+
+Standard patterns for spawning and using subagents in cook workflows.
+
+## Task Tool Pattern
+```
+Task(subagent_type="[type]", prompt="[task description]", description="[brief]")
+```
+
+## Research Phase
+```
+Task(subagent_type="researcher", prompt="Research [topic]. Report ≤150 lines.", description="Research [topic]")
+```
+- Use multiple researchers in parallel for different topics
+- Keep reports ≤150 lines with citations
+
+## Scout Phase
+```
+Task(subagent_type="Explore", prompt="Find files related to [feature] in codebase", description="Scout [feature]")
+```
+- Use `lu:scout` skill or `Explore` subagent for codebase search
+- Note: `scout` is a skill (`lu:scout`), not a subagent_type — use `subagent_type="Explore"` for Task spawning
+
+## Planning Phase
+```
+Task(subagent_type="planner", prompt="Create implementation plan based on reports: [reports]. Save to [path]", description="Plan [feature]")
+```
+- Input: researcher and scout reports
+- Output: `plan.md` + `phase-XX-*.md` files
+
+## UI Implementation
+```
+Task(subagent_type="ui-ux-designer", prompt="Implement [feature] UI per ./docs/design-guidelines.md", description="UI [feature]")
+```
+- For frontend work
+- Follow design guidelines
+
+## Testing
+```
+Task(subagent_type="tester", prompt="Run test suite for plan phase [phase-name]", description="Test [phase]")
+```
+- Must achieve 100% pass rate
+
+## Debugging
+```
+Task(subagent_type="debugger", prompt="Analyze failures: [details]", description="Debug [issue]")
+```
+- Use when tests fail
+- Provides root cause analysis
+
+## Code Review
+```
+Task(subagent_type="code-reviewer", prompt="Review changes for [phase]. Check security, performance, YAGNI/KISS/DRY. Return score (X/10), critical, warnings, suggestions.", description="Review [phase]")
+```
+
+## Project Management
+```
+Task(subagent_type="project-manager", prompt="Run full sync-back in [plan-path]: reconcile completed tasks with all phase files, backfill stale completed checkboxes across all phases, update plan.md status/progress, and report unresolved mappings.", description="Update plan")
+```
+
+## Documentation
+```
+Task(subagent_type="docs-manager", prompt="Update docs for [phase]. Changed files: [list]", description="Update docs")
+```
+
+## Git Operations
+```
+Task(subagent_type="git-manager", prompt="Stage and commit changes with conventional commit message", description="Commit changes")
+```
+
+## Parallel Execution
+```
+Task(subagent_type="fullstack-developer", prompt="Implement [phase-file] with file ownership: [files]", description="Implement phase [N]")
+```
+- Launch multiple for parallel phases
+- Include file ownership boundaries

package/agentic/opencode/.opencode/skills/cook/references/workflow-steps.md

@@ -0,0 +1,192 @@
+# Unified Workflow Steps
+
+All modes share core steps with mode-specific variations.
+
+## Step 0: Intent Detection & Setup
+
+1. Parse input with `intent-detection.md` rules
+2. Log detected mode: `✓ Step 0: Mode [X] - [reason]`
+3. If mode=code: detect plan path, set active plan
+4. Use `TaskCreate` to create workflow step tasks (with dependencies if complex)
+
+**Output:** `✓ Step 0: Mode [interactive|auto|fast|parallel|no-test|code] - [detection reason]`
+
+## Step 1: Research (skip if fast/code mode)
+
+**Interactive/Auto:**
+- Spawn multiple `researcher` agents in parallel
+- Start codebase search with `ccc search`; use `/scout` skill or `scout` agent only for broad discovery; use Glob/Grep for deterministic narrowing
+- Keep reports ≤150 lines
+
+**Task Tracking (≥3 researchers):**
+```
+// Register tasks BEFORE spawning
+TaskCreate(subject: "Research [topic]", activeForm: "Researching [topic]",
+  metadata: { agentType: "researcher", topic: "[topic]",
+              researchIndex: 1, totalResearchers: N })  // → taskId1
+// Repeat for each researcher
+
+// Mark in_progress then spawn all in single message
+TaskUpdate(taskId1, { status: "in_progress" })
+Task(subagent_type="researcher", prompt="...", description="Research [topic]")
+// ...
+
+// When report received
+TaskUpdate(taskId1, { status: "completed" })
+// Timeout (3m): TaskUpdate(taskId, { metadata: { error: "timeout" } })
+```
+- **Skip task tracking if:** researcher count ≤ 2 (overhead exceeds benefit)
+
+**Parallel:**
+- Optional: max 2 researchers if complex
+
+**Output:** `✓ Step 1: Research complete - [N] reports gathered`
+
+### [Review Gate 1] Post-Research (skip if auto mode)
+- Present research summary to user
+- Use `AskUserQuestion` to ask: "Proceed to planning?" / "Request more research" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 2: Planning
+
+**Interactive/Auto/No-test:**
+- Use `planner` agent with research context
+- Create `plan.md` + `phase-XX-*.md` files
+
+**Fast:**
+- Use `/plan --fast` with scout results only
+- Minimal planning, focus on action
+
+**Parallel:**
+- Use `/plan --parallel` for dependency graph + file ownership matrix
+
+**Code:**
+- Skip — plan already exists
+- Parse existing plan for phases
+
+**Output:** `✓ Step 2: Plan created - [N] phases`
+
+### [Review Gate 2] Post-Plan (skip if auto mode)
+- Present plan overview with phases
+- Use `AskUserQuestion` to ask: "Validate the plan or approve to start implementation?" — "Validate" / "Approve" / "Abort" / "Other" (request revisions)
+  - "Validate": run `/plan validate` slash command
+  - "Approve": continue to implementation
+  - "Abort": stop the workflow
+  - "Other": revise plan based on user feedback
+- **Auto mode:** Skip this gate
+
+## Step 3: Implementation
+
+**IMPORTANT:**
+1. `TaskList` first — check for existing tasks (hydrated by planning skill in same session)
+2. If tasks exist → pick them up, skip re-creation
+3. If no tasks → read plan phases, `TaskCreate` for each unchecked `[ ]` item with priority order and metadata (`phase`, `planDir`, `phaseFile`)
+4. Tasks can be blocked by other tasks via `addBlockedBy`
+
+**All modes:**
+- Use `TaskUpdate` to mark tasks as `in_progress` immediately.
+- Execute phase tasks sequentially (Step 3.1, 3.2, etc.)
+- Use `ui-ux-designer` for frontend
+- Use `ai-multimodal` for image assets
+- Run type checking after each file
+
+**Parallel mode:**
+- Utilize all tools of Claude Tasks: `TaskCreate`, `TaskUpdate`, `TaskGet` and `TaskList`
+- Launch multiple `fullstack-developer` agents
+- When agents pick up a task, use `TaskUpdate` to assign task to agent and mark tasks as `in_progress` immediately.
+- Respect file ownership boundaries
+- Wait for parallel group before next
+
+**Output:** `✓ Step 3: Implemented [N] files - [X/Y] tasks complete`
+
+### [Review Gate 3] Post-Implementation (skip if auto mode)
+- Present implementation summary (files changed, key changes)
+- Use `AskUserQuestion` to ask: "Proceed to testing?" / "Request implementation changes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 4: Testing (skip if no-test mode)
+
+**All modes (except no-test):**
+- Write tests: happy path, edge cases, errors
+- **MUST** spawn `tester` subagent: `Task(subagent_type="tester", prompt="Run test suite", description="Run tests")`
+- If failures: **MUST** spawn `debugger` subagent → fix → repeat
+- **Forbidden:** fake mocks, commented tests, changed assertions, skipping subagent delegation
+
+**Output:** `✓ Step 4: Tests [X/X passed] - tester subagent invoked`
+
+### [Review Gate 4] Post-Testing (skip if auto mode)
+- Present test results summary
+- Use `AskUserQuestion` to ask: "Proceed to code review?" / "Request test fixes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 5: Code Review
+
+**All modes - MANDATORY subagent:**
+- **MUST** spawn `code-reviewer` subagent: `Task(subagent_type="code-reviewer", prompt="Review changes. Return score, critical issues, warnings.", description="Code review")`
+- **DO NOT** review code yourself - delegate to subagent
+
+**Interactive/Parallel/Code/No-test:**
+- Interactive cycle (max 3): see `review-cycle.md`
+- Requires user approval
+
+**Auto:**
+- Auto-approve if score≥9.5 AND 0 critical
+- Auto-fix critical (max 3 cycles)
+- Escalate to user after 3 failed cycles
+
+**Fast:**
+- Simplified review, no fix loop
+- User approves or aborts
+
+**Output:** `✓ Step 5: Review [score]/10 - [Approved|Auto-approved] - code-reviewer subagent invoked`
+
+## Step 6: Finalize
+
+**All modes - MANDATORY subagents (NON-NEGOTIABLE):**
+1. **MUST** spawn these subagents in parallel:
+   - `Task(subagent_type="project-manager", prompt="Run full sync-back for [plan-path]: reconcile all completed Claude Tasks with all phase files, backfill stale completed checkboxes across every phase, then update plan.md frontmatter/table progress. Do NOT only mark current phase.", description="Update plan")`
+   - `Task(subagent_type="docs-manager", prompt="Update docs for changes.", description="Update docs")`
+2. Project-manager sync-back MUST include:
+   - Sweep all `phase-XX-*.md` files in the plan directory (also check `phases/` subdirectory for legacy format).
+   - Mark every completed item `[ ] → [x]` based on completed tasks (including earlier phases finished before current phase).
+   - Update `plan.md` status/progress (`pending`/`in-progress`/`completed`) from actual checkbox state.
+   - Return unresolved mappings if any completed task cannot be matched to a phase file.
+3. Use `TaskUpdate` to mark Claude Tasks complete after sync-back confirmation.
+4. Invoke `archive` skill to move plan to `plans/archive/` and clear active plan pointer.
+5. Onboarding check (API keys, env vars)
+6. **MUST** spawn git subagent: `Task(subagent_type="git-manager", prompt="Stage and commit changes", description="Commit")`
+
+**CRITICAL:** Step 6 is INCOMPLETE without spawning all 3 subagents AND invoking archive. DO NOT skip subagent delegation.
+
+**Auto mode:** Continue to next phase automatically, start from **Step 3**.
+**Others:** Ask user before next phase
+
+**Output:** `✓ Step 6: Finalized - 3 subagents invoked - Full-plan sync-back completed - Committed`
+
+## Mode-Specific Flow Summary
+
+Legend: `[R]` = Review Gate (human approval required)
+
+```
+interactive: 0 → 1 → [R] → 2 → [R] → 3 → [R] → 4 → [R] → 5(user) → 6
+auto:        0 → 1 → 2 → 3 → 4 → 5(auto) → 6 → next phase (NO stops)
+fast:        0 → skip → 2(fast) → [R] → 3 → [R] → 4 → [R] → 5(simple) → 6
+parallel:    0 → 1? → [R] → 2(parallel) → [R] → 3(multi-agent) → [R] → 4 → [R] → 5(user) → 6
+no-test:     0 → 1 → [R] → 2 → [R] → 3 → [R] → skip → 5(user) → 6
+code:        0 → skip → skip → 3 → [R] → 4 → [R] → 5(user) → 6
+```
+
+**Key difference:** `auto` mode is the ONLY mode that skips all review gates.
+
+## Critical Rules
+
+- Never skip steps without mode justification
+- **MANDATORY SUBAGENT DELEGATION:** Steps 4, 5, 6 MUST spawn subagents via Task tool. DO NOT implement directly.
+  - Step 4: `tester` (and `debugger` if failures)
+  - Step 5: `code-reviewer`
+  - Step 6: `project-manager`, `docs-manager`, `git-manager`
+- Use `TaskCreate` to create Claude Tasks for each unchecked item with priority order and dependencies.
+- Use `TaskUpdate` to mark Claude Tasks `in_progress` when picking up a task.
+- Use `TaskUpdate` to mark Claude Tasks `complete` immediately after finalizing the task.
+- All step outputs follow format: `✓ Step [N]: [status] - [metrics]`
+- **VALIDATION:** If Task tool calls = 0 at end of workflow, the workflow is INCOMPLETE.

package/agentic/opencode/.opencode/skills/create-skill/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: lu:create-skill
+author: luna
+description: Create new Luna skills with proper structure, sync to ~/.config/opencode/skills/, and register in AGENTS.md. Use when adding custom skills, extending Luna capabilities, building new workflows.
+argument-hint: "[skill-name or description]"
+---
+
+# Create Skill
+
+Scaffold, write, sync, and register new `lu:` skills end-to-end.
+
+**Scope:** Creates `lu:` skills in `agentic/opencode/.opencode/skills/`, syncs via hardlinks to `~/.config/opencode/skills/`, registers in AGENTS.md.
+Does NOT handle: `npx skills` marketplace, plugin distribution.
+
+## Workflow
+
+### Step 1 — Gather requirements
+
+Ask the user in your response:
+- **Skill name** (kebab-case, e.g., `my-skill`)
+- **Purpose** (1-2 sentences: what it does)
+- **Trigger phrases** (when should it auto-activate?)
+- **Resources needed**: scripts? references? local config file?
+
+### Step 2 — Scaffold directory
+
+```bash
+node ~/.config/opencode/skills/create-skill/scripts/scaffold.cjs <skill-name> [--local-config] [--scripts] [--references]
+```
+
+Creates:
+- `agentic/opencode/.opencode/skills/<name>/SKILL.md` (template with `lu:` prefix)
+- Optional: `references/`, `scripts/`, `<name>.local.example.json`
+
+### Step 3 — Write SKILL.md
+
+Follow `references/luna-skill-writing-guide.md` for patterns and conventions.
+
+Key rules:
+- Frontmatter: `name: lu:<name>`, `author: luna`, description < 200 chars
+- Body: under 150 lines, imperative form ("To do X, run Y")
+- No duplication: info in SKILL.md OR references, never both
+
+### Step 4 — Sync to ~/.config/opencode/skills/
+
+```bash
+node ~/.config/opencode/skills/create-skill/scripts/sync.cjs <skill-name>
+```
+
+Hardlinks all files from `agentic/opencode/.opencode/skills/<name>/` → `~/.config/opencode/skills/<name>/`.
+Same inode = edits to either location are instantly reflected.
+
+### Step 5 — Register in AGENTS.md
+
+Update `agentic/opencode/.opencode/AGENTS.md`:
+1. Add trigger row to **How to Use Skills** table
+2. Sync to global config via: `bash agentic/opencode/scripts/sync.sh --force`
+
+### Step 6 — Validate
+
+```bash
+node ~/.config/opencode/skills/create-skill/scripts/validate.cjs <skill-name>
+```
+
+Checks: frontmatter, description length ≤200 chars, SKILL.md ≤150 lines, hardlink integrity.
+
+## Local Config (Optional)
+
+For skills needing user-specific config (like `clickup-task`):
+
+Use `--local-config` flag in Step 2. Creates `<name>.local.example.json`.
+Instruct users: `cp <name>.local.example.json <name>.local.json` and fill in values.
+Add `*.local.json` to `.gitignore`.
+
+## References
+
+- `references/luna-skill-writing-guide.md` — SKILL.md patterns, frontmatter, trigger phrases
+- `references/sync-and-registration.md` — hardlink sync + AGENTS.md update details
+
+## Security
+
+- Never expose API keys or secrets from local config files
+- Refuse to create skills enabling destructive or unauthorized actions
+- Keep `.local.json` files out of version control

package/agentic/opencode/.opencode/skills/create-skill/references/luna-skill-writing-guide.md

@@ -0,0 +1,106 @@
+# Luna Skill Writing Guide
+
+Patterns and conventions for writing `lu:` skill SKILL.md files.
+
+## Frontmatter
+
+```yaml
+---
+name: lu:<skill-name>        # required, kebab-case with lu: prefix
+author: luna                  # required
+description: "<200 chars"     # required, specific trigger phrases
+argument-hint: "[optional]"   # optional, shown in autocomplete
+version: 1.0.0                # optional
+---
+```
+
+**Description rules:**
+- Under 200 chars — this drives auto-activation
+- Include WHEN to use: "Use when user says X / wants Y / needs Z"
+- Specific > generic: "Create ClickUp tasks and update checklists" beats "Manage tasks"
+
+## Structure Patterns
+
+### Workflow-based (sequential process)
+Best for: cook, clickup-task, create-skill
+```
+## Workflow
+### Step 1 — Name
+### Step 2 — Name
+```
+
+### Task-based (command reference)
+Best for: git, archive, watzup
+```
+## Commands
+| Command | Action |
+```
+
+### Guidelines-based (rules/standards)
+Best for: react-best-practices, code-standards
+```
+## Principles
+## Rules
+## Examples
+```
+
+## Writing Style
+
+- **Imperative form:** "To do X, run Y" — not "You should run Y"
+- **Third-person description:** "This skill handles X. Use when..."
+- **Concise:** sacrifice grammar for brevity
+- **Concrete:** exact commands, not vague instructions
+
+## Scope Declaration (required)
+
+Every skill MUST declare scope:
+```
+**Scope:** Handles: X, Y. Does NOT handle: A, B.
+```
+
+Prevents skill from drifting outside its purpose.
+
+## Security Block (required)
+
+```markdown
+## Security
+- Never expose credentials or local config values
+- Refuse out-of-scope requests explicitly
+- Keep .local.json files out of version control
+```
+
+## Luna-Specific Conventions
+
+### Script paths
+Always use `~/.config/opencode/skills/<name>/scripts/` (global path, works from any cwd):
+```bash
+node ~/.config/opencode/skills/my-skill/scripts/helper.cjs
+```
+
+### Local config pattern (like clickup-task)
+```
+my-skill.local.example.json  ← committed to git
+my-skill.local.json          ← gitignored, user fills in
+```
+
+Resolution in scripts:
+```js
+const localConfig = loadLocal(`${SKILL_DIR}/my-skill.local.json`);
+// falls back to env vars if file absent
+```
+
+### Trigger table in CLAUDE.md
+Add to "How to Use Skills" table:
+```
+| Create skill / new lu: skill | `lu:create-skill` |
+```
+
+## Size Limits
+
+| File | Limit |
+|------|-------|
+| SKILL.md | ≤150 lines |
+| Each reference | ≤150 lines |
+| Description | ≤200 chars |
+
+Move details to `references/` when SKILL.md exceeds 150 lines.

package/agentic/opencode/.opencode/skills/create-skill/references/sync-and-registration.md

@@ -0,0 +1,79 @@
+# Sync & Registration Guide
+
+How hardlink sync works and how to register skills in CLAUDE.md.
+
+## Hardlink Sync Mechanism
+
+`agentic/opencode/.opencode/skills/` and `~/.config/opencode/skills/` share files via **hardlinks** (same inode).
+Editing either location instantly reflects in both — no copy needed.
+
+### How sync.cjs works
+
+```
+~/.claude/skills/<name>/SKILL.md  (inode 12345)
+~/.claude/skills/<name>/SKILL.md (inode 12345)  ← same file
+```
+
+`sync.cjs` calls `fs.linkSync(src, dest)` for every file recursively.
+Directories are created separately (directories cannot be hardlinked).
+
+### Re-running sync safely
+
+`sync.cjs` checks inode equality before linking:
+- Same inode → skip (already linked)
+- Different inode → unlink dest, re-link from src
+
+### When to re-run sync
+
+- After adding new files to the skill directory
+- After the skill directory is recreated (e.g., from git clone)
+- After `~/.claude/` is reset or migrated to new machine
+
+## CLAUDE.md Registration
+
+Two locations must be updated (they are **not** hardlinked):
+
+| File | Purpose |
+|------|---------|
+| `~/.claude/CLAUDE.md` | Source of truth (in git) |
+| `~/.claude/CLAUDE.md` | Global config (read by Claude Code) |
+
+After editing `~/.claude/CLAUDE.md`, always sync:
+```bash
+cp ~/.claude/CLAUDE.md ~/.claude/CLAUDE.md
+```
+
+### Where to add entries
+
+**1. Skills Catalog section** — update count and add entry:
+```markdown
+## 🧰 Skills Catalog (36 Skills)   ← increment count
+
+- **Utility**: `lu:git`, ..., `lu:create-skill`   ← add here
+```
+
+**2. How to Use Skills table** — add trigger row:
+```markdown
+| Create skill / new lu: skill | `lu:create-skill` |
+```
+
+Place in the most relevant category group (Utility, Core, Execution, etc.).
+
+## Verifying Registration
+
+After update, confirm skill appears in Claude Code:
+1. Start new session (or `/clear`)
+2. Check system-reminder skills list includes your skill
+3. Run: `node ~/.claude/skills/create-skill/scripts/validate.cjs <name>`
+
+## Removing a Skill
+
+To fully remove a skill:
+```bash
+rm -rf ~/.claude/skills/<name>
+rm -rf ~/.claude/skills/<name>
+```
+Then remove entries from `~/.claude/CLAUDE.md` and sync:
+```bash
+cp ~/.claude/CLAUDE.md ~/.claude/CLAUDE.md
+```

package/agentic/opencode/.opencode/skills/create-skill/scripts/scaffold.cjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * scaffold.cjs — Initialize new Luna skill directory with template files
+ *
+ * Usage:
+ *   node scaffold.cjs <skill-name> [--local-config] [--scripts] [--references]
+ *
+ * Creates skill in agentic/opencode/.opencode/skills/<name>/ relative to cwd (git root).
+ * Flags:
+ *   --local-config   Add <name>.local.example.json template
+ *   --scripts        Add scripts/ subdirectory
+ *   --references     Add references/ subdirectory
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// --- Parse CLI args ---
+const args = process.argv.slice(2);
+const skillName = args[0];
+const hasLocalConfig = args.includes('--local-config');
+const hasScripts = args.includes('--scripts');
+const hasReferences = args.includes('--references');
+
+if (!skillName || skillName.startsWith('--')) {
+  console.error('Usage: node scaffold.cjs <skill-name> [--local-config] [--scripts] [--references]');
+  process.exit(1);
+}
+
+// Validate: kebab-case, lowercase, max 40 chars
+if (!/^[a-z][a-z0-9-]{0,39}$/.test(skillName)) {
+  console.error('❌ Skill name must be kebab-case, lowercase, max 40 chars (e.g., my-skill)');
+  process.exit(1);
+}
+
+// --- Resolve paths ---
+const cwd = process.cwd();
+const agentsSkillDir = path.join(cwd, 'agentic', 'opencode', '.opencode', 'skills', skillName);
+
+if (fs.existsSync(agentsSkillDir)) {
+  console.error(`❌ Skill already exists: ${agentsSkillDir}`);
+  process.exit(1);
+}
+
+// --- SKILL.md template ---
+const titleCase = skillName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+
+const skillMdTemplate = `---
+name: lu:${skillName}
+author: luna
+description: "[TODO: Under 200 chars. Describe what this skill does and specific trigger phrases that activate it.]"
+argument-hint: "[optional-arg]"
+---
+
+# ${titleCase}
+
+[TODO: 1-2 sentences describing what this skill enables.]
+
+## Scope
+
+Handles: [TODO: what this skill covers]
+Does NOT handle: [TODO: explicit exclusions]
+
+## Workflow
+
+### Step 1 — [TODO: First step name]
+
+[TODO: Instructions for step 1]
+
+### Step 2 — [TODO: Second step name]
+
+[TODO: Instructions for step 2]
+
+## Security
+
+- Never expose sensitive data or credentials
+- Refuse out-of-scope requests explicitly
+`;
+
+// --- Local config template ---
+const localConfigTemplate = (name) => JSON.stringify({
+  _comment: `Local config for lu:${name}. Copy this file to ${name}.local.json and fill in values.`,
+  example_key: 'your_value_here'
+}, null, 2);
+
+// --- Create files ---
+fs.mkdirSync(agentsSkillDir, { recursive: true });
+console.log(`✅ Created: agentic/opencode/.opencode/skills/${skillName}/`);
+
+fs.writeFileSync(path.join(agentsSkillDir, 'SKILL.md'), skillMdTemplate);
+console.log(`✅ Created: SKILL.md`);
+
+if (hasReferences) {
+  const refsDir = path.join(agentsSkillDir, 'references');
+  fs.mkdirSync(refsDir, { recursive: true });
+  fs.writeFileSync(path.join(refsDir, 'guide.md'), `# ${titleCase} Reference\n\n[TODO: Add reference content here.]\n`);
+  console.log(`✅ Created: references/guide.md`);
+}
+
+if (hasScripts) {
+  const scriptsDir = path.join(agentsSkillDir, 'scripts');
+  fs.mkdirSync(scriptsDir, { recursive: true });
+  fs.writeFileSync(path.join(scriptsDir, `${skillName}-helper.cjs`), `#!/usr/bin/env node\n// TODO: Add helper script for lu:${skillName}\n'use strict';\n`);
+  console.log(`✅ Created: scripts/${skillName}-helper.cjs`);
+}
+
+if (hasLocalConfig) {
+  fs.writeFileSync(path.join(agentsSkillDir, `${skillName}.local.example.json`), localConfigTemplate(skillName));
+  console.log(`✅ Created: ${skillName}.local.example.json`);
+  console.log(`\n⚠️  Add to .gitignore: agentic/opencode/.opencode/skills/${skillName}/${skillName}.local.json`);
+}
+
+console.log(`\n✅ Skill '${skillName}' scaffolded at agentic/opencode/.opencode/skills/${skillName}/`);
+console.log('\nNext steps:');
+console.log(`  1. Edit agentic/opencode/.opencode/skills/${skillName}/SKILL.md`);
+console.log(`  2. node ~/.config/opencode/skills/create-skill/scripts/sync.cjs ${skillName}`);
+console.log(`  3. node ~/.config/opencode/skills/create-skill/scripts/validate.cjs ${skillName}`);