skillmaxxing 0.1.0

package/dist/commands/doctor.js

@@ -0,0 +1,84 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { ALL_AGENTS } from '../agents/registry.js';
+import { readGlobalLock } from '../lock/global.js';
+import { isSymlink, fileExists } from '../util/fs.js';
+import * as log from '../util/log.js';
+const execFileAsync = promisify(execFile);
+export async function doctor() {
+    log.heading('skill-maxing doctor');
+    let issues = 0;
+    log.heading('Agent Detection');
+    for (const agent of ALL_AGENTS) {
+        const installed = await agent.detectInstalled();
+        const cliFound = await checkCli(agent.cliCommand);
+        if (installed) {
+            log.success(`${agent.displayName}: config directory found`);
+        }
+        else {
+            log.dim(`${agent.displayName}: not installed`);
+        }
+        if (cliFound) {
+            log.success(`${agent.displayName}: '${agent.cliCommand}' on PATH`);
+        }
+        else if (installed) {
+            log.warn(`${agent.displayName}: config exists but '${agent.cliCommand}' not on PATH`);
+        }
+    }
+    log.heading('Global Skills Health');
+    const lock = readGlobalLock();
+    const entries = Object.entries(lock.skills);
+    if (entries.length === 0) {
+        log.info('No global skills installed.');
+    }
+    for (const [name, entry] of entries) {
+        for (const agentName of entry.agents) {
+            const agent = ALL_AGENTS.find(a => a.name === agentName);
+            if (!agent) {
+                log.warn(`${name}: references unknown agent '${agentName}'`);
+                issues++;
+                continue;
+            }
+            const skillDir = path.join(agent.globalSkillsDir, name);
+            if (!fileExists(skillDir)) {
+                log.error(`${name}: missing at ${skillDir} (agent: ${agent.displayName})`);
+                issues++;
+                continue;
+            }
+            if (isSymlink(skillDir)) {
+                const target = fs.readlinkSync(skillDir);
+                const resolved = path.resolve(path.dirname(skillDir), target);
+                if (!fileExists(resolved)) {
+                    log.error(`${name}: broken symlink → ${resolved} (agent: ${agent.displayName})`);
+                    issues++;
+                    continue;
+                }
+            }
+            const skillMd = path.join(skillDir, 'SKILL.md');
+            if (!fileExists(skillMd)) {
+                log.warn(`${name}: directory exists but no SKILL.md (agent: ${agent.displayName})`);
+                issues++;
+                continue;
+            }
+            log.success(`${name}: OK (${agent.displayName})`);
+        }
+    }
+    log.heading('Summary');
+    if (issues === 0) {
+        log.success('No issues found.');
+    }
+    else {
+        log.warn(`${issues} issue(s) found. Run 'skill-maxing update' to fix stale installs.`);
+    }
+}
+async function checkCli(command) {
+    try {
+        await execFileAsync('which', [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,47 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { detectInstalledAgents } from '../agents/registry.js';
+import { ensureDir } from '../util/fs.js';
+import * as log from '../util/log.js';
+const TEMPLATE = `---
+name: my-skill
+description: A brief description of what this skill does
+version: 1.0.0
+tools:
+  - Bash
+  - Read
+triggers:
+  - activate this skill
+---
+
+# my-skill
+
+Instructions for the agent go here.
+
+## When to use
+
+Describe when this skill should be activated.
+
+## Steps
+
+1. First step
+2. Second step
+3. Third step
+`;
+export async function init(args) {
+    const dir = args.dir ?? process.cwd();
+    const name = args.name ?? 'my-skill';
+    const agents = await detectInstalledAgents();
+    log.heading('skill-maxing init');
+    log.info(`Detected agents: ${agents.length > 0 ? agents.map(a => a.displayName).join(', ') : 'none'}`);
+    const skillDir = path.join(dir, name);
+    if (fs.existsSync(skillDir)) {
+        log.warn(`Directory already exists: ${skillDir}`);
+        return;
+    }
+    ensureDir(skillDir);
+    const skillMd = TEMPLATE.replace(/my-skill/g, name);
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), skillMd);
+    log.success(`Created ${skillDir}/SKILL.md`);
+    log.info(`Edit the SKILL.md, then run: skill-maxing install ./${name}`);
+}

package/dist/commands/install.js

@@ -0,0 +1,74 @@
+import * as path from 'node:path';
+import { parseSource, sourceLabel } from '../source/parser.js';
+import { resolveSource, cleanupResolved } from '../source/resolver.js';
+import { detectInstalledAgents, getAgentOrThrow } from '../agents/registry.js';
+import { symlinkOrCopy, fileExists } from '../util/fs.js';
+import { addGlobalLockEntry, getGlobalLockEntry } from '../lock/global.js';
+import { addProjectLockEntry, computeSkillHash, readProjectLock } from '../lock/project.js';
+import { ensureValidName } from '../util/collision.js';
+import * as log from '../util/log.js';
+export async function install(args) {
+    const parsed = parseSource(args.source);
+    log.info(`Resolving ${sourceLabel(parsed)}...`);
+    const skills = await resolveSource(parsed);
+    log.info(`Found ${skills.length} skill(s): ${skills.map(s => s.name).join(', ')}`);
+    let agents;
+    if (args.agents && args.agents.length > 0) {
+        agents = args.agents.map(a => getAgentOrThrow(a));
+    }
+    else {
+        agents = await detectInstalledAgents();
+        if (agents.length === 0) {
+            log.warn('No supported agents detected. Use --agent to specify one.');
+            return;
+        }
+        log.info(`Detected agents: ${agents.map(a => a.displayName).join(', ')}`);
+    }
+    const projectDir = process.cwd();
+    for (const skill of skills) {
+        const nameCheck = ensureValidName(skill.name);
+        if (!nameCheck.ok) {
+            log.warn(`Skipping skill: ${nameCheck.reason}`);
+            continue;
+        }
+        // A skill already recorded in our lock is managed by skill-maxing and may be
+        // refreshed (this is the `update` path). An on-disk skill we do NOT track is
+        // unmanaged — refuse to clobber it (it may be a locally-optimized skill)
+        // unless --force (review C2).
+        const tracked = args.scope === 'global'
+            ? !!getGlobalLockEntry(skill.name)
+            : !!readProjectLock(projectDir).skills[skill.name];
+        log.heading(`Installing ${skill.name}`);
+        for (const agent of agents) {
+            const destDir = args.scope === 'global'
+                ? path.join(agent.globalSkillsDir, skill.name)
+                : path.join(projectDir, agent.projectSkillsDir, skill.name);
+            if (fileExists(destDir) && !tracked && !args.force) {
+                log.warn(`${skill.name} already exists at ${destDir} and is not managed by skill-maxing. ` +
+                    `Use --force to overwrite. Skipping.`);
+                continue;
+            }
+            const mode = symlinkOrCopy(skill.dir, destDir, args.copy);
+            log.success(`${agent.displayName} (${args.scope}): ${mode === 'symlink' ? 'linked' : 'copied'} → ${destDir}`);
+        }
+        if (args.scope === 'global') {
+            addGlobalLockEntry(skill.name, {
+                source: parsed.raw,
+                sourceType: parsed.type,
+                ref: parsed.ref,
+                commitSha: skill.commitSha,
+                agents: agents.map(a => a.name),
+            });
+        }
+        else {
+            addProjectLockEntry(projectDir, skill.name, {
+                source: parsed.raw,
+                sourceType: parsed.type,
+                ref: parsed.ref,
+                computedHash: computeSkillHash(skill.dir),
+            });
+        }
+    }
+    cleanupResolved(skills);
+    log.success(`Installed ${skills.length} skill(s) into ${agents.length} agent(s)`);
+}

package/dist/commands/list.js

@@ -0,0 +1,74 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ALL_AGENTS } from '../agents/registry.js';
+import { readSkillMeta } from '../util/frontmatter.js';
+import { isSymlink } from '../util/fs.js';
+import * as log from '../util/log.js';
+export async function list(args) {
+    const projectDir = process.cwd();
+    const skills = [];
+    const agents = args.agent
+        ? ALL_AGENTS.filter(a => a.name === args.agent)
+        : ALL_AGENTS;
+    for (const agent of agents) {
+        if (!args.scope || args.scope === 'global') {
+            skills.push(...scanDir(agent, agent.globalSkillsDir, 'global'));
+        }
+        if (!args.scope || args.scope === 'project') {
+            const projDir = path.join(projectDir, agent.projectSkillsDir);
+            skills.push(...scanDir(agent, projDir, 'project'));
+        }
+    }
+    if (args.json) {
+        console.log(JSON.stringify(skills, null, 2));
+        return;
+    }
+    if (skills.length === 0) {
+        log.info('No skills installed.');
+        return;
+    }
+    log.heading(`Installed skills (${skills.length})`);
+    const rows = [['Name', 'Agent', 'Scope', 'Link', 'Description']];
+    for (const s of skills) {
+        rows.push([
+            s.name,
+            s.agent,
+            s.scope,
+            s.isSymlink ? 'sym' : 'copy',
+            truncate(s.meta.description, 50),
+        ]);
+    }
+    log.table(rows);
+}
+function scanDir(agent, dir, scope) {
+    const results = [];
+    try {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const skillDir = path.join(dir, entry.name);
+            const skillMd = path.join(skillDir, 'SKILL.md');
+            if (!fs.existsSync(skillMd))
+                continue;
+            const content = fs.readFileSync(skillMd, 'utf-8');
+            const meta = readSkillMeta(content);
+            if (!meta)
+                continue;
+            results.push({
+                name: meta.name,
+                meta,
+                path: skillDir,
+                agent: agent.name,
+                scope,
+                isSymlink: isSymlink(skillDir),
+            });
+        }
+    }
+    catch {
+        // directory doesn't exist
+    }
+    return results;
+}
+function truncate(s, max) {
+    return s.length <= max ? s : s.substring(0, max - 3) + '...';
+}

