@bglocation/tune-context 1.0.0

package/cli/sync-doctrine.mjs

@@ -0,0 +1,29 @@
+// Mirrors this package's skills/agents/hooks into a Claude Code config dir
+// (~/.claude by default). Idempotent — removes each destination entry before
+// copying, so deletions at the source propagate too, not just an overlay.
+import { chmodSync, cpSync, existsSync, mkdirSync, readdirSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+/**
+ * @param {string} pkgRoot - root of the tune-context package (contains skills/, agents/, hooks/)
+ * @param {string} claudeDir - destination Claude config dir (e.g. ~/.claude)
+ * @returns {{kind: string, name: string, dest: string}[]} synced items
+ */
+export function syncDoctrine(pkgRoot, claudeDir) {
+  const synced = [];
+  for (const kind of ['skills', 'agents', 'hooks']) {
+    const from = join(pkgRoot, kind);
+    if (!existsSync(from)) continue;
+    for (const entry of readdirSync(from)) {
+      if (kind === 'hooks' && entry === 'hooks.json') continue; // plugin-only manifest, not a script to install
+      const s = join(from, entry);
+      const d = join(claudeDir, kind, entry);
+      rmSync(d, { recursive: true, force: true });
+      mkdirSync(dirname(d), { recursive: true });
+      cpSync(s, d, { recursive: true });
+      if (kind === 'hooks') chmodSync(d, 0o755);
+      synced.push({ kind, name: entry, dest: d });
+    }
+  }
+  return synced;
+}

package/cli/verify.mjs

@@ -0,0 +1,52 @@
+// Re-checks what generate.mjs claims to have done — "the merge actually
+// landed" per SKILL.md §3. Never trust that a write succeeded just because
+// the function returned; re-read the target file and parse it.
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @returns {{ok: boolean, checks: {name: string, ok: boolean, detail?: string}[]}}
+ */
+export function verify({ claudeDir, userSettingsPath, expectedHookCommands, projectSettingsPath, expectedPermissions }) {
+  const checks = [];
+
+  const settings = readJson(userSettingsPath);
+  for (const { event, scriptName } of expectedHookCommands) {
+    const entries = settings?.hooks?.[event] || [];
+    const ok = entries.some((g) => g.hooks?.some((h) => h.command?.includes(scriptName)));
+    checks.push({ name: `hooks.${event} registers ${scriptName}`, ok, detail: ok ? undefined : `not found in ${userSettingsPath}` });
+  }
+
+  const scriptNames = [...new Set(expectedHookCommands.map((h) => h.scriptName))];
+  for (const scriptName of scriptNames) {
+    const scriptPath = join(claudeDir, 'hooks', scriptName);
+    const exists = existsSync(scriptPath);
+    const executable = exists && Boolean(statSync(scriptPath).mode & 0o111);
+    checks.push({ name: `${scriptName} installed + executable`, ok: exists && executable, detail: !exists ? 'missing' : !executable ? 'not executable' : undefined });
+  }
+
+  if (projectSettingsPath && expectedPermissions?.length) {
+    const projectSettings = readJson(projectSettingsPath);
+    const allow = projectSettings?.permissions?.allow || [];
+    for (const perm of expectedPermissions) {
+      const ok = allow.includes(perm);
+      checks.push({ name: `permissions.allow has ${perm}`, ok, detail: ok ? undefined : `not found in ${projectSettingsPath}` });
+    }
+  }
+
+  const skillsDir = join(claudeDir, 'skills');
+  for (const skill of ['token-efficiency', 'caveman', 'cdd', 'phase-workflow']) {
+    const ok = existsSync(join(skillsDir, skill, 'SKILL.md'));
+    checks.push({ name: `skill ${skill} installed`, ok, detail: ok ? undefined : `missing ${join(skillsDir, skill, 'SKILL.md')}` });
+  }
+
+  return { ok: checks.every((c) => c.ok), checks };
+}

package/eval/adoption-report.mjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+// adoption-report — the tune-context analog of `rag-usage`. Reads the JSONL
+// that adoption-log.mjs appends (from the PostToolUse + SubagentStart hooks) and
+// prints which token-saving levers the model is actually reaching for: RAG vs
+// grep, doctrine skills, subagents, and re-read churn. Verdict at the end: which
+// levers show adoption, which don't. See tasks/TASK-062.
+//
+// Honest scope (printed in the report too):
+//   • Cost is NOT here. Claude Code exposes token cost only via OTEL
+//     (`claude_code.cost.usage`, needs a collector) — never a hook. This report
+//     measures *behavior* (a proxy), not dollars. OTEL is the opt-in complement.
+//   • caveman can't be measured: it's an output style, not a tool call.
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+
+const DOCTRINE_SKILLS = new Set([
+  'token-efficiency',
+  'caveman',
+  'cdd',
+  'phase-workflow',
+]);
+
+function defaultLogPath() {
+  return join(homedir(), '.claude', 'tune-context', 'adoption.jsonl');
+}
+
+const USAGE = `
+adoption-report — which token-saving levers is the model actually using?
+
+Usage:
+  adoption-report [--log <path>]
+
+Options:
+  --log <path>   Path to adoption.jsonl (default: ~/.claude/tune-context/adoption.jsonl)
+  -h, --help     Show this help
+
+The log is written by the adoption-log.mjs PostToolUse hook (installed by
+tune-context). Cost in dollars is NOT here — that needs OTEL (see report footer).
+`.trim();
+
+export function parseLog(text) {
+  const out = [];
+  for (const line of text.split('\n')) {
+    const t = line.trim();
+    if (t === '') continue;
+    try {
+      const o = JSON.parse(t);
+      if (o && typeof o === 'object' && typeof o.lever === 'string') out.push(o);
+    } catch {
+      // malformed line — skip
+    }
+  }
+  return out;
+}
+
+export function aggregate(records) {
+  const search = { rag: 0, text: 0, glob: 0 };
+  const skills = new Map();
+  const subagents = new Map();
+  const readCounts = new Map(); // detail(file) -> times read
+  let reads = 0;
+  let edits = 0;
+  let bash = 0;
+  let other = 0;
+
+  const bump = (m, k) => m.set(k, (m.get(k) ?? 0) + 1);
+
+  for (const r of records) {
+    switch (r.lever) {
+      case 'search':
+        if (r.detail === 'rag') search.rag++;
+        else if (r.detail === 'glob') search.glob++;
+        else search.text++;
+        break;
+      case 'skill':
+        bump(skills, r.detail ?? '(unknown)');
+        break;
+      case 'subagent':
+        bump(subagents, r.detail ?? '(unknown)');
+        break;
+      case 'read':
+        reads++;
+        if (r.detail) bump(readCounts, r.detail);
+        break;
+      case 'edit':
+        edits++;
+        break;
+      case 'bash':
+        bash++;
+        break;
+      default:
+        other++;
+    }
+  }
+
+  const contentSearches = search.rag + search.text;
+  const ragShare = contentSearches > 0 ? search.rag / contentSearches : null;
+
+  // Re-read churn proxy: files opened more than once, and the extra opens beyond
+  // the first. High churn hints the model is re-fetching context it lost — the
+  // symptom compaction hooks and RAG are meant to reduce.
+  let reReadFiles = 0;
+  let redundantReads = 0;
+  for (const n of readCounts.values()) {
+    if (n > 1) {
+      reReadFiles++;
+      redundantReads += n - 1;
+    }
+  }
+
+  return {
+    total: records.length,
+    search,
+    ragShare,
+    skills: [...skills.entries()].sort((a, b) => b[1] - a[1]),
+    subagents: [...subagents.entries()].sort((a, b) => b[1] - a[1]),
+    reads,
+    edits,
+    bash,
+    other,
+    reReadFiles,
+    redundantReads,
+    reReadRate: reads > 0 ? redundantReads / reads : null,
+  };
+}
+
+function pct(x) {
+  return x === null ? 'n/a' : `${Math.round(x * 100)}%`;
+}
+
+export function formatReport(a) {
+  const L = [];
+  L.push('tune-context Adoption Report');
+  L.push('============================');
+  L.push('');
+  L.push(`Tool calls logged: ${a.total}`);
+  L.push('');
+
+  L.push('Search — RAG vs grep:');
+  L.push(`  semantic (RAG):  ${a.search.rag}`);
+  L.push(`  text (grep/find):${String(a.search.text).padStart(2)}`);
+  L.push(`  glob (file find):${String(a.search.glob).padStart(2)}`);
+  L.push(
+    `  RAG share of content search: ${pct(a.ragShare)}` +
+      (a.ragShare === null ? '  (no content searches yet)' : ''),
+  );
+  L.push('');
+
+  L.push(`Doctrine skills invoked: ${a.skills.length} distinct`);
+  for (const [name, n] of a.skills) {
+    const mark = DOCTRINE_SKILLS.has(name) ? '★' : ' ';
+    L.push(`  ${mark} ${String(n).padStart(3)}×  ${name}`);
+  }
+  if (a.skills.length === 0) L.push('  (none — doctrine skills unused)');
+  L.push('');
+
+  L.push(`Subagents spawned: ${a.subagents.length} distinct`);
+  for (const [name, n] of a.subagents) {
+    L.push(`    ${String(n).padStart(3)}×  ${name}`);
+  }
+  if (a.subagents.length === 0) L.push('  (none)');
+  L.push('');
+
+  L.push('Context churn (re-read proxy):');
+  L.push(`  reads: ${a.reads}   edits: ${a.edits}   bash: ${a.bash}`);
+  L.push(
+    `  re-read files: ${a.reReadFiles}  redundant opens: ${a.redundantReads}` +
+      `  (${pct(a.reReadRate)} of reads)`,
+  );
+  L.push('');
+
+  // Verdict — behavioral, not a cost claim. Frozen thresholds so the model
+  // doesn't grade its own work on a sliding scale (anti-bias, per TASK-062).
+  L.push('Verdict (behavioral proxy — freeze thresholds with PO before trusting):');
+  if (a.total === 0) {
+    L.push('  No data yet. Run some sessions with the hook installed, then re-run.');
+  } else {
+    if (a.ragShare !== null) {
+      L.push(
+        a.ragShare >= 0.5
+          ? '  ✓ RAG lever working — semantic search is the default over grep.'
+          : '  ✗ RAG lever weak — grep still dominates content search. Revisit index/skill wiring.',
+      );
+    }
+    L.push(
+      a.skills.length > 0
+        ? '  ✓ Doctrine skills are being invoked.'
+        : '  ✗ Doctrine skills unused — check skill descriptions / discoverability.',
+    );
+    L.push(
+      a.reReadRate !== null && a.reReadRate <= 0.25
+        ? '  ✓ Low re-read churn.'
+        : '  ~ Elevated re-read churn — context may be getting lost (compaction/RAG lever).',
+    );
+  }
+  L.push('');
+  L.push('Cost (dollars) is not measurable from hooks. For hard cost, enable OTEL:');
+  L.push('  CLAUDE_CODE_ENABLE_TELEMETRY=1 + an OTLP collector →');
+  L.push('  metric `claude_code.cost.usage` (direct) / `claude_code.token.usage`.');
+  L.push('  caveman (output style) leaves no tool call — not measured here.');
+
+  return L.join('\n');
+}
+
+function main() {
+  let logPath;
+  try {
+    const { values } = parseArgs({
+      args: process.argv.slice(2),
+      options: {
+        log: { type: 'string' },
+        help: { type: 'boolean', short: 'h', default: false },
+      },
+      strict: true,
+    });
+    if (values.help) {
+      process.stdout.write(`${USAGE}\n`);
+      return;
+    }
+    logPath = values.log ?? defaultLogPath();
+  } catch (e) {
+    process.stderr.write(`adoption-report: ${e.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!existsSync(logPath)) {
+    process.stdout.write(
+      'tune-context Adoption Report\n============================\n\n' +
+        `No adoption log found at ${logPath}.\n` +
+        '(Install the adoption-log.mjs PostToolUse hook via tune-context and run a session.)\n',
+    );
+    return;
+  }
+
+  const records = parseLog(readFileSync(logPath, 'utf8'));
+  process.stdout.write(`${formatReport(aggregate(records))}\n`);
+}
+
+if (process.argv[1] && process.argv[1].endsWith('adoption-report.mjs')) {
+  main();
+}

package/hooks/adoption-log.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+// Adoption logger — registered under TWO Claude Code hook events (both matcher
+// "*"): `PostToolUse` (every tool call) and `SubagentStart` (subagent spawns).
+// Appends one JSONL line per event to a user-level log so
+// `eval/adoption-report.mjs` can answer "which token-saving lever is the model
+// actually reaching for?" — RAG vs grep, doctrine skills, subagents, re-read
+// churn. See tasks/TASK-062.
+//
+// Why two events: subagents are NOT PostToolUse tools — Claude Code fires the
+// dedicated `SubagentStart`/`SubagentStop` events for them, carrying `agent_type`
+// (not `subagent_type`). Verified against official docs (code.claude.com/docs/en/hooks.md).
+// One script handles both by branching on the payload shape.
+//
+// Honest scope: a hook sees the *event*, not the model's reasoning or its output
+// style. So it can measure RAG-vs-grep, Skill invocations, subagent spawns and
+// repeated reads — but NOT caveman (an output style, no tool call) and NOT token
+// cost (Claude Code exposes cost only via OTEL `claude_code.cost.usage`, which
+// needs a collector — never lands in a hook). The report is explicit about both
+// gaps. This is a behavioral proxy, always-on and zero-infra; the OTEL path is
+// the opt-in complement for hard cost.
+//
+// Never writes to stdout (would surface as transcript noise) and every failure
+// is swallowed — logging must never block or slow a tool call.
+import {
+  appendFileSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+const MAX_LOG_BYTES = 5 * 1024 * 1024; // rotate to <path>.1 past this (bounded ~2×)
+
+function readStdin() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function logFilePath() {
+  return join(homedir(), '.claude', 'tune-context', 'adoption.jsonl');
+}
+
+// Detect a text-search shell command (grep/rg/find/ag/ack), the grep-side of the
+// RAG-vs-grep ratio. Word-boundary matched so "pgrep"/"configure" don't trip it.
+const TEXT_SEARCH_RE = /(^|[|&;]|\s)(grep|rg|egrep|fgrep|ag|ack|find)\b/;
+
+// Map a raw (tool_name, tool_input) into a coarse lever + optional detail.
+// `detail` is deliberately bounded — never the full Bash command (size/privacy).
+// Note: subagents are NOT handled here — they arrive as SubagentStart events, not
+// PostToolUse tool calls (see buildRecord). `Skill`'s skill name is in
+// `tool_input.skill` (the tool's actual parameter; docs don't spell the field).
+export function classify(toolName, toolInput) {
+  const input = toolInput ?? {};
+  if (toolName === 'Skill') {
+    return { lever: 'skill', detail: input.skill ?? null };
+  }
+  if (typeof toolName === 'string' && toolName.includes('search_codebase')) {
+    return { lever: 'search', detail: 'rag' };
+  }
+  if (toolName === 'Grep') return { lever: 'search', detail: 'text' };
+  if (toolName === 'Glob') return { lever: 'search', detail: 'glob' };
+  if (toolName === 'Bash') {
+    const cmd = typeof input.command === 'string' ? input.command : '';
+    if (TEXT_SEARCH_RE.test(cmd)) return { lever: 'search', detail: 'text' };
+    return { lever: 'bash', detail: null };
+  }
+  if (toolName === 'Read') {
+    return { lever: 'read', detail: input.file_path ?? null };
+  }
+  if (toolName === 'Edit' || toolName === 'Write' || toolName === 'MultiEdit') {
+    return { lever: 'edit', detail: input.file_path ?? null };
+  }
+  return { lever: 'other', detail: typeof toolName === 'string' ? toolName : null };
+}
+
+export function buildRecord(input) {
+  const base = {
+    ts: new Date().toISOString(),
+    session: input.session_id ?? null,
+    cwd: input.cwd ?? null,
+  };
+  // Subagent event (SubagentStart/Stop): carries agent_type, not tool_name.
+  if (input.agent_type != null || isSubagentEvent(input.hook_event_name)) {
+    return {
+      ...base,
+      tool: input.hook_event_name ?? 'SubagentStart',
+      lever: 'subagent',
+      detail: input.agent_type ?? null,
+    };
+  }
+  const toolName = input.tool_name ?? null;
+  const { lever, detail } = classify(toolName, input.tool_input);
+  return { ...base, tool: toolName, lever, detail };
+}
+
+function isSubagentEvent(name) {
+  return typeof name === 'string' && name.startsWith('Subagent');
+}
+
+function rotateIfNeeded(path) {
+  try {
+    if (statSync(path).size >= MAX_LOG_BYTES) renameSync(path, `${path}.1`);
+  } catch {
+    // no file yet, or rotate failed — nothing to do
+  }
+}
+
+function main() {
+  try {
+    const input = readStdin();
+    // Accept a PostToolUse payload (tool_name) or a subagent event (agent_type /
+    // hook_event_name Subagent*); ignore anything else (e.g. empty stdin).
+    if (!input.tool_name && input.agent_type == null && !isSubagentEvent(input.hook_event_name)) {
+      return;
+    }
+    const path = logFilePath();
+    mkdirSync(dirname(path), { recursive: true });
+    rotateIfNeeded(path);
+    appendFileSync(path, `${JSON.stringify(buildRecord(input))}\n`);
+  } catch {
+    // non-fatal by design — never block a tool call over a log write
+  }
+}
+
+if (process.argv[1] && process.argv[1].endsWith('adoption-log.mjs')) {
+  main();
+}

package/hooks/hooks.json

@@ -0,0 +1,48 @@
+{
+  "hooks": {
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pre-compact-snapshot.mjs\""
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/session-start-reinject.mjs\""
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/adoption-log.mjs\""
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/adoption-log.mjs\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/pre-compact-snapshot.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// PreCompact hook: writes a mechanical snapshot to a user-level file before
+// Claude Code compacts context (manual /compact or auto-compact). Paired with
+// session-start-reinject.mjs, which reads this file back on the SessionStart
+// event that follows a compaction (matcher: "compact") and injects it via
+// hookSpecificOutput.additionalContext. See tasks/TASK-061.
+//
+// Honest scope: a hook is a plain script with no model access, so it can only
+// capture what the filesystem/git already know (branch, dirty files, recent
+// commits) — not decisions or open threads from the conversation. It is a
+// safety net against losing that mechanical state, not a summary.
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+function readStdin() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function git(cwd, args) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function stateFilePath(cwd) {
+  const safe = cwd.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  return join(homedir(), '.claude', 'tune-context', 'state', `${safe}.md`);
+}
+
+export function buildSnapshot(input) {
+  const cwd = input.cwd || process.cwd();
+  const branch = git(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  const status = git(cwd, ['status', '--short']);
+  const log = git(cwd, ['log', '-5', '--oneline']);
+  const lines = [
+    '# tune-context: pre-compact snapshot',
+    '',
+    `mechanical only — no decisions/open threads (hook has no model access)`,
+    '',
+    `- when: ${new Date().toISOString()}`,
+    `- trigger: ${input.trigger ?? 'unknown'}`,
+    `- session: ${input.session_id ?? 'unknown'}`,
+    `- cwd: ${cwd}`,
+    branch !== null ? `- branch: ${branch}` : null,
+    '',
+    status ? '## git status --short\n```\n' + status + '\n```' : null,
+    log ? '## git log -5 --oneline\n```\n' + log + '\n```' : null,
+  ].filter((l) => l !== null);
+  return lines.join('\n') + '\n';
+}
+
+function main() {
+  const input = readStdin();
+  const path = stateFilePath(input.cwd || process.cwd());
+  mkdirSync(join(path, '..'), { recursive: true });
+  writeFileSync(path, buildSnapshot(input));
+}
+
+if (process.argv[1] && process.argv[1].endsWith('pre-compact-snapshot.mjs')) {
+  main();
+}

package/hooks/session-start-reinject.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+// SessionStart hook (matcher: "compact"): reads the snapshot pre-compact-snapshot.mjs
+// wrote just before this compaction and re-injects it via
+// hookSpecificOutput.additionalContext, per the round-trip confirmed in TASK-056.
+// No-ops (no stdout) when source isn't "compact" or no snapshot exists — never
+// injects stale/wrong-project content.
+import { existsSync, readFileSync } from 'node:fs';
+import { stateFilePath } from './pre-compact-snapshot.mjs';
+
+function readStdin() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function main() {
+  const input = readStdin();
+  if (input.source !== 'compact') return;
+  const cwd = input.cwd || process.cwd();
+  const path = stateFilePath(cwd);
+  if (!existsSync(path)) return;
+  const additionalContext = readFileSync(path, 'utf8');
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext,
+      },
+    }),
+  );
+}
+
+if (
+  process.argv[1] &&
+  process.argv[1].endsWith('session-start-reinject.mjs')
+) {
+  main();
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@bglocation/tune-context",
+  "version": "1.0.0",
+  "description": "Context-efficiency configurator for Claude Code — token-saving doctrine packaged as skills, plus a tune-context configurator that scaffolds a lean CLAUDE.md, doctrine skills, subagents, settings, hooks and MCP wiring.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Szymon Walczak",
+  "homepage": "https://bglocation.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/bglocation/tune-context.git"
+  },
+  "keywords": [
+    "claude-code",
+    "claude",
+    "skills",
+    "plugin",
+    "context-engineering",
+    "token-efficiency",
+    "configurator",
+    "mcp"
+  ],
+  "bin": {
+    "tune-context": "./bin/tune-context.mjs"
+  },
+  "files": [
+    ".claude-plugin",
+    "bin",
+    "cli",
+    "skills",
+    "agents",
+    "hooks",
+    "eval",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "verify:pack": "node scripts/verify-pack.mjs",
+    "smoke:init": "node scripts/smoke-init.mjs",
+    "prepublishOnly": "npm run verify:pack && npm run smoke:init"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}