@alecsibilia/luca 14.0.0-alpha.10 → 14.0.0-alpha.12

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @alecsibilia/luca
 
+## 14.0.0-alpha.12
+
+No changes in this release.
+
+## 14.0.0-alpha.11
+
+No changes in this release.
+
 ## 14.0.0-alpha.10
 
 No changes in this release.

package/README.md

@@ -49,7 +49,7 @@ After a run, type `/luca-retro` the same way to look back on it: it reads the ru
 | `luca init` | Sets up this computer, once (safe to run again): MuninnDB and its Claude Code entry, the board in Paseo with its engine and Bun paths, the planning skills (`to-spec`, `to-tickets`, `setup-matt-pocock-skills`, `grilling`, `domain-modeling`), and Luca's own `/luca-unstick` and `/luca-retro` skills. It asks before turning on Paseo's plugins, and leaves skills you already have alone (it only replaces its own two). `--skip-skills` skips the planning skills. Inside a git repo, it then runs `luca setup` for that repo. |
 | `luca setup` | Gets the repo in this folder ready: the labels a run needs (and the `release:*` labels when the repo uses changesets), `.luca/config.json` (a new one gets the repo's GitHub name as its vault; an existing vault is kept), and a check of GitHub sub-issues and dependencies. `--base <branch>` names the base branch. |
 | `luca doctor` | Checks this computer, this repo when you're in one, and what v13 left behind. Each problem comes with its exact fix. `luca doctor --fix` fixes what's safe without asking: it never deletes (v13 files go to a dated backup folder) and never commits, and it lists the repo files to commit. |
-| `luca upgrade` | Moves to the newest Luca on your channel: `alpha` stays on `alpha`, and it never goes back to v13. It refuses while any run is going (stuck runs and limit waits count) and lists them. A run that crashed, with no engine running it, doesn't stop it: upgrade says how to resume it on the new version. Then it reloads the board, copies the new `/luca-unstick` and `/luca-retro` skills, and says when to run `/reload-skills`. |
+| `luca upgrade` | Moves to the newest Luca on your channel: `alpha` stays on `alpha`, and it never goes back to v13. It refuses while any run is going (stuck runs and limit waits count) and lists them. A run that crashed, with no engine running it, doesn't stop it: upgrade says how to resume it on the new version. Then the version it just installed finishes the job with its own code: it reloads the board, copies its skills (every one it ships, new ones included), and says when to run `/reload-skills`. |
 | `luca upgrade --to <version>` | Installs that exact version, an older one too, to go back when a version breaks. |
 
 `init`, `setup`, and `upgrade` end with their part of `luca doctor`'s checks.
@@ -92,7 +92,7 @@ This is the one package that goes to npm. It's TypeScript source with no build a
 | ------ | ---------- |
 | `engine/` | The engine's source, from [`packages/engine/src`](../engine/src). Both bins point into it. |
 | `board/` | The board plugin's folder, from [`packages/board`](../board): `paseo-plugin.json`, its entry points, its client, server, and shared code, and its own `package.json`, so Paseo can install it as a folder source. |
-| `skills/` | Luca's own Claude Code skills, `luca-unstick` and `luca-retro`, from [`packages/engine/skills`](../engine/skills). `luca init` and `luca upgrade` copy them to `~/.claude/skills`. |
+| `skills/` | Luca's own Claude Code skills, `luca-unstick` and `luca-retro`, from [`packages/engine/skills`](../engine/skills). `luca init` and `luca upgrade` copy every folder in it with a `SKILL.md` to `~/.claude/skills`. |
 | `LICENSE` | The repo's license. |
 
 Test files and test helpers stay out. The engine and the board stay private workspace packages, and this package lists every package they import at runtime as its own dependency.

package/board/client/board-panel.tsx

@@ -1327,7 +1327,7 @@ export const BoardPanel = ({
             ) : null}
             {state.jev.asked > 0 ? (
                 <Text style={styles.small}>
-                    Jev, in shadow mode: {state.jev.asked} asked,{' '}
+                    Decision model, in shadow mode: {state.jev.asked} asked,{' '}
                     {state.jev.answered} answered, {state.jev.failed} without an
                     answer. The engine doesn't act on them.
                 </Text>

package/board/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luca/board",
-    "version": "14.0.0-alpha.10",
+    "version": "14.0.0-alpha.12",
     "private": true,
     "type": "module"
 }

package/board/server/board-vocabulary.ts

@@ -304,10 +304,17 @@ export const BOARD_VOCABULARY = {
     worktrees_removed: z.looseObject({
         paths: z.array(z.string()).catch([]),
     }),
-    // Jev in shadow mode: counted, never acted on.
+    // The decision model (Clef; Jev in older journals) in shadow mode:
+    // counted, never acted on.
     jev_asked: JevJobSchema,
     jev_answered: JevJobSchema,
     jev_failed: JevJobSchema,
+    /**
+     * The decision model is off for the rest of the run (#534): no
+     * credentials, or Cloudflare turned them down. The board reads only the
+     * plain-words `detail`.
+     */
+    decision_model_off: z.looseObject({ detail: z.string().catch('') }),
     // Agent messages: sent inside an agent's turn, so they move nothing.
     agent_message: z.looseObject({
         from: z.string(),
@@ -490,6 +497,7 @@ const BoardEntrySchema = z.discriminatedUnion('kind', [
     entry({ kind: 'jev_asked' }),
     entry({ kind: 'jev_answered' }),
     entry({ kind: 'jev_failed' }),
+    entry({ kind: 'decision_model_off' }),
     entry({ kind: 'agent_message' }),
     entry({ kind: 'agent_message_delivered' }),
     entry({ kind: 'shared_git_changed' }),

package/board/server/luca-version.ts

@@ -1,2 +1,2 @@
 /** The Luca version of this board, stamped when the package was packed. */
-export const LUCA_VERSION: string = "14.0.0-alpha.10"
+export const LUCA_VERSION: string = "14.0.0-alpha.12"

package/board/server/make-rows.ts

@@ -227,8 +227,8 @@ const nothingToDoText = ({
 
 /**
  * What a record means in one line, or `null` for records that are noise in
- * a chat (snapshots, session summaries, a clean leftover scan, Jev in shadow
- * mode, ...).
+ * a chat (snapshots, session summaries, a clean leftover scan, the decision
+ * model's asks in shadow mode, ...).
  */
 export const describeRecord = ({
     before,
@@ -257,6 +257,11 @@ export const describeRecord = ({
                 text: `Config reloaded: ${record.content.changes.map(({ field }) => field).join(', ')} changed.`,
                 tone: 'info',
             })
+        case 'decision_model_off':
+            return event({
+                text: `Decision model off: ${record.content.detail}`,
+                tone: 'info',
+            })
         case 'config_reload_refused':
             return event({
                 text: `Config not reloaded, so the run keeps its own: ${record.content.reason.split('\n')[0] ?? ''}`,

package/board/server/reduce-board.ts

@@ -114,6 +114,7 @@ const QUIET_KINDS = new Set([
     'jev_asked',
     'jev_answered',
     'jev_failed',
+    'decision_model_off',
     'agent_message',
     'agent_message_delivered',
     'shared_git_changed',
@@ -1298,6 +1299,9 @@ const applyKind = ({
                 ...state,
                 jev: { ...state.jev, failed: state.jev.failed + 1 },
             }
+        // The decision model turning off is only a chat line (#534).
+        case 'decision_model_off':
+            return state
         case 'agent_message': {
             const refused = record.content.status === 'refused'
             return {

package/board/shared/board-state.ts

@@ -482,8 +482,9 @@ export const RunInfoSchema = z.object({
 export type RunInfo = z.infer<typeof RunInfoSchema>
 
 /**
- * Jev in shadow mode: how often the engine asked it and what came back. The
- * engine never acts on the answers, so the board only counts them.
+ * The decision model (Clef; Jev in older journals) in shadow mode: how often
+ * the engine asked it and what came back. The engine never acts on the
+ * answers, so the board only counts them.
  */
 export const JevCountsSchema = z.object({
     asked: z.number().int().min(0),

package/engine/cli/computer-adapters-real.ts

@@ -400,7 +400,7 @@ const PackageJsonSchema = z.looseObject({
 })
 
 /** The package a file belongs to: the nearest package.json with a name. */
-const packageOf = async (
+export const packageOf = async (
     file: string
 ): Promise<{ name: string; version: string | null } | null> => {
     for (let dir = dirname(file); ; dir = dirname(dir)) {

package/engine/cli/computer-checks.ts

@@ -26,14 +26,20 @@ import { claudeSkillsDir, skillDrift } from './luca-skills'
 import { isRight, rightEntry, userMuninnEntry } from './muninn-entry'
 
 import { LUCA_PACKAGE } from '../config/luca-version'
+import {
+    loadDecisionModelCredentials,
+    missingKeyLines,
+    type Env,
+} from '../jev/decision-model-credentials'
+import { DEFAULT_DECISION_MODEL } from '../jev/jev-schemas'
 import { READY_LABEL } from '../tracker/tracker'
 
 /**
  * `luca doctor`'s checks of this computer, read-only: Bun, the `luca`
  * copies on the PATH, Claude Code, the `gh` login, Paseo and its plugins,
  * the board, MuninnDB and Claude Code's `muninn` entry, the planning
- * skills, and Luca's own skills. `luca init` and `luca upgrade` end with them too. The token is
- * never shown.
+ * skills, Luca's own skills, and the decision model's credentials. `luca
+ * init` and `luca upgrade` end with them too. No token is ever shown.
  */
 
 /** The oldest tool versions Luca works with. */
@@ -329,8 +335,8 @@ const checkPlanningSkills = async ({ home }: { home: string }) => {
 }
 
 /**
- * Luca's own skills (#504): each is in `~/.claude/skills`, and its files
- * are the ones the installed Luca ships.
+ * Luca's own skills (#504): each one in the installed Luca's skills folder
+ * (#529) is in `~/.claude/skills`, and its files are the ones it ships.
  */
 const checkLucaSkills = async ({
     home,
@@ -342,10 +348,9 @@ const checkLucaSkills = async ({
     luca_version: string
 }) => {
     const drift = await skillDrift({ home, skills_dir })
-    const unshipped = drift.filter(({ unshipped }) => unshipped)
-    if (unshipped.length > 0) {
+    if (drift.length === 0) {
         return problem({
-            detail: `Luca's folder ${skills_dir} has no ${unshipped.map(({ skill }) => skill).join(', ')} skill.`,
+            detail: `Luca's folder ${skills_dir} has no skills.`,
             fix: `Reinstall Luca: bun add -g ${LUCA_PACKAGE}@alpha`,
         })
     }
@@ -368,12 +373,32 @@ const checkLucaSkills = async ({
     )
 }
 
+/**
+ * The decision model's Cloudflare credentials (#534), from Luca's own env
+ * file and the process env. With none it is off: a warning, not a problem,
+ * since runs go on without it. Never shows the token.
+ */
+const checkDecisionModel = async ({
+    env,
+    home,
+}: {
+    env: Env
+    home: string
+}) => {
+    const credentials = await loadDecisionModelCredentials({ env, home })
+    if (credentials.ok) return ok(`Clef set up (${DEFAULT_DECISION_MODEL})`)
+    return warning({
+        detail: `Decision model off: no credentials (${credentials.missing.join(' and ')} not set in ${credentials.file}).`,
+        fix: `Add these lines to ${credentials.file}: ${missingKeyLines(credentials).join(', ')} (a Workers AI token from the Cloudflare dashboard), or leave the decision model off.`,
+    })
+}
+
 /**
  * Runs the computer checks, in order, read-only. Never throws: a check that
  * fails becomes a problem.
  *
  * @example
- * const checks = await computerChecks({ home, luca_version, board_dir, skills_dir, engine_path, bun_path, computer, muninn, muninn_health, claude, paseo })
+ * const checks = await computerChecks({ home, luca_version, board_dir, skills_dir, engine_path, bun_path, computer, muninn, muninn_health, claude, paseo, env: process.env })
  */
 export const computerChecks = async ({
     home,
@@ -387,6 +412,7 @@ export const computerChecks = async ({
     muninn_health,
     claude,
     paseo,
+    env,
 }: {
     home: string
     /** The installed Luca's version. */
@@ -401,6 +427,11 @@ export const computerChecks = async ({
     muninn_health: MuninnHealth
     claude: ClaudeMcp
     paseo: Paseo
+    /**
+     * The process env, for the decision model's keys and `XDG_CONFIG_HOME`.
+     * Left out, none: only Luca's env file in `home` counts.
+     */
+    env?: Env
 }): Promise<DoctorCheck[]> => {
     // With Paseo down, its plugins and the board aren't asked about.
     let paseo_up = true
@@ -447,6 +478,10 @@ export const computerChecks = async ({
                 'luca_skills',
                 () => checkLucaSkills({ home, skills_dir, luca_version }),
             ],
+            [
+                'decision_model',
+                () => checkDecisionModel({ env: env ?? {}, home }),
+            ],
         ],
     })
 }

package/engine/cli/doctor-command.ts

@@ -65,6 +65,7 @@ export const doctorCommand = async ({
                           memory,
                       },
             tmp_dir: '/tmp',
+            env: process.env,
             log: (line) => {
                 console.log(line)
             },

package/engine/cli/doctor.ts

@@ -25,6 +25,7 @@ import {
 } from './v13-leftovers'
 
 import type { V13Manifest } from '../doctor/v13-manifest'
+import type { Env } from '../jev/decision-model-credentials'
 import type { MemoryClient } from '../memory/memory-client'
 import { runCommand } from '../shell/run-command'
 
@@ -32,7 +33,8 @@ import { runCommand } from '../shell/run-command'
  * `luca doctor [--fix]`: checks this computer, the repo when run inside
  * one, and what old Luca v13 left behind, and prints each check as OK, or
  * the problem and its exact fix. It exits 1 when any check is a problem;
- * warnings (memory off, planning-skill drift) don't fail it. When it finds
+ * warnings (memory off, the decision model off, planning-skill drift)
+ * don't fail it. When it finds
  * v13 leftovers, it links the migration guide.
  *
  * `--fix` fixes what's safe, without asking: it cleans up v13's leftovers
@@ -270,6 +272,7 @@ export const runDoctor = async ({
     repo,
     tmp_dir,
     v13_manifest,
+    env,
     log,
 }: LucaInstall & {
     home: string
@@ -285,6 +288,8 @@ export const runDoctor = async ({
     tmp_dir: string
     /** The v13 fingerprint list; defaults to the committed one. */
     v13_manifest?: V13Manifest
+    /** The process env, for the decision model's check. Left out, none. */
+    env?: Env
     log: (line: string) => void
 }): Promise<DoctorEnd> => {
     const check = async (): Promise<DoctorCheck[]> => [
@@ -300,6 +305,7 @@ export const runDoctor = async ({
             muninn_health,
             claude,
             paseo,
+            env,
         })),
         ...(repo === null
             ? []

package/engine/cli/init-command.ts

@@ -160,6 +160,7 @@ export const initCommand = async ({
             ask: askInTerminal,
             computer: computerOf({ home }),
             ...(await lucaInstall()),
+            env: process.env,
             log: (line) => {
                 console.log(line)
             },

package/engine/cli/init.ts

@@ -23,6 +23,8 @@ import { installLucaSkills } from './luca-skills'
 import { ensureMuninnEntry, hideToken } from './muninn-entry'
 import { runSetup } from './setup'
 
+import type { Env } from '../jev/decision-model-credentials'
+
 /**
  * `luca init`: sets up this computer for Luca, once, and is safe to run
  * again. It has three parts, each run even when an earlier one failed, and
@@ -297,6 +299,7 @@ export const runInit = async ({
     skills_dir,
     engine_path,
     bun_path,
+    env,
     log,
 }: LucaInstall & {
     home: string
@@ -312,6 +315,8 @@ export const runInit = async ({
     skills: SkillsTool
     ask: Ask
     computer: Computer
+    /** The process env, for the decision model's check. Left out, none. */
+    env?: Env
     log: (line: string) => void
 }): Promise<InitEnd> => {
     const memory = await setUpMemory({
@@ -356,6 +361,7 @@ export const runInit = async ({
         muninn_health,
         claude,
         paseo,
+        env,
     })
     for (const line of formatChecks({ checks: doctor })) log(line)
     const setup =

package/engine/cli/luca-run.ts

@@ -7,9 +7,13 @@
  *       --run-id <id> --board-plugin luca-board      (token in $LUCA_BOARD_TOKEN)
  *
  * A real run builds with real Claude agents (`createClaudeLauncher`: Claude
- * Opus 5.5, every guard on, paid by your Claude plan) and asks Jev in shadow
- * mode (`createTypeSafeJev`, which reads `TYPESAFE_API_KEY`; with no key each
- * ask is journaled as `missing_key` and the run goes on). Memory (#370) is
+ * Opus 5.5, every guard on, paid by your Claude plan) and asks the decision
+ * model, Cloudflare's Clef, in shadow mode (#534). Its credentials,
+ * `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_API_TOKEN`, come from Luca's own
+ * env file, `~/.config/luca/.env` (or `$XDG_CONFIG_HOME/luca/.env`), with
+ * the process env winning key by key; never from the repo's `.env`. With
+ * none, the decision model is off for the run: one line and one
+ * `decision_model_off` record, and no asks. Memory (#370) is
  * MuninnDB over MCP, found through `LUCA_MUNINN_URL` and `LUCA_MUNINN_TOKEN`
  * or Claude Code's `mcpServers.muninn` in `~/.claude.json`; with neither,
  * the run goes on without memory.
@@ -39,7 +43,7 @@ import {
 import { createClaudeLauncher } from '../agents/claude-launcher'
 import { createBoardSync, type BoardSync } from '../board/board-sync'
 import { createPaseoBoardLink } from '../board/paseo-board-link'
-import { createTypeSafeJev } from '../jev/jev-client'
+import { loadDecisionModelCredentials } from '../jev/decision-model-credentials'
 import { defaultRunsDir } from '../journal/journal'
 import {
     defaultSharedReadingsPath,
@@ -76,6 +80,14 @@ const memoryOf = async (): Promise<MemoryDeps | undefined> => {
     return { client: createMuninnMcpClient({ settings: found.settings }) }
 }
 
+/** The decision model's setup: its credentials from Luca's own env file. */
+const decisionModelSetup = async () => ({
+    credentials: await loadDecisionModelCredentials({
+        env: process.env,
+        home: homedir(),
+    }),
+})
+
 /**
  * The usage line (#434): the `luca-board` plugin's lines, and the readings
  * every run shares, both in Luca's state folder.
@@ -119,7 +131,7 @@ const run = async ({
             tracker: async ({ repo }) =>
                 createGitHubTracker({ repo: await githubRepoOf({ repo }) }),
             launcher: createClaudeLauncher({}),
-            jev: { client: createTypeSafeJev() },
+            decision_model: await decisionModelSetup(),
             memory: await memoryOf(),
             usage: usageLine(),
             board,
@@ -137,7 +149,7 @@ const run = async ({
         runs_dir: defaultRunsDir(),
         tracker,
         launcher: createClaudeLauncher({}),
-        jev: { client: createTypeSafeJev() },
+        decision_model: await decisionModelSetup(),
         memory: await memoryOf(),
         usage: usageLine(),
         board,

package/engine/cli/luca-skills.ts

@@ -5,20 +5,22 @@ import type { StepEnd } from './board-in-paseo'
 import { reason } from './doctor-checks'
 
 /**
- * Luca's own Claude Code skills: `/luca-unstick` (#504) and `/luca-retro`
- * (#514). They ship in the package's `skills/` folder, next to `engine/`
- * and `board/` (`packages/engine/skills/` in the repo). `luca init` and `luca upgrade`
- * copy them to `~/.claude/skills/<skill>/`, so they work in any repo and
- * any Paseo chat, and `luca doctor` checks the copy is the one the
- * installed Luca ships (`luca doctor --fix` copies it again).
+ * Luca's own Claude Code skills, such as `/luca-unstick` (#504) and
+ * `/luca-retro` (#514). They ship in the package's `skills/` folder, next
+ * to `engine/` and `board/` (`packages/engine/skills/` in the repo). `luca
+ * init` and `luca upgrade` copy them to `~/.claude/skills/<skill>/`, so
+ * they work in any repo and any Paseo chat, and `luca doctor` checks the
+ * copy is the one the installed Luca ships (`luca doctor --fix` copies it
+ * again).
+ *
+ * Which skills there are comes from that folder, not a list in the code
+ * (#529): every folder in it with a `SKILL.md`. So a skill new in a
+ * release is copied and checked even by code from before it.
  *
  * A copy writes every file the skill ships (not its tests), over Luca's own
  * earlier copy. It never deletes, and never touches other skills.
  */
 
-/** Luca's own skills, by folder name. */
-export const LUCA_SKILLS = ['luca-unstick', 'luca-retro']
-
 /** Test files stay in the repo: they aren't part of a skill. */
 const isTestFile = (path: string) => /\.test\.[cm]?[jt]sx?$/.test(path)
 
@@ -26,6 +28,31 @@ const isTestFile = (path: string) => /\.test\.[cm]?[jt]sx?$/.test(path)
 export const claudeSkillsDir = ({ home }: { home: string }): string =>
     join(home, '.claude', 'skills')
 
+/**
+ * Luca's own skills in `skills_dir`, by folder name, sorted: each folder
+ * with a `SKILL.md`. None when the folder is missing.
+ *
+ * @example
+ * await lucaSkills({ skills_dir }) // ['luca-retro', 'luca-unstick']
+ */
+export const lucaSkills = async ({
+    skills_dir,
+}: {
+    skills_dir: string
+}): Promise<string[]> => {
+    try {
+        const manifests = await Array.fromAsync(
+            new Bun.Glob('*/SKILL.md').scan({
+                cwd: skills_dir,
+                onlyFiles: true,
+            })
+        )
+        return manifests.map((manifest) => dirname(manifest)).toSorted()
+    } catch {
+        return []
+    }
+}
+
 /**
  * The files one skill ships, relative to its folder in `skills_dir`,
  * sorted: every file but tests. None when the folder is missing.
@@ -57,8 +84,6 @@ export const skillFiles = async ({
 /** How one installed skill differs from the one Luca ships. */
 export type SkillDrift = {
     skill: string
-    /** Luca's install folder has no files for it. */
-    unshipped: boolean
     /** Shipped files the installed copy lacks. */
     missing: string[]
     /** Shipped files whose installed copy has other content. */
@@ -67,7 +92,8 @@ export type SkillDrift = {
 
 /**
  * How each of Luca's skills in `~/.claude/skills` differs from the ones in
- * `skills_dir`; a skill that matches has empty lists. Read-only.
+ * `skills_dir`; a skill that matches has empty lists. None when
+ * `skills_dir` has no skills. Read-only.
  */
 export const skillDrift = async ({
     home,
@@ -77,7 +103,7 @@ export const skillDrift = async ({
     skills_dir: string
 }): Promise<SkillDrift[]> => {
     const drift: SkillDrift[] = []
-    for (const skill of LUCA_SKILLS) {
+    for (const skill of await lucaSkills({ skills_dir })) {
         const files = await skillFiles({ skills_dir, skill })
         const missing: string[] = []
         const changed: string[] = []
@@ -94,7 +120,7 @@ export const skillDrift = async ({
                 changed.push(file)
             }
         }
-        drift.push({ skill, unshipped: files.length === 0, missing, changed })
+        drift.push({ skill, missing, changed })
     }
     return drift
 }
@@ -107,7 +133,7 @@ export const skillDrift = async ({
  *
  * @example
  * await installLucaSkills({ home: homedir(), skills_dir, prefix: '[luca init]', log: console.log })
- * // [luca init] Luca's skills: installed /luca-unstick, /luca-retro in ~/.claude/skills
+ * // [luca init] Luca's skills: installed /luca-retro, /luca-unstick in ~/.claude/skills
  */
 export const installLucaSkills = async ({
     home,
@@ -125,17 +151,15 @@ export const installLucaSkills = async ({
         return { ok, message }
     }
     try {
+        const drift = await skillDrift({ home, skills_dir })
+        if (drift.length === 0) {
+            return say({
+                message: `${prefix} Luca's skills: Luca's folder ${skills_dir} has none. Reinstall Luca.`,
+                ok: false,
+            })
+        }
         const written: string[] = []
-        for (const { skill, unshipped, missing, changed } of await skillDrift({
-            home,
-            skills_dir,
-        })) {
-            if (unshipped) {
-                return say({
-                    message: `${prefix} Luca's skills: ${skill} isn't in Luca's folder ${skills_dir}. Reinstall Luca.`,
-                    ok: false,
-                })
-            }
+        for (const { skill, missing, changed } of drift) {
             for (const file of [...missing, ...changed]) {
                 const target = join(claudeSkillsDir({ home }), skill, file)
                 await mkdir(dirname(target), { recursive: true })