package/dist/commands/optimize.js

@@ -0,0 +1,152 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { ensureDir, removeDir, copyDir, fileExists } from '../util/fs.js';
+import { applyEdits } from '../optimize/diff.js';
+import { editBudget } from '../optimize/budget.js';
+import { selectEdits, gate, noHeldOutRegression } from '../optimize/loop.js';
+import { loadEvalManifest } from '../eval/schema.js';
+import { scoreRollouts } from '../eval/runner.js';
+import { promote, revert } from '../util/versions.js';
+import { loadState, ensureState, saveState, setLifecycle } from '../state/store.js';
+import * as log from '../util/log.js';
+const CANDIDATES_DIR = path.join(os.homedir(), '.skillmax', 'candidates');
+function readJson(p) {
+    return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+function bumpPatch(version) {
+    const m = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!m)
+        return `${version}+1`;
+    return `${m[1]}.${m[2]}.${Number(m[3]) + 1}`;
+}
+export async function optimize(args) {
+    switch (args.action) {
+        case 'score':
+            return scoreAction(args);
+        case 'apply':
+            return applyAction(args);
+        case 'gate':
+            return gateAction(args);
+        case 'promote':
+            return promoteAction(args);
+        case 'revert':
+            return revertAction(args);
+        default:
+            log.error(`Unknown optimize action: ${args.action}`);
+            process.exitCode = 1;
+    }
+}
+// Score rollout outputs against an eval manifest (deterministic; defers agent-judge).
+async function scoreAction(args) {
+    if (!args.evalPath || !args.rolloutsPath) {
+        log.error('Usage: optimize score --eval <manifest> --rollouts <rollouts.json>');
+        process.exitCode = 1;
+        return;
+    }
+    const manifest = loadEvalManifest(args.evalPath); // throws on empty/invalid (AE3)
+    const rollouts = readJson(args.rolloutsPath);
+    const result = await scoreRollouts(manifest, rollouts, {
+        skillId: args.skillName,
+        allowExec: args.allowExec,
+    });
+    if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    log.heading(`Score: ${result.aggregate ?? 'n/a'}`);
+    for (const t of result.perTask) {
+        log.info(`  ${t.taskId}: ${t.pending ? 'PENDING (agent-judge)' : t.score}${t.detail ? ` (${t.detail})` : ''}`);
+    }
+    if (result.pendingJudgments.length > 0) {
+        log.warn(`${result.pendingJudgments.length} task(s) need agent-judge scoring before the gate can run.`);
+    }
+}
+// Apply bounded edits to a managed COPY (never the symlinked source — KTD5).
+function applyAction(args) {
+    if (!args.skillDir || !args.editsPath) {
+        log.error('Usage: optimize apply --skill-dir <dir> --edits <edits.json> [--step N --total M]');
+        process.exitCode = 1;
+        return;
+    }
+    const name = args.skillName ?? path.basename(args.skillDir);
+    const skillMd = path.join(args.skillDir, 'SKILL.md');
+    if (!fileExists(skillMd)) {
+        log.error(`no SKILL.md in ${args.skillDir}`);
+        process.exitCode = 1;
+        return;
+    }
+    const candidateDir = path.join(CANDIDATES_DIR, name);
+    removeDir(candidateDir);
+    ensureDir(path.dirname(candidateDir));
+    copyDir(args.skillDir, candidateDir); // managed working copy
+    const edits = readJson(args.editsPath);
+    const budget = editBudget(args.step ?? 0, args.total ?? 1, {
+        base: args.base,
+        min: args.min,
+        scheduler: args.scheduler,
+    });
+    const selected = selectEdits(edits, budget);
+    const content = fs.readFileSync(path.join(candidateDir, 'SKILL.md'), 'utf-8');
+    const result = applyEdits(content, selected);
+    fs.writeFileSync(path.join(candidateDir, 'SKILL.md'), result.content);
+    if (args.json) {
+        console.log(JSON.stringify({ candidateDir, budget, applied: result.applied.length, rejected: result.rejected }, null, 2));
+        return;
+    }
+    log.success(`Candidate at ${candidateDir} (budget ${budget}, applied ${result.applied.length})`);
+    for (const r of result.rejected)
+        log.warn(`  rejected ${r.edit.op}: ${r.reason}`);
+}
+// Deterministic gate decision (exit 1 on reject so the loop can branch).
+function gateAction(args) {
+    if (args.current === undefined || args.candidate === undefined) {
+        log.error('Usage: optimize gate --current <score> --candidate <score> [--best <score>]');
+        process.exitCode = 1;
+        return;
+    }
+    const res = gate(args.current, args.candidate, args.best ?? args.current);
+    log.info(`gate: ${res.action}`);
+    if (res.action === 'reject')
+        process.exitCode = 1;
+}
+// Human-approved promotion: atomic swap, prior version retained, score recorded.
+function promoteAction(args) {
+    if (!args.skillName || !args.liveDir || !args.candidateDir) {
+        log.error('Usage: optimize promote --skill <name> --live <dir> --candidate <dir> [--score S]');
+        process.exitCode = 1;
+        return;
+    }
+    const now = new Date().toISOString();
+    const state = loadState(args.skillName) ?? ensureState({ name: args.skillName, origin: 'optimized' }, now);
+    const priorVersion = state.version;
+    const newVersion = bumpPatch(priorVersion);
+    promote({
+        id: args.skillName,
+        liveDir: args.liveDir,
+        candidateDir: args.candidateDir,
+        priorVersion,
+    });
+    state.version = newVersion;
+    state.lifecycle = 'live';
+    state.origin = 'optimized';
+    state.updatedAt = now;
+    if (args.score !== undefined) {
+        state.scoreHistory.push({ version: newVersion, score: args.score, at: now });
+    }
+    saveState(state);
+    log.success(`Promoted ${args.skillName} ${priorVersion} → ${newVersion} (prior retained, reversible).`);
+}
+// Revert to a retained version (atomic).
+function revertAction(args) {
+    if (!args.skillName || !args.version || !args.liveDir) {
+        log.error('Usage: optimize revert --skill <name> --version <v> --live <dir>');
+        process.exitCode = 1;
+        return;
+    }
+    revert(args.skillName, args.version, args.liveDir);
+    const now = new Date().toISOString();
+    setLifecycle(args.skillName, 'reverted', now);
+    log.success(`Reverted ${args.skillName} to ${args.version}.`);
+}
+export { noHeldOutRegression };

