@skillit/client 0.2.0

package/dist/model/cli/cli-client.js

@@ -0,0 +1,36 @@
+import { buildDraftPrompt, buildReviewPrompt, parseReviewVerdict } from '../anthropic.js';
+import { runCli } from './run.js';
+/**
+ * A {@link ModelClient} that drives an agent CLI (claude/codex/copilot) instead
+ * of the Anthropic API. Reuses the shared prompt builders and verdict parser;
+ * only the transport differs.
+ */
+export class CliModelClient {
+    adapter;
+    runner;
+    timeoutMs;
+    constructor(adapter, options = {}) {
+        this.adapter = adapter;
+        this.runner = options.runner ?? runCli;
+        this.timeoutMs = options.timeoutMs;
+    }
+    async run(role, prompt) {
+        const inv = this.adapter.invocation(role, prompt);
+        const stdout = await this.runner({
+            cmd: inv.cmd,
+            args: inv.args,
+            ...(inv.input !== undefined ? { input: inv.input } : {}),
+            ...(this.timeoutMs !== undefined ? { timeoutMs: this.timeoutMs } : {})
+        });
+        return this.adapter.extractResult(stdout);
+    }
+    async draft(req) {
+        const result = await this.run('draft', buildDraftPrompt(req));
+        return result.trim();
+    }
+    async review(req) {
+        const result = await this.run('review', buildReviewPrompt(req));
+        return parseReviewVerdict(result);
+    }
+}
+//# sourceMappingURL=cli-client.js.map

package/dist/model/cli/cli-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-client.js","sourceRoot":"","sources":["../../../src/model/cli/cli-client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAsB,MAAM,UAAU,CAAC;AAWtD;;;;GAIG;AACH,MAAM,OAAO,cAAc;IAKN,OAAO;IAJT,MAAM,CAAY;IAClB,SAAS,CAAU;IAEpC,YACmB,OAAmB,EACpC,OAAO,GAA0B,EAAE;uBADlB,OAAO;QAGxB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC;QACvC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IACrC,CAAC;IAEO,KAAK,CAAC,GAAG,CAAC,IAAwB,EAAE,MAAc;QACxD,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAClD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC;YAC/B,GAAG,EAAE,GAAG,CAAC,GAAG;YACZ,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxD,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACvE,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,GAAiB;QAC3B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,GAAkB;QAC7B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC;QAChE,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;CACF"}

package/dist/model/cli/run.d.ts

@@ -0,0 +1,17 @@
+export interface RunCliOptions {
+    /** Executable name (resolved on PATH) — never a shell string. */
+    cmd: string;
+    /** Arguments as an array — no shell, so no injection/escaping concerns. */
+    args: string[];
+    /** Optional text written to the child's stdin, then closed. */
+    input?: string;
+    /** Per-call timeout in milliseconds (default 120000). */
+    timeoutMs?: number;
+}
+/**
+ * Spawn `cmd` with `args` (no shell), optionally pipe `input` to stdin, and
+ * resolve the captured stdout. Throws on non-zero exit (message includes the
+ * command, exit code, and a stderr tail) or on timeout.
+ */
+export declare function runCli(opts: RunCliOptions): Promise<string>;
+//# sourceMappingURL=run.d.ts.map

package/dist/model/cli/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/model/cli/run.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA6D3D"}

package/dist/model/cli/run.js

