runwork 0.15.1 → 0.15.2

package/dist/agents/defaults-merge.d.ts

@@ -1,87 +0,0 @@
-/**
- * Pure functions for the default-rules merge algorithm.
- *
- * The sync loop (commands/sync.ts) wires these together with per-adapter I/O.
- * Keeping the logic side-effect-free here makes it cheap to unit-test the
- * tricky lifecycle (bootstrap, opt-out detection, set shrinking) without
- * mocking filesystem layers.
- */
-import type { AgentDefaultsState } from '../types.js';
-import type { BakedDefaults } from './default-config.js';
-/** Items present in `lastInjected` but not in `onDisk`. These are entries the user removed since the previous sync. */
-export declare function detectRemovals(lastInjected: string[], onDisk: string[]): string[];
-/** Defaults filtered to exclude anything the user has opted out of. */
-export declare function computeApplicable(baked: string[], optOuts: string[]): string[];
-/**
- * Dedupe-silently merge of defaults and team rules. Team rules appear after
- * defaults in the output (the marker block's team-managed half), and dedupe
- * keeps the team-positioned copy when a default and a team rule are identical
- * strings. Stable ordering is preserved.
- */
-export declare function mergeAllow(applicableDefaults: string[], teamRules: string[]): string[];
-export declare function unique(items: string[]): string[];
-/**
- * Merge a new managed list into a markerless on-disk array while preserving
- * user-added entries. Shared by all markerless adapters (Cursor, Claude Code).
- *
- * existing  = what's currently on disk
- * baseline  = what we wrote on the previous sync (state.lastInjected). Items
- *             present here are assumed to be ours; subtracting them from
- *             existing leaves entries the user added themselves.
- * incoming  = the new managed set to inject (defaults already filtered for
- *             opt-outs, merged with team rules)
- *
- * If baseline is empty (bootstrap or first run with this CLI version), we
- * assume nothing currently on disk is ours and preserve all existing entries.
- */
-export declare function mergeMarkerless(existing: string[], baseline: string[], incoming: string[]): string[];
-/** True if no per-agent state has ever been recorded — first sync after upgrade or fresh install. */
-export declare function isBootstrap(state: AgentDefaultsState | undefined): boolean;
-export interface ResolveResult {
-    /**
-     * Final merged list to write into the managed block.
-     * For marker-based agents (Claude Code): goes after the marker.
-     * For markerless agents (Cursor): becomes part of the array,
-     * with `baseline` used by the adapter to identify and preserve user entries.
-     */
-    managedAllow: string[];
-    managedDeny: string[];
-    /** Defaults that we actually injected this sync. Stored as next sync's lastInjected. */
-    applicableAllow: string[];
-    applicableDeny: string[];
-    /** New sticky opt-out set. Stored as next sync's userOptOuts. */
-    newOptOutsAllow: string[];
-    newOptOutsDeny: string[];
-    /** Diagnostic counts for the sync log. */
-    removalsThisSync: {
-        allow: number;
-        deny: number;
-    };
-    /** True when this sync is the bootstrap pass and skipped default injection. */
-    bootstrapped: boolean;
-}
-export interface ResolveInput {
-    baked: BakedDefaults | undefined;
-    state: AgentDefaultsState | undefined;
-    onDisk: {
-        allow?: string[];
-        deny?: string[];
-    } | undefined;
-    team: {
-        allow?: string[];
-        deny?: string[];
-    } | undefined;
-}
-/**
- * Single-call resolver for one agent. Consumes the full input set and emits
- * the merged managed lists plus the next-sync state values. Pure: no I/O.
- *
- * Cases:
- *   1. No baked defaults for this agent → emits team rules only (no defaults
- *      logic kicks in). State stays undefined.
- *   2. Bootstrap (state undefined) → applies team rules but does NOT inject
- *      defaults this sync. Caller initializes empty state for next time.
- *   3. Normal → detects removals against lastInjected, accumulates opt-outs,
- *      filters baked by opt-outs, merges with team rules.
- */
-export declare function resolveAgentDefaults(input: ResolveInput): ResolveResult;

