agentic-workflow-manager 3.1.0 → 3.2.1

package/dist/src/commands/add.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAddBundleCore = runAddBundleCore;
+// src/commands/add.ts
+//
+// `awm add <bundle>` — the non-interactive, headless bundle-activation path
+// of `awm add` (works without a TTY, unlike the interactive artifact
+// picker). Resolves agent targets the same way as `remove`/`sync`/`update`/
+// `doctor` (R12/R13): every enabled agent when `--agent` is absent, or an
+// explicit comma-separated subset validated against `enabledAgents`.
+const picocolors_1 = __importDefault(require("picocolors"));
+const agent_targets_1 = require("../core/agent-targets");
+const bundles_1 = require("../core/bundles");
+const bundle_install_1 = require("../core/bundle-install");
+const profile_1 = require("../core/profile");
+/**
+ * Installs `options.name`'s bundle closure for the resolved agent targets.
+ * Pure-ish: the only side effect is the injected `addBundle` (defaults to
+ * the real one). Returns a result object rather than calling `process.exit`
+ * so it's directly testable and composable with `index.ts`'s Commander
+ * action (which does the console output / exit-code translation).
+ */
+function runAddBundleCore(options, prefs, bundles, deps = {}) {
+    const d = { addBundle: bundle_install_1.addBundle, ...deps };
+    const matchedBundle = bundles.find((b) => b.name === options.name);
+    if (!matchedBundle) {
+        console.error(picocolors_1.default.red(`Bundle "${options.name}" not found in registry.`));
+        console.error(picocolors_1.default.dim('Run `awm list` to see available packages.'));
+        return { code: 1, selectedAgents: [] };
+    }
+    const resolved = (0, agent_targets_1.resolveAgentTargetsOrError)({ prefs, explicit: options.agent });
+    if (!resolved.ok) {
+        console.error(picocolors_1.default.red(resolved.error));
+        return { code: 1, selectedAgents: [] };
+    }
+    const selectedAgents = resolved.targets;
+    let scopeOverride;
+    if (options.scope) {
+        if (!['local', 'global'].includes(options.scope)) {
+            console.error(picocolors_1.default.red(`Invalid scope "${options.scope}". Use: local or global.`));
+            return { code: 1, selectedAgents };
+        }
+        scopeOverride = options.scope;
+    }
+    const effective = scopeOverride ?? (0, bundles_1.defaultScopeForBundle)(matchedBundle.scope);
+    const cwd = options.cwd ?? process.cwd();
+    const projectRoot = (0, profile_1.findProjectRoot)(cwd);
+    if (effective === 'local' && !projectRoot) {
+        console.error(picocolors_1.default.red('No project root found (need a .git/, package.json, or .awm/profile.json here). Run inside a project, or pass --global.'));
+        return { code: 1, selectedAgents };
+    }
+    let result;
+    try {
+        result = d.addBundle({
+            bundleName: matchedBundle.name,
+            bundles,
+            agents: selectedAgents,
+            method: 'symlink',
+            projectRoot: projectRoot ?? cwd,
+            scopeOverride,
+        });
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red(e.message));
+        return { code: 1, selectedAgents };
+    }
+    if (result.skipped.length > 0) {
+        for (const s of result.skipped)
+            console.log(picocolors_1.default.yellow(`  ⚠  Skipped: ${s}`));
+    }
+    if (result.installed.length === 0) {
+        console.log(picocolors_1.default.yellow(`Nothing installed for bundle "${matchedBundle.name}".`));
+        return { code: 0, selectedAgents, result };
+    }
+    const lines = result.installed.map((n) => picocolors_1.default.green(n)).join('\n  ');
+    const recordNote = result.recordedExtension
+        ? `\n\n${picocolors_1.default.dim('Recorded as a project extension in .awm/profile.json (commit it; symlinks are gitignored).')}`
+        : '';
+    console.log(`✅ Installed bundle ${picocolors_1.default.cyan(matchedBundle.name)}:\n  ${lines}${recordNote}`);
+    return { code: 0, selectedAgents, result };
+}