@@ -0,0 +1,72 @@
+// packages/client/src/model/cli/run.ts
+import { spawn } from 'node:child_process';
+const DEFAULT_TIMEOUT_MS = 120_000;
+/**
+ * Spawn `cmd` with `args` (no shell), optionally pipe `input` to stdin, and
+ * resolve the captured stdout. Throws on non-zero exit (message includes the
+ * command, exit code, and a stderr tail) or on timeout.
+ */
+export function runCli(opts) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+        // On Windows, npm-installed CLIs are `.cmd`/`.bat` shims that Node cannot
+        // exec directly — they must go through the shell. This is injection-safe
+        // because every adapter delivers the (untrusted) prompt via stdin, so
+        // `args` only ever holds static flags and hardcoded model ids — no
+        // untrusted content reaches argv on any platform. On POSIX we keep the
+        // no-shell path regardless.
+        const child = spawn(opts.cmd, opts.args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32'
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill('SIGKILL');
+            reject(new Error(`${opts.cmd} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.stdout.on('data', (d) => {
+            stdout += d.toString();
+        });
+        child.stderr.on('data', (d) => {
+            stderr += d.toString();
+        });
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(new Error(`${opts.cmd} failed to start: ${err.message}`));
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                const tail = stderr.trim().slice(-500);
+                // Intentionally omit args from the message: an adapter may pass the
+                // prompt as an argument (copilot), and the prompt can be large/sensitive.
+                reject(new Error(`${opts.cmd} exited with code ${code}: ${tail}`));
+            }
+        });
+        // The child may exit before consuming stdin (e.g. an auth/usage failure),
+        // in which case writing a large prompt emits EPIPE. Swallow stdin errors so
+        // they don't crash the process as an unhandled stream error — the `close`
+        // handler still rejects with the real exit code + stderr. Also omit args
+        // from that message: the prompt is delivered here, not via argv.
+        child.stdin.on('error', () => { });
+        if (opts.input !== undefined) {
+            child.stdin.write(opts.input);
+        }
+        child.stdin.end();
+    });
+}
+//# sourceMappingURL=run.js.map

package/dist/model/cli/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../../src/model/cli/run.ts"],"names":[],"mappings":"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"}

package/dist/model/model-client-factory.d.ts

@@ -0,0 +1,16 @@
+import type { ModelClient } from '@skillit/core';
+import { type CliModelClientKind } from './cli/adapters.js';
+export type ModelClientKind = 'api' | CliModelClientKind;
+export interface CreateModelClientOptions {
+    /** Per-call timeout for CLI invocations. */
+    timeoutMs?: number;
+    /** Injectable PATH check (defaults to a real `command -v` probe). */
+    hasBinary?: (cmd: string) => boolean;
+}
+/**
+ * Build the {@link ModelClient} for the requested backend. `'api'` → the
+ * Anthropic API client; a CLI kind → a {@link CliModelClient} after a PATH
+ * pre-flight. Throws an actionable error for an unknown kind or a missing CLI.
+ */
+export declare function createModelClient(kind: string, options?: CreateModelClientOptions): ModelClient;
+//# sourceMappingURL=model-client-factory.d.ts.map

package/dist/model/model-client-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-client-factory.d.ts","sourceRoot":"","sources":["../../src/model/model-client-factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,OAAO,EAAc,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAExE,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,kBAAkB,CAAC;AAKzD,MAAM,WAAW,wBAAwB;IACvC,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACtC;AAqBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,wBAA6B,GACrC,WAAW,CAeb"}

package/dist/model/model-client-factory.js

@@ -0,0 +1,44 @@
+// packages/client/src/model/model-client-factory.ts
+import { execFileSync } from 'node:child_process';
+import { AnthropicModelClient } from './anthropic.js';
+import { CliModelClient } from './cli/cli-client.js';
+import { adapterFor } from './cli/adapters.js';
+const CLI_KINDS = ['claude', 'codex', 'copilot'];
+const ALL_KINDS = ['api', ...CLI_KINDS];
+function defaultHasBinary(cmd) {
+    try {
+        if (process.platform === 'win32') {
+            // `where` has no `-v` flag; `where <cmd>` exits non-zero when not found.
+            execFileSync('where', [cmd], { stdio: 'ignore' });
+        }
+        else {
+            // POSIX: `command -v <cmd>` is a shell builtin, so run it through a shell.
+            execFileSync('command', ['-v', cmd], { stdio: 'ignore', shell: true });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isCliKind(kind) {
+    return CLI_KINDS.includes(kind);
+}
+/**
+ * Build the {@link ModelClient} for the requested backend. `'api'` → the
+ * Anthropic API client; a CLI kind → a {@link CliModelClient} after a PATH
+ * pre-flight. Throws an actionable error for an unknown kind or a missing CLI.
+ */
+export function createModelClient(kind, options = {}) {
+    if (kind === 'api')
+        return new AnthropicModelClient();
+    if (!isCliKind(kind)) {
+        throw new Error(`invalid --model-client '${kind}'. Use one of: ${ALL_KINDS.join('|')}.`);
+    }
+    const hasBinary = options.hasBinary ?? defaultHasBinary;
+    if (!hasBinary(kind)) {
+        throw new Error(`${kind} CLI not found on PATH — install it, or use --model-client api (requires ANTHROPIC_API_KEY).`);
+    }
+    return new CliModelClient(adapterFor(kind), options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {});
+}
+//# sourceMappingURL=model-client-factory.js.map

package/dist/model/model-client-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-client-factory.js","sourceRoot":"","sources":["../../src/model/model-client-factory.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,UAAU,EAA2B,MAAM,mBAAmB,CAAC;AAIxE,MAAM,SAAS,GAAkC,CAAC,QAAQ,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;AAChF,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,GAAG,SAAS,CAAU,CAAC;AASjD,SAAS,gBAAgB,CAAC,GAAW;IACnC,IAAI,CAAC;QACH,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YACjC,yEAAyE;YACzE,YAAY,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,2EAA2E;YAC3E,YAAY,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACzE,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,SAAS,SAAS,CAAC,IAAY;IAC7B,OAAQ,SAA+B,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAY,EACZ,OAAO,GAA6B,EAAE;IAEtC,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,IAAI,oBAAoB,EAAE,CAAC;IACtD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,kBAAkB,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC3F,CAAC;IACD,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,gBAAgB,CAAC;IACxD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,8FAA8F,CACtG,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,cAAc,CACvB,UAAU,CAAC,IAAI,CAAC,EAChB,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CACxE,CAAC;AACJ,CAAC"}

package/dist/model/models.d.ts

@@ -0,0 +1,4 @@
+export declare const DRAFTER = "claude-sonnet-4-6";
+export declare const REVIEWER = "claude-opus-4-7";
+export declare const MAX_TOKENS = 1024;
+//# sourceMappingURL=models.d.ts.map

package/dist/model/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/model/models.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO,sBAAsB,CAAC;AAC3C,eAAO,MAAM,QAAQ,oBAAoB,CAAC;AAC1C,eAAO,MAAM,UAAU,OAAO,CAAC"}

package/dist/model/models.js

@@ -0,0 +1,8 @@
+// packages/client/src/model/models.ts
+// Shared model identifiers for the refine drafter/reviewer roles. Imported by
+// both the Anthropic API client and the claude CLI adapter so the role→model
+// mapping has one source of truth.
+export const DRAFTER = 'claude-sonnet-4-6';
+export const REVIEWER = 'claude-opus-4-7';
+export const MAX_TOKENS = 1024;
+//# sourceMappingURL=models.js.map

package/dist/model/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/model/models.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,8EAA8E;AAC9E,6EAA6E;AAC7E,mCAAmC;AACnC,MAAM,CAAC,MAAM,OAAO,GAAG,mBAAmB,CAAC;AAC3C,MAAM,CAAC,MAAM,QAAQ,GAAG,iBAAiB,CAAC;AAC1C,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,CAAC"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@skillit/client",
+  "version": "0.2.0",
+  "description": "Anthropic model client + skillit CLI (refine command)",
+  "license": "MIT",
+  "author": "Pradeep Mouli",
+  "bin": {
+    "skillit": "./dist/bin.js"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.100.0",
+    "commander": "^14.0.3",
+    "@skillit/mcp": "0.3.0",
+    "@skillit/core": "1.5.0",
+    "@skillit/cli": "0.4.0"
+  },
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json",
+    "gen-cli-skill": "pnpm build && node scripts/gen-refine-cli-skill.mjs",
+    "type-check": "tsgo --noEmit"
+  }
+}

package/scripts/gen-refine-cli-skill.mjs

@@ -0,0 +1,48 @@
+// Dogfood: generate a skill for the `skillit` CLI binary (the `refine` command)
+// using @skillit/cli's own commander introspection.
+//
+// Run via the package script (builds first):  pnpm --filter @skillit/client gen-cli-skill
+// Or directly, after building @skillit/client:  node packages/client/scripts/gen-refine-cli-skill.mjs
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { Command } from 'commander';
+import { extractCliSkill, writeCliSkill } from '@skillit/cli';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(here, '../../..');
+
+// This script reads the refine command from build output. `dist/` is not in the
+// repo by default, so fail with an actionable message rather than a raw
+// ERR_MODULE_NOT_FOUND when it is missing or stale.
+const refineDist = resolve(here, '../dist/commands/refine.js');
+if (!existsSync(refineDist)) {
+  console.error(
+    `Cannot find ${refineDist}.\nBuild @skillit/client first:  pnpm --filter @skillit/client build`
+  );
+  process.exit(1);
+}
+const { buildRefineCommand } = await import(refineDist);
+
+// Reconstruct the same program shape that packages/client/src/bin.ts ships.
+const program = new Command('skillit').description('skillit CLI').version('0.1.0');
+program.addCommand(buildRefineCommand());
+
+const skill = await extractCliSkill({
+  program,
+  metadata: {
+    name: 'skillit-refine',
+    description:
+      'Autonomously improve an MCP skill via the skillit audit→draft→review loop (build or runtime mode)',
+    keywords: ['skillit', 'refine', 'mcp', 'skill-generation', 'cli', 'audit', 'overlay'],
+    repository: 'https://github.com/pradeepmouli/skillit'
+  }
+});
+
+writeCliSkill(skill, { outDir: resolve(repoRoot, 'skills') });
+
+const issues = skill.audit?.issues ?? [];
+console.log(`Generated skills/skillit-refine/ — ${issues.length} audit finding(s).`);
+for (const i of issues) {
+  console.log(`  [${i.severity ?? '?'}] ${i.code ?? ''} ${i.message ?? ''}`.trimEnd());
+}

package/src/__tests__/anthropic-model.test.ts

@@ -0,0 +1,45 @@
+// packages/client/src/__tests__/anthropic-model.test.ts
+import { describe, it, expect } from 'vitest';
+import { parseReviewVerdict } from '../model/anthropic.js';
+
+describe('parseReviewVerdict', () => {
+  it('parses accepted verdict', () => {
+    const text = 'Looks good. {"verdict":"accepted","feedback":""}';
+    expect(parseReviewVerdict(text)).toEqual({ verdict: 'accepted', feedback: '' });
+  });
+
+  it('parses revise verdict', () => {
+    const text = '{"verdict":"revise","feedback":"Be more specific about edge cases"}';
+    expect(parseReviewVerdict(text)).toEqual({
+      verdict: 'revise',
+      feedback: 'Be more specific about edge cases'
+    });
+  });
+
+  it('fails open on malformed JSON — returns accepted', () => {
+    expect(parseReviewVerdict('not json at all')).toEqual({ verdict: 'accepted', feedback: '' });
+  });
+
+  it('fails open on missing verdict field', () => {
+    expect(parseReviewVerdict('{"feedback":"ok"}')).toEqual({
+      verdict: 'accepted',
+      feedback: 'ok'
+    });
+  });
+
+  it('parses revise verdict when feedback contains balanced braces', () => {
+    const text = '{"verdict":"revise","feedback":"handle {edge-case} and {null} inputs"}';
+    expect(parseReviewVerdict(text)).toEqual({
+      verdict: 'revise',
+      feedback: 'handle {edge-case} and {null} inputs'
+    });
+  });
+
+  it('parses revise verdict when feedback contains an unbalanced open brace', () => {
+    const text = '{"verdict":"revise","feedback":"use {var in templates"}';
+    expect(parseReviewVerdict(text)).toEqual({
+      verdict: 'revise',
+      feedback: 'use {var in templates'
+    });
+  });
+});

package/src/__tests__/anthropic-prompt.test.ts

@@ -0,0 +1,102 @@
+// packages/client/src/__tests__/anthropic-prompt.test.ts
+import { describe, it, expect } from 'vitest';
+import { buildDraftPrompt, buildReviewPrompt } from '../model/anthropic.js';
+import type { DraftRequest, ReviewRequest, ExtractedSkill } from '@skillit/core';
+
+const baseSkill = (): ExtractedSkill =>
+  ({ name: 'my-tool', functions: [] }) as unknown as ExtractedSkill;
+
+const baseDraftReq = (overrides: Partial<DraftRequest> = {}): DraftRequest => ({
+  toolName: 'tool_a',
+  tag: 'useWhen',
+  suggestion: 'Add @useWhen annotation',
+  currentValue: undefined,
+  skill: baseSkill(),
+  ...overrides
+});
+
+const baseReviewReq = (overrides: Partial<ReviewRequest> = {}): ReviewRequest => ({
+  toolName: 'tool_a',
+  tag: 'useWhen',
+  draft: 'Use this tool when listing files',
+  suggestion: 'Add @useWhen annotation',
+  skill: baseSkill(),
+  ...overrides
+});
+
+describe('buildDraftPrompt', () => {
+  it('includes a Conventions section with guidance text when guidance is provided', () => {
+    const req = baseDraftReq({ guidance: 'Always use active voice.' });
+    const prompt = buildDraftPrompt(req);
+    expect(prompt).toContain('Conventions');
+    expect(prompt).toContain('Always use active voice.');
+  });
+
+  it('does NOT include a Conventions section when guidance is undefined', () => {
+    const req = baseDraftReq({ guidance: undefined });
+    const prompt = buildDraftPrompt(req);
+    expect(prompt).not.toContain('Conventions');
+  });
+
+  it('does NOT include a Conventions section when guidance is absent', () => {
+    const req = baseDraftReq();
+    const prompt = buildDraftPrompt(req);
+    expect(prompt).not.toContain('Conventions');
+  });
+
+  it('still includes core prompt content regardless of guidance', () => {
+    const req = baseDraftReq({ guidance: 'Some guidance.' });
+    const prompt = buildDraftPrompt(req);
+    expect(prompt).toContain('tool_a');
+    expect(prompt).toContain('@useWhen');
+  });
+
+  it('uses source-neutral framing (no hardcoded MCP) and keeps guidance', () => {
+    const req = baseDraftReq({ guidance: 'CLI conventions: use --flag syntax.' });
+    const prompt = buildDraftPrompt(req);
+    expect(prompt).not.toContain('MCP');
+    expect(prompt).toContain('skill annotations for "my-tool"');
+    expect(prompt).toContain('Conventions');
+    expect(prompt).toContain('CLI conventions: use --flag syntax.');
+  });
+});
+
+describe('buildReviewPrompt', () => {
+  it('includes a Conventions section with guidance text when guidance is provided', () => {
+    const req = baseReviewReq({ guidance: 'Always use active voice.' });
+    const prompt = buildReviewPrompt(req);
+    expect(prompt).toContain('Conventions');
+    expect(prompt).toContain('Always use active voice.');
+    expect(prompt.indexOf('Conventions')).toBeLessThan(prompt.indexOf('Respond with JSON only'));
+  });
+
+  it('does NOT include a Conventions section when guidance is undefined', () => {
+    const req = baseReviewReq({ guidance: undefined });
+    const prompt = buildReviewPrompt(req);
+    expect(prompt).not.toContain('Conventions');
+  });
+
+  it('does NOT include a Conventions section when guidance is absent', () => {
+    const req = baseReviewReq();
+    const prompt = buildReviewPrompt(req);
+    expect(prompt).not.toContain('Conventions');
+  });
+
+  it('still includes core prompt content regardless of guidance', () => {
+    const req = baseReviewReq({ guidance: 'Some guidance.' });
+    const prompt = buildReviewPrompt(req);
+    expect(prompt).toContain('tool_a');
+    expect(prompt).toContain('@useWhen');
+    expect(prompt).toContain('Use this tool when listing files');
+  });
+
+  it('uses source-neutral framing (no hardcoded MCP) and keeps guidance + JSON instruction', () => {
+    const req = baseReviewReq({ guidance: 'CLI conventions: use --flag syntax.' });
+    const prompt = buildReviewPrompt(req);
+    expect(prompt).not.toContain('MCP');
+    expect(prompt).toContain('skill annotation draft for "my-tool"');
+    expect(prompt).toContain('Conventions');
+    expect(prompt).toContain('CLI conventions: use --flag syntax.');
+    expect(prompt).toContain('Respond with JSON only');
+  });
+});

package/src/__tests__/cli-adapters.test.ts

@@ -0,0 +1,119 @@
+// packages/client/src/__tests__/cli-adapters.test.ts
+import { describe, it, expect } from 'vitest';
+import { claudeAdapter, codexAdapter, copilotAdapter, adapterFor } from '../model/cli/adapters.js';
+import { DRAFTER, REVIEWER } from '../model/models.js';
+
+describe('claudeAdapter', () => {
+  it('maps draft role to the drafter model and review role to the reviewer model', () => {
+    const draft = claudeAdapter.invocation('draft', 'PROMPT');
+    expect(draft.cmd).toBe('claude');
+    expect(draft.args).toEqual(['-p', '--output-format', 'json', '--model', DRAFTER]);
+    expect(draft.input).toBe('PROMPT');
+    const review = claudeAdapter.invocation('review', 'PROMPT');
+    expect(review.args).toContain(REVIEWER);
+  });
+
+  it('extracts result from the claude json envelope', () => {
+    const stdout = JSON.stringify({ type: 'result', is_error: false, result: 'the answer' });
+    expect(claudeAdapter.extractResult(stdout)).toBe('the answer');
+  });
+
+  it('throws when claude reports is_error', () => {
+    const stdout = JSON.stringify({ type: 'result', is_error: true, result: 'nope' });
+    expect(() => claudeAdapter.extractResult(stdout)).toThrow(/claude/i);
+  });
+
+  it('returns an empty result string (does not editorialize)', () => {
+    const stdout = JSON.stringify({ type: 'result', is_error: false, result: '' });
+    expect(claudeAdapter.extractResult(stdout)).toBe('');
+  });
+});
+
+describe('codexAdapter', () => {
+  it('invokes codex exec --json with the prompt on stdin and no per-role model', () => {
+    const inv = codexAdapter.invocation('draft', 'PROMPT');
+    expect(inv.cmd).toBe('codex');
+    expect(inv.args).toEqual(['exec', '--json']);
+    expect(inv.input).toBe('PROMPT');
+    // role-agnostic: review uses the same invocation
+    expect(codexAdapter.invocation('review', 'PROMPT').args).toEqual(['exec', '--json']);
+  });
+
+  it('extracts the last agent_message from the jsonl stream, skipping log/noise lines', () => {
+    const stdout = [
+      'some non-json log line',
+      JSON.stringify({ type: 'thread.started', thread_id: 'x' }),
+      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'first' } }),
+      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'final' } }),
+      JSON.stringify({ type: 'turn.completed' })
+    ].join('\n');
+    expect(codexAdapter.extractResult(stdout)).toBe('final');
+  });
+
+  it('returns an empty final agent_message, overriding an earlier non-empty one (last-wins on empty)', () => {
+    const stdout = [
+      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'first' } }),
+      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: '' } })
+    ].join('\n');
+    expect(codexAdapter.extractResult(stdout)).toBe('');
+  });
+
+  it('throws when no agent_message is present', () => {
+    expect(() => codexAdapter.extractResult('{"type":"turn.completed"}')).toThrow(/codex/i);
+  });
+
+  it('surfaces a turn.failed signal in the no-message error', () => {
+    const stdout = JSON.stringify({ type: 'turn.failed' });
+    expect(() => codexAdapter.extractResult(stdout)).toThrow(/turn\.failed/);
+  });
+});
+
+describe('copilotAdapter', () => {
+  it('pipes the prompt via stdin (not argv) so untrusted content stays out of argv', () => {
+    const inv = copilotAdapter.invocation('draft', 'PROMPT');
+    expect(inv.cmd).toBe('copilot');
+    expect(inv.args).toEqual(['--output-format', 'json', '--no-color']);
+    expect(inv.args).not.toContain('PROMPT');
+    expect(inv.input).toBe('PROMPT');
+  });
+
+  it('extracts the last assistant.message content from the jsonl stream, skipping deltas/result', () => {
+    const stdout = [
+      JSON.stringify({ type: 'assistant.message_delta', data: { deltaContent: 'the ' } }),
+      JSON.stringify({ type: 'assistant.message_delta', data: { deltaContent: 'answer' } }),
+      JSON.stringify({
+        type: 'assistant.message',
+        data: { content: 'the answer', toolRequests: [] }
+      }),
+      JSON.stringify({ type: 'result', exitCode: 0 })
+    ].join('\n');
+    expect(copilotAdapter.extractResult(stdout)).toBe('the answer');
+  });
+
+  it('returns an empty assistant.message content (does not editorialize)', () => {
+    const stdout = [
+      JSON.stringify({ type: 'assistant.message', data: { content: 'first', toolRequests: [] } }),
+      JSON.stringify({ type: 'assistant.message', data: { content: '', toolRequests: [] } })
+    ].join('\n');
+    expect(copilotAdapter.extractResult(stdout)).toBe('');
+  });
+
+  it('throws when no assistant.message is present', () => {
+    expect(() => copilotAdapter.extractResult('{"type":"result","exitCode":0}')).toThrow(
+      /copilot/i
+    );
+  });
+
+  it('surfaces a nonzero result exitCode in the no-message error', () => {
+    const stdout = JSON.stringify({ type: 'result', exitCode: 1 });
+    expect(() => copilotAdapter.extractResult(stdout)).toThrow(/exitCode 1/);
+  });
+});
+
+describe('adapterFor', () => {
+  it('returns the matching adapter', () => {
+    expect(adapterFor('claude')).toBe(claudeAdapter);
+    expect(adapterFor('codex')).toBe(codexAdapter);
+    expect(adapterFor('copilot')).toBe(copilotAdapter);
+  });
+});

package/src/__tests__/cli-client.test.ts

@@ -0,0 +1,58 @@
+// packages/client/src/__tests__/cli-client.test.ts
+import { describe, it, expect, vi } from 'vitest';
+import { CliModelClient } from '../model/cli/cli-client.js';
+import { claudeAdapter } from '../model/cli/adapters.js';
+import type { DraftRequest, ReviewRequest, ExtractedSkill } from '@skillit/core';
+
+const skill = { name: 'demo' } as unknown as ExtractedSkill;
+const draftReq: DraftRequest = {
+  toolName: 'gen',
+  tag: 'useWhen',
+  suggestion: 'say when',
+  currentValue: undefined,
+  skill
+};
+const reviewReq: ReviewRequest = {
+  toolName: 'gen',
+  tag: 'useWhen',
+  draft: 'When generating',
+  suggestion: 'say when',
+  skill
+};
+
+describe('CliModelClient', () => {
+  it('draft() returns the trimmed result extracted from the adapter envelope', async () => {
+    const runner = vi.fn(async () =>
+      JSON.stringify({ type: 'result', is_error: false, result: '  When generating output  ' })
+    );
+    const client = new CliModelClient(claudeAdapter, { runner });
+    const out = await client.draft(draftReq);
+    expect(out).toBe('When generating output');
+    // the adapter's invocation was forwarded to the runner
+    expect(runner).toHaveBeenCalledWith(
+      expect.objectContaining({ cmd: 'claude', args: expect.arrayContaining(['-p']) })
+    );
+  });
+
+  it('review() parses the verdict JSON out of the adapter result', async () => {
+    const runner = vi.fn(async () =>
+      JSON.stringify({
+        type: 'result',
+        is_error: false,
+        result: 'Sure: {"verdict":"revise","feedback":"too vague"}'
+      })
+    );
+    const client = new CliModelClient(claudeAdapter, { runner });
+    const res = await client.review(reviewReq);
+    expect(res).toEqual({ verdict: 'revise', feedback: 'too vague' });
+  });
+
+  it('passes the configured timeout through to the runner', async () => {
+    const runner = vi.fn(async () =>
+      JSON.stringify({ type: 'result', is_error: false, result: 'x' })
+    );
+    const client = new CliModelClient(claudeAdapter, { runner, timeoutMs: 5000 });
+    await client.draft(draftReq);
+    expect(runner).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 5000 }));
+  });
+});