package/dist/agents/defaults-merge.js

@@ -1,150 +0,0 @@
-/**
- * Pure functions for the default-rules merge algorithm.
- *
- * The sync loop (commands/sync.ts) wires these together with per-adapter I/O.
- * Keeping the logic side-effect-free here makes it cheap to unit-test the
- * tricky lifecycle (bootstrap, opt-out detection, set shrinking) without
- * mocking filesystem layers.
- */
-/** Items present in `lastInjected` but not in `onDisk`. These are entries the user removed since the previous sync. */
-export function detectRemovals(lastInjected, onDisk) {
-    const onDiskSet = new Set(onDisk);
-    return lastInjected.filter((item) => !onDiskSet.has(item));
-}
-/** Defaults filtered to exclude anything the user has opted out of. */
-export function computeApplicable(baked, optOuts) {
-    const optOutSet = new Set(optOuts);
-    return baked.filter((item) => !optOutSet.has(item));
-}
-/**
- * Dedupe-silently merge of defaults and team rules. Team rules appear after
- * defaults in the output (the marker block's team-managed half), and dedupe
- * keeps the team-positioned copy when a default and a team rule are identical
- * strings. Stable ordering is preserved.
- */
-export function mergeAllow(applicableDefaults, teamRules) {
-    const teamSet = new Set(teamRules);
-    const result = [];
-    for (const item of applicableDefaults) {
-        if (!teamSet.has(item))
-            result.push(item);
-    }
-    for (const item of teamRules) {
-        result.push(item);
-    }
-    return result;
-}
-export function unique(items) {
-    const seen = new Set();
-    const out = [];
-    for (const item of items) {
-        if (!seen.has(item)) {
-            seen.add(item);
-            out.push(item);
-        }
-    }
-    return out;
-}
-/**
- * Merge a new managed list into a markerless on-disk array while preserving
- * user-added entries. Shared by all markerless adapters (Cursor, Claude Code).
- *
- * existing  = what's currently on disk
- * baseline  = what we wrote on the previous sync (state.lastInjected). Items
- *             present here are assumed to be ours; subtracting them from
- *             existing leaves entries the user added themselves.
- * incoming  = the new managed set to inject (defaults already filtered for
- *             opt-outs, merged with team rules)
- *
- * If baseline is empty (bootstrap or first run with this CLI version), we
- * assume nothing currently on disk is ours and preserve all existing entries.
- */
-export function mergeMarkerless(existing, baseline, incoming) {
-    const baselineSet = new Set(baseline);
-    const userEntries = existing.filter((item) => !baselineSet.has(item));
-    return unique([...userEntries, ...incoming]);
-}
-/** True if no per-agent state has ever been recorded — first sync after upgrade or fresh install. */
-export function isBootstrap(state) {
-    return state === undefined;
-}
-/**
- * Single-call resolver for one agent. Consumes the full input set and emits
- * the merged managed lists plus the next-sync state values. Pure: no I/O.
- *
- * Cases:
- *   1. No baked defaults for this agent → emits team rules only (no defaults
- *      logic kicks in). State stays undefined.
- *   2. Bootstrap (state undefined) → applies team rules but does NOT inject
- *      defaults this sync. Caller initializes empty state for next time.
- *   3. Normal → detects removals against lastInjected, accumulates opt-outs,
- *      filters baked by opt-outs, merges with team rules.
- */
-export function resolveAgentDefaults(input) {
-    const team = input.team ?? {};
-    const teamAllow = team.allow ?? [];
-    const teamDeny = team.deny ?? [];
-    // Case 1: no baked defaults — emit team rules unchanged, no state to track.
-    if (!input.baked) {
-        return {
-            managedAllow: unique(teamAllow),
-            managedDeny: unique(teamDeny),
-            applicableAllow: [],
-            applicableDeny: [],
-            newOptOutsAllow: [],
-            newOptOutsDeny: [],
-            removalsThisSync: { allow: 0, deny: 0 },
-            bootstrapped: false,
-        };
-    }
-    // Case 2: bootstrap — do not inject defaults this pass.
-    if (isBootstrap(input.state)) {
-        return {
-            managedAllow: unique(teamAllow),
-            managedDeny: unique(teamDeny),
-            applicableAllow: [],
-            applicableDeny: [],
-            newOptOutsAllow: [],
-            newOptOutsDeny: [],
-            removalsThisSync: { allow: 0, deny: 0 },
-            bootstrapped: true,
-        };
-    }
-    // Case 3: normal merge.
-    const state = input.state;
-    const lastInjectedAllow = state.lastInjected.allow ?? [];
-    const lastInjectedDeny = state.lastInjected.deny ?? [];
-    const existingOptOutsAllow = state.userOptOuts.allow ?? [];
-    const existingOptOutsDeny = state.userOptOuts.deny ?? [];
-    // Removal detection requires a reliable on-disk read. Markerless adapters
-    // (Cursor) cannot distinguish injected entries from user entries on disk, so
-    // they return `undefined` from readManagedBlock. Treating `undefined` as an
-    // empty array would fabricate a "user removed everything" signal on every
-    // subsequent sync and incorrectly convert every default into a sticky opt-out.
-    // When we cannot read managed state, we trust the baseline mechanism in the
-    // adapter and skip removal detection for this sync.
-    const canDetectRemovals = input.onDisk !== undefined;
-    const newRemovalsAllow = canDetectRemovals
-        ? detectRemovals(lastInjectedAllow, input.onDisk?.allow ?? [])
-        : [];
-    const newRemovalsDeny = canDetectRemovals
-        ? detectRemovals(lastInjectedDeny, input.onDisk?.deny ?? [])
-        : [];
-    const newOptOutsAllow = unique([...existingOptOutsAllow, ...newRemovalsAllow]);
-    const newOptOutsDeny = unique([...existingOptOutsDeny, ...newRemovalsDeny]);
-    const applicableAllow = computeApplicable(input.baked.allow, newOptOutsAllow);
-    const applicableDeny = computeApplicable(input.baked.deny, newOptOutsDeny);
-    return {
-        managedAllow: mergeAllow(applicableAllow, teamAllow),
-        managedDeny: mergeAllow(applicableDeny, teamDeny),
-        applicableAllow,
-        applicableDeny,
-        newOptOutsAllow,
-        newOptOutsDeny,
-        removalsThisSync: {
-            allow: newRemovalsAllow.length,
-            deny: newRemovalsDeny.length,
-        },
-        bootstrapped: false,
-    };
-}