package/dist/commands/plugin.js

@@ -0,0 +1,232 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
+import { ensureDir } from '../util/fs.js';
+import { SKILLS_GUIDANCE, REFLECT_NUDGE } from '../plugin/guidance.js';
+import { recordToolUse, shouldReflect, markReflected } from '../plugin/sessions.js';
+import { runReflectionDetached, isReflecting } from '../plugin/reflect.js';
+import * as log from '../util/log.js';
+const DEFAULT_THRESHOLD = 10;
+/** Identify hooks we own (any of our bin names), keyed on our unique subcommands. */
+function isOurHook(command) {
+    return typeof command === 'string' && /\bplugin (guidance|on-tool|on-stop)\b/.test(command);
+}
+// ---------- shared helpers ----------
+function resolveCli() {
+    for (const bin of ['skillmaxxing', 'skill-maxing', 'skillmax']) {
+        try {
+            execSync(`command -v ${bin}`, { stdio: 'ignore' });
+            return bin;
+        }
+        catch {
+            /* not on PATH */
+        }
+    }
+    return 'npx -y skillmaxxing';
+}
+function readStdin() {
+    try {
+        const raw = fs.readFileSync(0, 'utf-8');
+        return raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function claudeSettingsPath(project) {
+    return project
+        ? path.join(process.cwd(), '.claude', 'settings.json')
+        : path.join(os.homedir(), '.claude', 'settings.json');
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeJson(file, data) {
+    ensureDir(path.dirname(file));
+    const tmp = file + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+    fs.renameSync(tmp, file);
+}
+/** Drop any hook groups in `list` that belong to skill-maxing. */
+function stripOurs(list) {
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((g) => !(g.hooks ?? []).some((h) => isOurHook(h.command)));
+}
+// ---------- install / uninstall / status ----------
+function install(args) {
+    const agent = args.agent ?? 'claude';
+    const mode = args.mode ?? 'auto';
+    const threshold = args.threshold ?? DEFAULT_THRESHOLD;
+    const cli = resolveCli();
+    if (agent === 'codex') {
+        installCodex();
+        return;
+    }
+    const file = claudeSettingsPath(args.project ?? false);
+    const settings = readJson(file);
+    settings.hooks = settings.hooks ?? {};
+    // SessionStart: standing guidance (Layer A) — always wired.
+    settings.hooks.SessionStart = [
+        ...stripOurs(settings.hooks.SessionStart),
+        { hooks: [{ type: 'command', command: `${cli} plugin guidance` }] },
+    ];
+    // PostToolUse + Stop: the background reflection loop (Layer B) — auto mode only.
+    if (mode === 'auto') {
+        settings.hooks.PostToolUse = [
+            ...stripOurs(settings.hooks.PostToolUse),
+            { matcher: '*', hooks: [{ type: 'command', command: `${cli} plugin on-tool` }] },
+        ];
+        settings.hooks.Stop = [
+            ...stripOurs(settings.hooks.Stop),
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: `${cli} plugin on-stop --agent ${agent} --mode ${mode} --threshold ${threshold}`,
+                    },
+                ],
+            },
+        ];
+    }
+    else {
+        // nudge mode: remove any auto hooks we previously installed
+        settings.hooks.PostToolUse = stripOurs(settings.hooks.PostToolUse);
+        settings.hooks.Stop = stripOurs(settings.hooks.Stop);
+    }
+    writeJson(file, settings);
+    log.success(`Skill Maxing installed for Claude Code (${mode} mode).`);
+    log.info(`  hooks written to ${file}`);
+    log.info(`  SessionStart: standing skill-creation guidance`);
+    if (mode === 'auto') {
+        log.info(`  Stop: background reflection after ${threshold}+ tool calls (claude -p, trusted:false drafts)`);
+    }
+    log.info('No explicit trigger needed — restart your agent session to activate.');
+    log.info('Uninstall any time with: skill-maxing plugin uninstall');
+}
+const CODEX_MARK_START = '<!-- skill-maxing:start -->';
+const CODEX_MARK_END = '<!-- skill-maxing:end -->';
+function installCodex() {
+    // Codex lacks programmatic Stop/PostToolUse hooks, so we deliver the standing
+    // guidance via AGENTS.md (Layer A). The agent then self-evolves per instruction.
+    const file = path.join(process.cwd(), 'AGENTS.md');
+    let body = '';
+    try {
+        body = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        /* new file */
+    }
+    const block = `${CODEX_MARK_START}\n## Skill Maxing\n\n${SKILLS_GUIDANCE}\n${CODEX_MARK_END}`;
+    const re = new RegExp(`${CODEX_MARK_START}[\\s\\S]*?${CODEX_MARK_END}`);
+    body = re.test(body) ? body.replace(re, block) : `${body.trimEnd()}\n\n${block}\n`;
+    fs.writeFileSync(file, body.replace(/^\n+/, ''));
+    log.success('Skill Maxing installed for Codex (guidance written to AGENTS.md).');
+    log.info('Codex has no Stop hook; self-evolution runs in-session via standing guidance.');
+}
+function uninstall(args) {
+    const agent = args.agent ?? 'claude';
+    if (agent === 'codex') {
+        const file = path.join(process.cwd(), 'AGENTS.md');
+        try {
+            const body = fs.readFileSync(file, 'utf-8');
+            const re = new RegExp(`\\n*${CODEX_MARK_START}[\\s\\S]*?${CODEX_MARK_END}\\n*`);
+            fs.writeFileSync(file, body.replace(re, '\n'));
+            log.success('Removed Skill Maxing guidance from AGENTS.md.');
+        }
+        catch {
+            log.info('Nothing to uninstall.');
+        }
+        return;
+    }
+    const file = claudeSettingsPath(args.project ?? false);
+    const settings = readJson(file);
+    if (settings.hooks) {
+        settings.hooks.SessionStart = stripOurs(settings.hooks.SessionStart);
+        settings.hooks.PostToolUse = stripOurs(settings.hooks.PostToolUse);
+        settings.hooks.Stop = stripOurs(settings.hooks.Stop);
+        for (const k of ['SessionStart', 'PostToolUse', 'Stop']) {
+            if (Array.isArray(settings.hooks[k]) && settings.hooks[k].length === 0)
+                delete settings.hooks[k];
+        }
+    }
+    writeJson(file, settings);
+    log.success(`Removed Skill Maxing hooks from ${file}.`);
+}
+function status(args) {
+    const file = claudeSettingsPath(args.project ?? false);
+    const settings = readJson(file);
+    const owned = [];
+    for (const k of ['SessionStart', 'PostToolUse', 'Stop']) {
+        const groups = settings.hooks?.[k] ?? [];
+        if (groups.some((g) => (g.hooks ?? []).some((h) => isOurHook(h.command))))
+            owned.push(k);
+    }
+    if (owned.length > 0) {
+        log.success(`Skill Maxing is active for Claude Code: ${owned.join(', ')} hooks (${file}).`);
+    }
+    else {
+        log.info('Skill Maxing is not installed for Claude Code. Run: skill-maxing plugin install');
+    }
+}
+// ---------- hook entrypoints ----------
+function guidance() {
+    // SessionStart additionalContext — injects the standing nudge into the agent.
+    console.log(JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: SKILLS_GUIDANCE },
+    }));
+}
+function onTool() {
+    if (isReflecting())
+        return; // don't count the reflector's own work
+    const input = readStdin();
+    const id = typeof input.session_id === 'string' ? input.session_id : 'default';
+    recordToolUse(id);
+}
+function onStop(args) {
+    if (isReflecting())
+        return; // recursion guard: the reflector must never re-trigger
+    const input = readStdin();
+    const id = typeof input.session_id === 'string' ? input.session_id : 'default';
+    const transcriptPath = typeof input.transcript_path === 'string' ? input.transcript_path : '';
+    const mode = args.mode ?? 'auto';
+    const threshold = args.threshold ?? DEFAULT_THRESHOLD;
+    if (!shouldReflect(id, threshold))
+        return; // not enough substantive work yet
+    if (mode === 'nudge') {
+        // Surface a one-line reminder to the user; the agent acts on standing guidance.
+        console.log(JSON.stringify({ systemMessage: `Skill Maxing: ${REFLECT_NUDGE}` }));
+        markReflected(id, new Date().toISOString());
+        return;
+    }
+    // auto mode: fire the background reflector and reset the counter.
+    markReflected(id, new Date().toISOString());
+    if (transcriptPath) {
+        runReflectionDetached({ agent: args.agent ?? 'claude', transcriptPath, cwd: process.cwd() });
+    }
+}
+export async function plugin(args) {
+    switch (args.action) {
+        case 'install':
+            return install(args);
+        case 'uninstall':
+            return uninstall(args);
+        case 'status':
+            return status(args);
+        case 'guidance':
+            return guidance();
+        case 'on-tool':
+            return onTool();
+        case 'on-stop':
+            return onStop(args);
+        default:
+            log.error(`Unknown plugin action: ${args.action}`);
+            process.exitCode = 1;
+    }
+}