package/dist/src/commands/agent.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAgents = listAgents;
+exports.disableAgent = disableAgent;
+exports.registerAgentCommand = registerAgentCommand;
+const picocolors_1 = __importDefault(require("picocolors"));
+const providers_1 = require("../providers");
+const config_1 = require("../utils/config");
+/** Every known agent target, tagged with this machine's enabled/default state. */
+function listAgents() {
+    const prefs = (0, config_1.getPreferences)();
+    return providers_1.AGENT_TARGETS.map((id) => ({
+        id,
+        label: (0, providers_1.providerFor)(id).label,
+        enabled: prefs.enabledAgents.includes(id),
+        default: prefs.defaultAgent === id,
+    }));
+}
+/**
+ * Disables `agent` in AWM's own bookkeeping only (preferences.json's
+ * enabledAgents). Never touches the agent's provider files.
+ *
+ * Refuses to disable the current default without a `replacement` (must
+ * itself remain enabled after the change) — AWM always needs a default agent
+ * to fall back to for commands that don't specify `--agent`.
+ */
+function disableAgent(agent, replacement) {
+    if (!(0, providers_1.isAgentTarget)(agent)) {
+        throw new Error(`Invalid agent target: ${String(agent)}`);
+    }
+    const prefs = (0, config_1.getPreferences)();
+    if (!prefs.enabledAgents.includes(agent)) {
+        throw new Error(`${agent} is not enabled`);
+    }
+    if (prefs.defaultAgent === agent && replacement === undefined) {
+        throw new Error('Cannot disable the default agent; pass --default <agent>');
+    }
+    if (replacement !== undefined && !(0, providers_1.isAgentTarget)(replacement)) {
+        throw new Error(`Invalid replacement agent target: ${String(replacement)}`);
+    }
+    const enabledAgents = prefs.enabledAgents.filter((candidate) => candidate !== agent);
+    const defaultAgent = replacement ?? prefs.defaultAgent;
+    if (!enabledAgents.includes(defaultAgent)) {
+        throw new Error(`Replacement default ${defaultAgent} must remain enabled`);
+    }
+    (0, config_1.savePreferences)({ ...prefs, enabledAgents, defaultAgent });
+}
+function registerAgentCommand(program) {
+    const agent = program.command('agent').description('Manage which agent targets AWM tracks');
+    agent.command('list')
+        .description('List every agent target and this machine\'s enabled/default state')
+        .option('--json', 'Emit the agent list as JSON')
+        .action((options) => {
+        const rows = listAgents();
+        if (options.json) {
+            process.stdout.write(JSON.stringify(rows, null, 2) + '\n');
+            return;
+        }
+        for (const row of rows) {
+            const marker = row.default ? picocolors_1.default.cyan(' (default)') : '';
+            const state = row.enabled ? picocolors_1.default.green('enabled') : picocolors_1.default.dim('disabled');
+            process.stdout.write(`  ${row.id.padEnd(12)} ${state}${marker}\n`);
+        }
+    });
+    agent.command('disable <agent>')
+        .description('Stop AWM from managing <agent> (preferences only — provider files are untouched)')
+        .option('--default <agent>', 'Replacement default agent, required when disabling the current default')
+        .action((agentArg, options) => {
+        if (!(0, providers_1.isAgentTarget)(agentArg)) {
+            console.error(picocolors_1.default.red(`Invalid agent "${agentArg}". Use: ${providers_1.AGENT_TARGETS.join(', ')}.`));
+            process.exitCode = 1;
+            return;
+        }
+        let replacement;
+        if (options.default !== undefined) {
+            if (!(0, providers_1.isAgentTarget)(options.default)) {
+                console.error(picocolors_1.default.red(`Invalid --default "${options.default}". Use: ${providers_1.AGENT_TARGETS.join(', ')}.`));
+                process.exitCode = 1;
+                return;
+            }
+            replacement = options.default;
+        }
+        try {
+            disableAgent(agentArg, replacement);
+            console.log(picocolors_1.default.green(`✓ ${agentArg} disabled.`));
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`✗ ${e.message}`));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/commands/backup.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBackupCommand = registerBackupCommand;
+const picocolors_1 = __importDefault(require("picocolors"));
+const install_transaction_1 = require("../core/install-transaction");
+function registerBackupCommand(program) {
+    const backup = program.command('backup')
+        .description('inspect and restore AWM filesystem backups (~/.awm/backups)');
+    backup
+        .command('list')
+        .description('list recorded backup transactions')
+        .option('--json', 'emit the list as JSON')
+        .action((options) => {
+        const backups = (0, install_transaction_1.listBackups)();
+        if (options.json) {
+            process.stdout.write(JSON.stringify(backups, null, 2) + '\n');
+            return;
+        }
+        if (backups.length === 0) {
+            console.log(picocolors_1.default.dim('(no backups recorded)'));
+            return;
+        }
+        for (const b of backups) {
+            const status = b.committed ? picocolors_1.default.dim('committed') : picocolors_1.default.yellow('uncommitted');
+            console.log(`${b.id}  ${status}  ${b.targets.length} target(s)`);
+        }
+    });
+    backup
+        .command('restore <transactionId>')
+        .description('restore every filesystem target recorded in a backup transaction')
+        .action((transactionId) => {
+        try {
+            const result = (0, install_transaction_1.restoreBackup)(transactionId);
+            console.log(picocolors_1.default.green(`Restored ${result.restored.length} target(s) from ${transactionId}`));
+            for (const target of result.restored)
+                console.log(`  ${target}`);
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(e instanceof Error ? e.message : String(e)));
+            process.exit(1);
+        }
+    });
+}

package/dist/src/commands/doctor.js

@@ -4,12 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderReport = renderReport;
+exports.renderProviderReport = renderProviderReport;
 exports.runDoctor = runDoctor;
 exports.registerDoctorCommand = registerDoctorCommand;
 const picocolors_1 = __importDefault(require("picocolors"));
 const context_1 = require("../core/diagnostics/context");
 const checks_1 = require("../core/diagnostics/checks");
 const paths_1 = require("../core/paths");
+const config_1 = require("../utils/config");
+const agent_targets_1 = require("../core/agent-targets");
 function glyph(status) {
     if (status === 'ok')
         return picocolors_1.default.green('✔');
@@ -52,10 +55,82 @@ function renderReport(report) {
     lines.push(`status: ${status} · ${actions} suggested actions`);
     return lines.join('\n');
 }
+// --- Task 9: per-provider report rendering ---------------------------------
+//
+// Separate from renderReport/CheckReport above (which `init.ts` still uses,
+// unchanged, for its before/after machine+project display). `doctor`'s own
+// text/JSON output is provider-centric.
+const CHECK_LABELS = {
+    'binary.version': 'binary/version',
+    'skills.global': 'global skills',
+    'agents.native': 'native agents',
+    'context.global': 'global context',
+    'hook.trust': 'hook SessionStart',
+    'guidance.project': 'project guidance',
+    'constitution.delivery': 'constitution delivery',
+};
+const OK_STATES = ['supported', 'healthy', 'shared', 'delivered'];
+const PENDING_STATES = ['pending', 'pending-trust'];
+const WARN_STATES = ['stale'];
+function providerGlyph(state) {
+    if (OK_STATES.includes(state))
+        return picocolors_1.default.green('✔');
+    if (PENDING_STATES.includes(state))
+        return picocolors_1.default.yellow('◷');
+    if (WARN_STATES.includes(state))
+        return picocolors_1.default.yellow('⚠');
+    return picocolors_1.default.red('✖');
+}
+function providerCheckDetail(check) {
+    if (check.id === 'binary.version' && check.target)
+        return picocolors_1.default.dim(` (${check.target})`);
+    if (check.state === 'pending-trust')
+        return picocolors_1.default.dim(' (pending trust)');
+    if (check.detail)
+        return picocolors_1.default.dim(` (${check.detail})`);
+    return '';
+}
+function providerCheckRemedy(check) {
+    return check.remediationCode ? picocolors_1.default.dim(`   → ${check.remediationCode}`) : '';
+}
+function providerCheckLine(check) {
+    return `  ${providerGlyph(check.state)} ${CHECK_LABELS[check.id]}${providerCheckDetail(check)}${providerCheckRemedy(check)}`;
+}
+function renderProviderReport(report) {
+    const lines = [];
+    lines.push(picocolors_1.default.bold('AWM · harness status'));
+    lines.push('');
+    for (const provider of report.providers) {
+        lines.push(`Provider: ${provider.label}`);
+        for (const check of provider.checks)
+            lines.push(providerCheckLine(check));
+        lines.push('');
+    }
+    const status = report.overall === 'healthy' ? picocolors_1.default.green('healthy') : picocolors_1.default.red('degraded');
+    lines.push(`status: ${status}`);
+    return lines.join('\n');
+}
 function runDoctor(opts = {}) {
+    const resolveTargets = opts.resolveTargets ?? agent_targets_1.resolveAgentTargets;
+    // Validates --agent separately from the general diagnostic gathering below:
+    // an unknown or disabled agent is a normal input-validation failure (the
+    // user typo'd or forgot `awm init --agent <x>`), not an "internal error" —
+    // give it its own clear message rather than lumping it under the generic
+    // internal-error catch further down.
+    let targets;
+    try {
+        const prefs = (0, config_1.getPreferences)();
+        targets = resolveTargets({ prefs, explicit: opts.agent });
+    }
+    catch (err) {
+        process.stderr.write(`awm doctor: ${err.message}\n`);
+        return 2;
+    }
     let report;
     try {
-        report = (0, checks_1.runChecks)((0, context_1.gatherContext)({ cwd: opts.cwd }));
+        const ctx = (0, context_1.gatherContext)({ cwd: opts.cwd, agents: targets });
+        const providers = ctx.providers ?? [];
+        report = { providers, overall: (0, checks_1.computeProviderOverall)(providers) };
     }
     catch (err) {
         process.stderr.write(`awm doctor: internal error: ${err.message}\n`);
@@ -65,15 +140,16 @@ function runDoctor(opts = {}) {
         process.stdout.write(JSON.stringify(report, null, 2) + '\n');
     }
     else {
-        process.stdout.write(renderReport(report) + '\n');
+        process.stdout.write(renderProviderReport(report) + '\n');
     }
     return report.overall === 'healthy' ? 0 : 1;
 }
 function registerDoctorCommand(program) {
     program.command('doctor')
-        .description('Read-only dashboard of the AWM harness state (machine + project)')
+        .description('Read-only dashboard of the AWM harness state, per provider')
         .option('--json', 'Emit the diagnostic report as JSON')
+        .option('-a, --agent <agent>', 'Target agent subset (comma-separated); defaults to every enabled agent')
         .action((options) => {
-        process.exitCode = runDoctor({ json: options.json });
+        process.exitCode = runDoctor({ json: options.json, agent: options.agent });
     });
 }

package/dist/src/commands/hooks/claude.js

@@ -0,0 +1,192 @@
+"use strict";
+// cli/src/commands/hooks/claude.ts
+//
+// Claude Code hook adapter: merges a single AWM SessionStart entry into
+// ~/.claude/settings.json, keyed by matcher + scriptsDir substring match.
+// Extracted verbatim (behavior-preserving) from the former monolithic
+// install.ts/status.ts/uninstall.ts — see tests/commands/hooks/install.test.ts's
+// characterization test for the frozen contract this must keep honoring.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installClaudeHook = installClaudeHook;
+exports.computeClaudeHookStatus = computeClaudeHookStatus;
+exports.uninstallClaudeHook = uninstallClaudeHook;
+exports.resyncClaudeHookFiles = resyncClaudeHookFiles;
+exports.claudeResyncSourcesExist = claudeResyncSourcesExist;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+const shared_1 = require("./shared");
+function isAwmEntry(entry, scriptsDir, matcher) {
+    return (entry?.matcher === matcher &&
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
+}
+function installClaudeHook(options) {
+    const config = (0, providers_1.getSettingsMergeHookConfig)(options.agent);
+    // 1. Verify registry sources exist FIRST (before touching settings)
+    const sourceHooks = path_1.default.join(options.registryRoot, 'hooks');
+    const sourceSkill = path_1.default.join(options.registryRoot, 'skills/using-awm/SKILL.md');
+    if (!fs_1.default.existsSync(path_1.default.join(sourceHooks, 'session-start'))) {
+        throw new Error(`AWM registry not found at ${sourceHooks}. Run 'awm update' to refresh the registry.`);
+    }
+    if (!fs_1.default.existsSync(sourceSkill)) {
+        throw new Error(`using-awm skill not found at ${sourceSkill}. Run 'awm update' first.`);
+    }
+    // 2. Sync scripts
+    fs_1.default.mkdirSync(config.scriptsDir, { recursive: true });
+    (0, shared_1.syncExecutable)(path_1.default.join(sourceHooks, 'session-start'), path_1.default.join(config.scriptsDir, 'session-start'), options.installMethod);
+    (0, shared_1.syncExecutable)(path_1.default.join(sourceHooks, 'run-hook.cmd'), path_1.default.join(config.scriptsDir, 'run-hook.cmd'), options.installMethod);
+    // 3. Link the skill (default: symlink so 'awm update' propagates; fall back to copy if symlink is unavailable, e.g. Windows without Developer Mode)
+    const skillDest = path_1.default.join(config.scriptsDir, 'using-awm.md');
+    try {
+        fs_1.default.unlinkSync(skillDest);
+    }
+    catch { /* not exists */ }
+    try {
+        fs_1.default.symlinkSync(sourceSkill, skillDest);
+    }
+    catch {
+        // best-effort: copy the single skill file; 'awm update' will not auto-propagate
+        fs_1.default.copyFileSync(sourceSkill, skillDest);
+    }
+    // 4. Backup settings if it exists
+    const backupPath = (0, shared_1.backupManagedFile)(config.settingsPath);
+    // 5. Read or initialize settings
+    let settings = {};
+    if (fs_1.default.existsSync(config.settingsPath)) {
+        const raw = fs_1.default.readFileSync(config.settingsPath, 'utf-8');
+        try {
+            settings = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`${config.settingsPath} is not valid JSON. Backup created at ${backupPath}. Fix the file manually, then re-run.`);
+        }
+    }
+    else {
+        fs_1.default.mkdirSync(path_1.default.dirname(config.settingsPath), { recursive: true });
+    }
+    // 6. Merge AWM entry
+    if (!settings.hooks)
+        settings.hooks = {};
+    if (!settings.hooks[config.eventName])
+        settings.hooks[config.eventName] = [];
+    const entries = settings.hooks[config.eventName];
+    const awmEntryIdx = entries.findIndex((e) => isAwmEntry(e, config.scriptsDir, config.matcher));
+    const newEntry = {
+        matcher: config.matcher,
+        hooks: [{
+                type: 'command',
+                command: `${path_1.default.join(config.scriptsDir, 'run-hook.cmd')} session-start`,
+                async: false
+            }]
+    };
+    let status;
+    if (awmEntryIdx >= 0) {
+        if (JSON.stringify(entries[awmEntryIdx]) === JSON.stringify(newEntry)) {
+            return { status: 'already-up-to-date', scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath: null };
+        }
+        entries[awmEntryIdx] = newEntry;
+        status = 'installed';
+    }
+    else {
+        entries.push(newEntry);
+        status = 'installed';
+    }
+    // 7. Write settings
+    fs_1.default.writeFileSync(config.settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { status, scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath };
+}
+function checkSettingsEntry(settingsPath, scriptsDir, matcher, eventName) {
+    if (!fs_1.default.existsSync(settingsPath)) {
+        return { ok: false, detail: `settings.json not found: ${settingsPath}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        return { ok: false, detail: 'settings.json is not valid JSON' };
+    }
+    const entries = parsed?.hooks?.[eventName] ?? [];
+    const awmEntry = entries.find((e) => e?.matcher === matcher &&
+        (e?.hooks ?? []).some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
+    if (!awmEntry) {
+        return { ok: false, detail: `no AWM SessionStart entry in ${settingsPath}` };
+    }
+    return { ok: true, detail: settingsPath };
+}
+function computeClaudeHookStatus(agent) {
+    const config = (0, providers_1.getSettingsMergeHookConfig)(agent);
+    const checks = {
+        bootstrapSkill: (0, shared_1.checkFile)(path_1.default.join(config.scriptsDir, 'using-awm.md')),
+        sessionStartScript: (0, shared_1.checkExecutable)(path_1.default.join(config.scriptsDir, 'session-start')),
+        runHookWrapper: (0, shared_1.checkExecutable)(path_1.default.join(config.scriptsDir, 'run-hook.cmd')),
+        settingsEntry: checkSettingsEntry(config.settingsPath, config.scriptsDir, config.matcher, config.eventName)
+    };
+    const allOk = Object.values(checks).every((c) => c.ok);
+    const settingsOnlyMissing = !checks.settingsEntry.ok && checks.bootstrapSkill.ok && checks.sessionStartScript.ok && checks.runHookWrapper.ok;
+    let overall;
+    if (allOk)
+        overall = 'HEALTHY';
+    else if (settingsOnlyMissing)
+        overall = 'NOT_INSTALLED';
+    else
+        overall = 'DEGRADED';
+    return { overall, checks };
+}
+function uninstallClaudeHook(agent) {
+    const config = (0, providers_1.getSettingsMergeHookConfig)(agent);
+    if (!fs_1.default.existsSync(config.settingsPath)) {
+        return { status: 'not-installed', backupPath: null };
+    }
+    let settings;
+    try {
+        settings = JSON.parse(fs_1.default.readFileSync(config.settingsPath, 'utf-8'));
+    }
+    catch {
+        throw new Error(`${config.settingsPath} is not valid JSON. Manual cleanup required.`);
+    }
+    const entries = settings?.hooks?.[config.eventName] ?? [];
+    const beforeLength = entries.length;
+    const filtered = entries.filter((e) => !isAwmEntry(e, config.scriptsDir, config.matcher));
+    if (filtered.length === beforeLength) {
+        return { status: 'not-installed', backupPath: null };
+    }
+    const backupPath = (0, shared_1.backupManagedFile)(config.settingsPath);
+    if (filtered.length === 0) {
+        delete settings.hooks[config.eventName];
+        if (Object.keys(settings.hooks).length === 0) {
+            delete settings.hooks;
+        }
+    }
+    else {
+        settings.hooks[config.eventName] = filtered;
+    }
+    fs_1.default.writeFileSync(config.settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { status: 'uninstalled', backupPath };
+}
+/** Refresh the Claude hook's script/skill files in place (used by resync). Assumes the caller has verified the settings entry is already present. */
+function resyncClaudeHookFiles(config, registryRoot, method) {
+    const sourceHooks = path_1.default.join(registryRoot, 'hooks');
+    const sourceSkill = path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md');
+    fs_1.default.mkdirSync(config.scriptsDir, { recursive: true });
+    (0, shared_1.syncExecutable)(path_1.default.join(sourceHooks, 'session-start'), path_1.default.join(config.scriptsDir, 'session-start'), method);
+    (0, shared_1.syncExecutable)(path_1.default.join(sourceHooks, 'run-hook.cmd'), path_1.default.join(config.scriptsDir, 'run-hook.cmd'), method);
+    const skillDest = path_1.default.join(config.scriptsDir, 'using-awm.md');
+    try {
+        fs_1.default.unlinkSync(skillDest);
+    }
+    catch { /* not exists */ }
+    fs_1.default.symlinkSync(sourceSkill, skillDest);
+}
+/** True when the registry has everything needed to resync the Claude hook files. */
+function claudeResyncSourcesExist(registryRoot) {
+    const sourceHooks = path_1.default.join(registryRoot, 'hooks');
+    const sourceSkill = path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md');
+    return fs_1.default.existsSync(path_1.default.join(sourceHooks, 'session-start')) &&
+        fs_1.default.existsSync(path_1.default.join(sourceHooks, 'run-hook.cmd')) &&
+        fs_1.default.existsSync(sourceSkill);
+}