package/dist/agents/detect.d.ts

@@ -1,4 +0,0 @@
-import type { AgentAdapter } from './types.js';
-export declare function detectAgents(): Promise<AgentAdapter[]>;
-export declare function getAdapterBySlug(slug: string): AgentAdapter | undefined;
-export declare function printNoAgentsMessage(): void;

package/dist/agents/detect.js

@@ -1,67 +0,0 @@
-import { ClaudeCodeAdapter } from './claude-code.js';
-import { ClaudeDesktopAdapter } from './claude-desktop.js';
-import { CursorAdapter } from './cursor.js';
-import { WindsurfAdapter } from './windsurf.js';
-import { CodexAdapter, CodexDesktopAdapter } from './codex.js';
-import { ClineAdapter } from './cline.js';
-import { GeminiAdapter } from './gemini.js';
-import { GenericAgentAdapter } from './generic-adapter.js';
-import { getRegistryAgents, getCustomAdapterSlugs } from './registry.js';
-/**
- * Agents with custom adapter implementations (plugin systems, special formats).
- * These override the generic adapter for their slug.
- */
-const CUSTOM_ADAPTERS = [
-    new ClaudeCodeAdapter(),
-    new ClaudeDesktopAdapter(),
-    new CursorAdapter(),
-    new WindsurfAdapter(),
-    new CodexAdapter(),
-    new CodexDesktopAdapter(),
-    new ClineAdapter(),
-    new GeminiAdapter(),
-];
-const customSlugs = getCustomAdapterSlugs();
-const customMap = new Map(CUSTOM_ADAPTERS.map(a => [a.slug, a]));
-/**
- * Build the full list of adapters: custom adapters for special agents,
- * generic adapters for everything else in the registry.
- */
-function buildAllAdapters() {
-    const adapters = [...CUSTOM_ADAPTERS];
-    for (const def of getRegistryAgents()) {
-        if (customSlugs.has(def.slug))
-            continue;
-        adapters.push(new GenericAgentAdapter(def));
-    }
-    return adapters;
-}
-const ALL_ADAPTERS = buildAllAdapters();
-export async function detectAgents() {
-    const results = await Promise.all(ALL_ADAPTERS.map(async (adapter) => {
-        try {
-            const detected = await adapter.detect();
-            return detected ? adapter : null;
-        }
-        catch {
-            return null;
-        }
-    }));
-    return results.filter((a) => a !== null);
-}
-export function getAdapterBySlug(slug) {
-    // Check custom adapters first, then fall back to generic
-    if (customMap.has(slug))
-        return customMap.get(slug);
-    return ALL_ADAPTERS.find(a => a.slug === slug);
-}
-export function printNoAgentsMessage() {
-    console.log('No supported AI coding agents detected.\n');
-    console.log('Install one to get started:\n');
-    console.log('  Claude Code:  npm i -g @anthropic-ai/claude-code');
-    console.log('  Cursor:       https://cursor.com');
-    console.log('  Codex CLI:    npm i -g @openai/codex');
-    console.log('  Gemini CLI:   https://github.com/google-gemini/gemini-cli');
-    console.log('  Windsurf:     https://windsurf.com');
-    console.log('');
-}

package/dist/agents/detection.d.ts

@@ -1,18 +0,0 @@
-/**
- * Shared agent-installation detection used by the generic adapter and by
- * custom adapters that opt in to the registry's declared detection rules
- * (e.g. Codex Desktop, which detects via `/Applications/Codex.app` on macOS
- * and the AppX package on Windows rather than a `codex` binary on PATH).
- *
- * Mirrors the desktop's agent-detection.ts logic but uses Node APIs instead
- * of Tauri plugins.
- */
-import type { AgentDetection } from './registry-data.js';
-/**
- * Detection — returns true when the agent is installed according to its
- * registry `detection` rules. Supports `binary`, `path`, `windows-appx`,
- * `windows-start-app`, and nested `any` combinators. PowerShell-backed
- * Windows probes run in parallel so a multi-target `any { windows-appx }`
- * pays one PowerShell startup, not N.
- */
-export declare function runAgentDetection(detection: AgentDetection): Promise<boolean>;

package/dist/agents/detection.js

@@ -1,94 +0,0 @@
-/**
- * Shared agent-installation detection used by the generic adapter and by
- * custom adapters that opt in to the registry's declared detection rules
- * (e.g. Codex Desktop, which detects via `/Applications/Codex.app` on macOS
- * and the AppX package on Windows rather than a `codex` binary on PATH).
- *
- * Mirrors the desktop's agent-detection.ts logic but uses Node APIs instead
- * of Tauri plugins.
- */
-import { execFile } from 'child_process';
-import { existsSync } from 'fs';
-import { homedir, platform } from 'os';
-import { isAbsolute, join } from 'path';
-import { promisify } from 'util';
-import { whichBinary } from '../utils/which.js';
-import { resolvePlatformString } from './registry.js';
-const execFileAsync = promisify(execFile);
-function isWindows() {
-    return platform() === 'win32';
-}
-function powershellQuote(value) {
-    return `'${value.replace(/'/g, "''")}'`;
-}
-function toList(value) {
-    return Array.isArray(value) ? value : [value];
-}
-async function runPowerShell(script) {
-    try {
-        await execFileAsync('powershell', ['-NoProfile', '-Command', script]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function checkPath(target) {
-    const resolved = resolvePlatformString(target);
-    if (!resolved)
-        return false;
-    if (isAbsolute(resolved))
-        return existsSync(resolved);
-    return existsSync(join(homedir(), resolved));
-}
-async function checkWindowsAppxPackage(target) {
-    if (!isWindows())
-        return false;
-    // Probe all candidate package names in parallel; resolve true on first hit.
-    const probes = toList(target).map((pkg) => {
-        const script = `$p = Get-AppxPackage -Name ${powershellQuote(pkg)} -ErrorAction SilentlyContinue; if ($null -ne $p) { exit 0 } exit 1`;
-        return runPowerShell(script);
-    });
-    const results = await Promise.all(probes);
-    return results.some(Boolean);
-}
-async function checkWindowsStartApp(target) {
-    if (!isWindows())
-        return false;
-    const probes = toList(target).map((pattern) => {
-        const script = `$a = Get-StartApps -Name ${powershellQuote(pattern)} -ErrorAction SilentlyContinue | Select-Object -First 1; if ($null -ne $a) { exit 0 } exit 1`;
-        return runPowerShell(script);
-    });
-    const results = await Promise.all(probes);
-    return results.some(Boolean);
-}
-/**
- * Detection — returns true when the agent is installed according to its
- * registry `detection` rules. Supports `binary`, `path`, `windows-appx`,
- * `windows-start-app`, and nested `any` combinators. PowerShell-backed
- * Windows probes run in parallel so a multi-target `any { windows-appx }`
- * pays one PowerShell startup, not N.
- */
-export async function runAgentDetection(detection) {
-    switch (detection.method) {
-        case 'binary': {
-            const target = resolvePlatformString(detection.target);
-            return !!target && !!whichBinary(target);
-        }
-        case 'path':
-            return checkPath(detection.target);
-        case 'windows-appx':
-            return checkWindowsAppxPackage(detection.target);
-        case 'windows-start-app':
-            return checkWindowsStartApp(detection.target);
-        case 'any': {
-            const probes = await Promise.all(detection.target.map((p) => runAgentDetection(p)));
-            return probes.some(Boolean);
-        }
-        case 'always':
-            // Web-only agents have no local footprint; always treated as available.
-            return true;
-        default:
-            return false;
-    }
-}

package/dist/agents/gemini.d.ts

@@ -1,15 +0,0 @@
-import type { AgentAdapter, AgentConfigOverride, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
-export declare class GeminiAdapter implements AgentAdapter {
-    name: string;
-    slug: string;
-    mcpProvidesSkills: boolean;
-    detect(): Promise<boolean>;
-    supportsMcpScope(scope: 'project' | 'user'): boolean;
-    supportsSkills(): boolean;
-    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
-    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
-    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
-    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
-    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
-}

package/dist/agents/gemini.js

@@ -1,122 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { whichBinary } from '../utils/which.js';
-import { buildSkillMd } from './types.js';
-import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
-import { mergeJsonMcpServers, removeRunworkMcpServers } from './utils/json-config.js';
-export class GeminiAdapter {
-    name = 'Gemini CLI';
-    slug = 'gemini';
-    mcpProvidesSkills = true;
-    async detect() {
-        return !!whichBinary('gemini');
-    }
-    supportsMcpScope(scope) {
-        return scope === 'user';
-    }
-    supportsSkills() {
-        return true;
-    }
-    async writeMcpServers(servers, _scope) {
-        const configPath = join(homedir(), '.gemini', 'settings.json');
-        const entries = {};
-        for (const s of servers) {
-            entries[s.name] = {
-                url: s.url,
-                ...(s.headers ? { headers: s.headers } : {}),
-            };
-        }
-        mergeJsonMcpServers(configPath, entries, 'mcpServers');
-    }
-    async writeSkills(skills, scope) {
-        const baseDir = scope === 'project'
-            ? join(process.cwd(), '.gemini', 'skills')
-            : join(homedir(), '.gemini', 'skills');
-        for (const skill of skills) {
-            if (skill.name !== skill.filename) {
-                const oldDir = join(baseDir, skill.name);
-                if (existsSync(oldDir)) {
-                    try {
-                        rmSync(oldDir, { recursive: true, force: true });
-                    }
-                    catch { /* best-effort */ }
-                }
-            }
-            const skillDir = join(baseDir, skill.filename);
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
-        }
-    }
-    async writeInstructionHint(hint, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), 'GEMINI.md')
-            : join(homedir(), '.gemini', 'GEMINI.md');
-        writeHintToFile(filePath, hint);
-    }
-    async writeTeamInstructions(instructions, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), 'GEMINI.md')
-            : join(homedir(), '.gemini', 'GEMINI.md');
-        writeTeamInstructionsToFile(filePath, instructions);
-    }
-    // ── Agent config (settings.json) ──────────────────────────────────
-    async writeAgentConfig(config, scope) {
-        const settingsPath = scope === 'project'
-            ? join(process.cwd(), '.gemini', 'settings.json')
-            : join(homedir(), '.gemini', 'settings.json');
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let settings = {};
-        if (existsSync(settingsPath)) {
-            try {
-                settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-            }
-            catch { /* start fresh */ }
-        }
-        if (config.modelPreference) {
-            if (!settings.model)
-                settings.model = {};
-            settings.model.name = config.modelPreference;
-        }
-        if (config.permissionRules?.allow) {
-            if (!settings.tools)
-                settings.tools = {};
-            settings.tools.allowed = config.permissionRules.allow;
-        }
-        if (config.permissionRules?.deny) {
-            if (!settings.tools)
-                settings.tools = {};
-            settings.tools.exclude = config.permissionRules.deny;
-        }
-        mkdirSync(join(settingsPath, '..'), { recursive: true });
-        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-    }
-    // ── Cleanup (uninstall) ────────────────────────────────────────────
-    async cleanup(scope, manifest) {
-        // 1. Remove MCP entries (user scope only)
-        if (scope === 'user') {
-            removeRunworkMcpServers(join(homedir(), '.gemini', 'settings.json'), 'mcpServers');
-        }
-        // 2. Remove only skill directories that we synced (listed in manifest)
-        const skillsDir = scope === 'project'
-            ? join(process.cwd(), '.gemini', 'skills')
-            : join(homedir(), '.gemini', 'skills');
-        if (existsSync(skillsDir) && manifest?.skillFilenames.length) {
-            const allowed = new Set(manifest.skillFilenames);
-            for (const entry of readdirSync(skillsDir)) {
-                if (!allowed.has(entry))
-                    continue;
-                try {
-                    rmSync(join(skillsDir, entry), { recursive: true, force: true });
-                }
-                catch { /* best-effort */ }
-            }
-        }
-        // 3. Remove instruction hints and team instructions
-        const instructionFile = scope === 'project'
-            ? join(process.cwd(), 'GEMINI.md')
-            : join(homedir(), '.gemini', 'GEMINI.md');
-        removeHintFromFile(instructionFile);
-        removeTeamInstructionsFromFile(instructionFile);
-    }
-}

package/dist/agents/generic-adapter.d.ts

@@ -1,25 +0,0 @@
-import type { AgentAdapter, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
-import type { AgentDefinition } from './registry.js';
-/**
- * Generic adapter that handles any agent from the registry using its
- * skillsPaths, mcpConfigPath, and instructionFile metadata.
- *
- * This covers the long tail of community agents. Agents with custom behavior
- * (plugin systems, special config formats, usage stats reading) use their
- * own dedicated adapter classes instead.
- */
-export declare class GenericAgentAdapter implements AgentAdapter {
-    name: string;
-    slug: string;
-    mcpProvidesSkills: boolean;
-    private def;
-    constructor(def: AgentDefinition);
-    detect(): Promise<boolean>;
-    supportsMcpScope(scope: 'project' | 'user'): boolean;
-    supportsSkills(): boolean;
-    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
-    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
-    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
-    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
-}