@lmctl-ai/lmctl 0.1.342 → 0.2.2

package/dist/providers/claude-mock.d.ts

@@ -0,0 +1,90 @@
+import type { ConversationMessage, SessionDetail, SessionProvider, SessionSummary, WatchPathInfo } from "./types.js";
+import type { ForkResult, InjectionInfo, ManualSeedHint, ProviderAdapter, ProviderCapabilities, SeedOptions, SeedResult, TurnOptions, TurnResult } from "./adapter.js";
+interface MockSession {
+    sessionId: string;
+    cwd: string;
+    filePath: string;
+    createdAt: Date;
+    modifiedAt: Date;
+    messages: ConversationMessage[];
+    totalInputTokens: number;
+    totalOutputTokens: number;
+}
+interface StoredConversationMessage extends Omit<ConversationMessage, "timestamp"> {
+    timestamp: string;
+}
+interface StoredMockSession extends Omit<MockSession, "createdAt" | "modifiedAt" | "messages"> {
+    createdAt: string;
+    modifiedAt: string;
+    messages: StoredConversationMessage[];
+}
+type ScriptedResponse = string | {
+    text: string;
+    error?: never;
+    delayMs?: number;
+} | {
+    error: string;
+    text?: never;
+    delayMs?: number;
+};
+interface ClaudeMockStore {
+    schemaVersion: 1;
+    defaultDelayMs?: number;
+    script?: Record<string, ScriptedResponse>;
+    /**
+     * Substring-match scripting, checked LAST (after exact + first-line miss).
+     * A key matches when it is a substring of the prompt, so a prompt with
+     * dynamic content before AND after a stable anchor phrase can be scripted
+     * deterministically. Kept as its own field (not a prefixed key inside
+     * `script`) so the two lookup modes stay independently typed and a literal
+     * prompt can never be mistaken for a substring pattern.
+     */
+    scriptContains?: Record<string, ScriptedResponse>;
+    sessions: Record<string, StoredMockSession>;
+}
+declare function mockStorePath(cwd?: string): string;
+declare function readStore(path: string): ClaudeMockStore;
+declare function acquireStoreLock(path: string): string;
+declare function releaseStoreLock(lockDir: string): void;
+declare function withStoreLock<T>(path: string, fn: () => T): T;
+declare function savePersistentSession(session: MockSession): void;
+declare function deletePersistentSession(sessionId: string, cwd?: string): boolean;
+export declare function _resetClaudeMockSessionsForTests(): void;
+export declare const _claudeMockStoreInternals: {
+    savePersistentSession: typeof savePersistentSession;
+    deletePersistentSession: typeof deletePersistentSession;
+    acquireStoreLock: typeof acquireStoreLock;
+    releaseStoreLock: typeof releaseStoreLock;
+    withStoreLock: typeof withStoreLock;
+    readStore: typeof readStore;
+    mockStorePath: typeof mockStorePath;
+    STORE_LOCK_STALE_MS: number;
+    STORE_LOCK_MAX_WAIT_MS: number;
+};
+export declare class ClaudeMockProvider implements SessionProvider {
+    name: "ClaudeMock";
+    discoverSessions(): Promise<SessionSummary[]>;
+    loadSession(sessionId: string): Promise<SessionDetail | null>;
+    resolveSessionPath(sessionId: string): Promise<string | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+}
+export declare class ClaudeMockAdapter implements ProviderAdapter {
+    readonly name: "ClaudeMock";
+    readonly capabilities: ProviderCapabilities;
+    readonly injection: InjectionInfo;
+    private readonly provider;
+    discover(): Promise<SessionSummary[]>;
+    load(sessionId: string): Promise<SessionDetail | null>;
+    resolvePath(sessionId: string): Promise<string | null>;
+    delete(sessionId: string): Promise<boolean>;
+    getWatchPaths(): WatchPathInfo[];
+    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
+    resumeCommand(sessionId: string): string;
+    startCommand(): string;
+    manualSeedHint(sessiondir: string): ManualSeedHint;
+    forkHint(_sessionId: string): string;
+    fork(_sessionId: string, _tag: string): Promise<ForkResult>;
+    sendTurn(prompt: string, opts: TurnOptions): Promise<TurnResult>;
+}
+export declare function createClaudeMockAdapter(): ClaudeMockAdapter;
+export {};

package/dist/providers/claude.d.ts

@@ -0,0 +1,21 @@
+import type { SessionProvider, SessionSummary, SessionDetail } from "./types.js";
+interface ClaudeProviderOptions {
+    claudeDir?: string;
+}
+export declare class ClaudeProvider implements SessionProvider {
+    name: "claude";
+    private claudeDir;
+    private projectsDir;
+    constructor(options?: ClaudeProviderOptions);
+    getWatchPaths(): {
+        directory: string;
+        filePattern: RegExp;
+    }[];
+    discoverSessions(): Promise<SessionSummary[]>;
+    private extractSummary;
+    loadSession(sessionId: string): Promise<SessionDetail | null>;
+    resolveSessionPath(sessionId: string): Promise<string | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    private resolveSessionFile;
+}
+export {};

package/dist/providers/codex-config.d.ts

@@ -0,0 +1,15 @@
+/** Compatibility no-op for retired Codex lmctl-MCP injection. */
+import type { McpExecutableWarningOptions } from "../mcp/path-warning.js";
+/**
+ * Per-server tool request timeout. Codex's MCP config uses seconds
+ * (`tool_timeout_sec`); keep the ms constant for parity with
+ * opencode's config and derive seconds for the TOML override.
+ */
+export declare const CODEX_LMCTL_MCP_TIMEOUT_MS = 86400000;
+export declare const CODEX_LMCTL_MCP_TIMEOUT_SEC: number;
+/**
+ * The lmctl MCP server remains in-tree, but provider MCP injection is
+ * retired. Keep the helper as a compatibility no-op for callers that
+ * still append its result into codex argv.
+ */
+export declare function buildCodexMcpFlags(_options?: McpExecutableWarningOptions): string[];

package/dist/providers/codex.d.ts

@@ -0,0 +1,25 @@
+import type { SessionProvider, SessionSummary, SessionDetail } from "./types.js";
+interface CodexProviderOptions {
+    codexDirs?: string[];
+    codexDir?: string;
+    codeDir?: string;
+}
+export declare class CodexProvider implements SessionProvider {
+    name: "codex";
+    private codexDirs;
+    constructor(options?: CodexProviderOptions);
+    getWatchPaths(): {
+        directory: string;
+        filePattern: RegExp;
+    }[];
+    private getSessionsDirs;
+    discoverSessions(): Promise<SessionSummary[]>;
+    private findSessionFiles;
+    private extractSessionIdFromFilename;
+    private extractSummary;
+    loadSession(sessionId: string): Promise<SessionDetail | null>;
+    resolveSessionPath(sessionId: string): Promise<string | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    private resolveSessionFile;
+}
+export {};

package/dist/providers/config/model-selection-lint.d.ts

@@ -0,0 +1,45 @@
+import { type CatalogSnapshot } from "../pricing.js";
+import type { MemberConfig } from "./team-config.js";
+export interface AgyModelsRunResult {
+    status: number | null;
+    stdout: string;
+    error?: Error;
+}
+export interface CodexModelsRunResult {
+    status: number | null;
+    stdout: string;
+    error?: Error;
+}
+export interface OpencodeModelsRunResult {
+    status: number | null;
+    stdout: string;
+    error?: Error;
+}
+export declare function modelSelectionWarnings(members: MemberConfig[], opts?: {
+    opencodeConfigPath?: string;
+    kimiConfigPath?: string;
+    agyModelsRunner?: () => AgyModelsRunResult;
+    opencodeModelsRunner?: (provider: string) => OpencodeModelsRunResult;
+    codexModelsRunner?: () => CodexModelsRunResult;
+}): string[];
+/**
+ * lmprice catalog resolution for lint/seed (design v2 sections 2+5). Runs
+ * resolveModel() for every member with model= on an adapter-covered
+ * provider against ONE snapshot load (loadCatalogSnapshot is memoized per
+ * process):
+ *   - unknown        -> warning (`provider may still accept it`)
+ *   - known-unpriced -> warning (operator invariant 2026-09-25: "if we can
+ *     lint, then we can cost" -- a lint-recognized model that cost cannot
+ *     price must be surfaced at lint time; lmprice build validation is
+ *     tasked with never publishing such half-bindings again)
+ *   - priced/estimated -> ok
+ *   - unresolved     -> silent (deliberate non-binding in lmprice's alias
+ *     table, not lint's claim to second-guess)
+ *   - no-catalog / catalog unavailable -> skip silently
+ * The returned warnings wire into lint/seed's standard warnings array, so
+ * `lint --strict` promotes them exactly like every other warning.
+ */
+export declare function catalogModelWarnings(members: MemberConfig[], opts?: {
+    snapshot?: CatalogSnapshot;
+}): Promise<string[]>;
+export declare function resolveModelSelectionDocPathFromHere(here: string): string;

package/dist/providers/config/team-config.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Team config — one <team>.lmctl file per team.
+ *
+ * Free-form markdown with embedded `_MEMBER_` lines for the team's
+ * sessions:
+ *
+ *   # Frontend Team
+ *
+ *   _MEMBER_ alias=Lead     provider=claude sessionid=abc-123
+ *   _MEMBER_ alias=Coder    provider=claude sessionid=def-456
+ *   _MEMBER_ alias=Reviewer provider=codex  sessionid=ghi-789
+ *
+ * `sessiondir=` is optional; when omitted, the teamfile's own directory is
+ * used at resolution time. Keep explicit sessiondir only for members that run
+ * in a different repository.
+ *
+ * Everything outside `_MEMBER_` lines is natural language (policy,
+ * notes, context). Legacy frontmatter is parsed when present, but it
+ * is optional. When the team declares a Lead, the full document is
+ * injected into that Lead's context as-is.
+ *
+ * Wire format renames (one cutover at this commit):
+ *   - `_SESSION_`  → `_MEMBER_`  (matches the codebase's `MemberEntry`
+ *     type)
+ *   - `id=`        → `sessionid=` (matches `mcp__lmctl__lmctl_chat`'s
+ *     `sessionid` parameter; an LLM can copy the identity quadruple
+ *     from a member line straight to a tool call without renaming
+ *     fields)
+ *
+ * Legacy `_SESSION_` is rejected with a clear migration error.
+ *
+ * alias=Lead has special bootstrap/default-routing behavior when
+ * present (at most one per team), but a Lead is not required.
+ */
+import { type Frontmatter } from "../frontmatter.js";
+export interface MemberConfig {
+    alias: string;
+    provider: string;
+    session?: string;
+    sessiondir?: string;
+    /** Provider-specific model name (e.g. "claude-sonnet-4-6"). Optional.
+     *  The transport maps this through each provider's supported model
+     *  selection surface; unsupported providers ignore with provider-
+     *  specific diagnostics. */
+    model?: string;
+    /** Provider-specific effort / variant selection. Currently used by
+     *  OpenCode ACP as the provider's effort config option. Kimi has no
+     *  genuine per-turn effort override (its `thinking` option is on/off
+     *  only, resolved per-model) so lint warns and ignores this for kimi. */
+    effort?: string;
+    /** Path to a sub-team's .lmctl file. When set, this member is a
+     *  team reference — provider/id/sessiondir come from the
+     *  referenced teamfile's lead session at resolution time. */
+    teamfile?: string;
+    /** Extra key=value pairs from the session line */
+    extra: Record<string, string>;
+}
+export interface TeamConfig {
+    /** Team name (from filename without .lmctl extension). */
+    name: string;
+    /** All members parsed from session lines. */
+    members: MemberConfig[];
+    /** The full raw document text (for leader injection). */
+    rawText: string;
+    /** Errors from malformed session lines, invalid legacy frontmatter,
+     *  legacy `_SESSION_` prefix, etc. `validateTeamConfig` upgrades
+     *  these to validation errors so CLI commands surface them. */
+    parseErrors: string[];
+    /** Parsed legacy frontmatter, or `null` if the file lacks it / had
+     *  a malformed block. Frontmatter is optional for current teamfiles. */
+    frontmatter: Frontmatter | null;
+}
+export interface TeamValidationError {
+    field: string;
+    message: string;
+}
+/** The conventional alias that triggers Lead bootstrap/default routing. */
+export declare const LEADER_ALIAS = "Lead";
+export declare function teamNameFromPath(filePath: string): string;
+export declare function readTeamConfig(filePath: string): TeamConfig;
+export interface ParseTeamConfigOptions {
+    baseDir?: string;
+    sourcePath?: string;
+}
+export declare function parseTeamConfigText(raw: string, name: string, options?: ParseTeamConfigOptions): TeamConfig;
+/**
+ * Diff frontmatter `members:` against the aliases on `_MEMBER_` lines.
+ * Returns null if they agree (sorted-set equal); else returns a
+ * human-readable warning string. Caller decides how to surface it.
+ */
+export declare function checkMemberDrift(config: TeamConfig): string | null;
+export declare function serializeTeamConfig(config: TeamConfig): string;
+export declare function writeTeamConfig(filePath: string, config: TeamConfig): void;
+export declare function validateTeamConfig(config: TeamConfig, parentDir?: string): TeamValidationError[];
+export declare function getLeader(config: TeamConfig): MemberConfig | undefined;
+/**
+ * Resolved details from a team reference — the sub-team's lead
+ * session's provider, id, sessiondir, and model override.
+ */
+export interface ResolvedTeamMember {
+    provider: string;
+    session: string;
+    sessiondir: string;
+    alias: string;
+    resolvedFrom: string;
+    /** Model override from the sub-team's lead (Task A). Undefined if unset. */
+    model?: string;
+    /** Effort override from the sub-team's lead. Undefined if unset. */
+    effort?: string;
+}
+export interface ResolveTeamReferenceOptions {
+    requireSession?: boolean;
+}
+/**
+ * Resolve a `teamfile=` reference to the sub-team's lead session.
+ *
+ * @param member     The member with `teamfile` set.
+ * @param parentDir  Directory of the PARENT teamfile (for resolving
+ *                   relative paths in `teamfile=`).
+ * @param visited    Circular-reference guard. Callers should NOT pass
+ *                   this — it's used internally for recursion.
+ *
+ * Throws on: missing teamfile, no lead, no session ID, circular ref.
+ */
+export declare function resolveTeamReference(member: MemberConfig, parentDir: string, visited?: Set<string>, options?: ResolveTeamReferenceOptions): ResolvedTeamMember;
+export declare function getMemberByAlias(config: TeamConfig, alias: string): MemberConfig | undefined;
+/** Reserved aliases for the mechanical review loop. */
+export declare const CODER_ALIAS = "Coder";
+export declare const REVIEWER_ALIAS = "Reviewer";
+/**
+ * Check whether a team is a leadless Coder+Reviewer team, which
+ * triggers the mechanical review loop (Task 77).
+ */
+export declare function isLeadlessReviewTeam(config: TeamConfig): boolean;
+/**
+ * Resolve the target alias for a team given the routing rules:
+ *   1. --alias specified → that alias (direct addressing)
+ *   2. Exactly 1 member → that member (regardless of alias; solo-worker
+ *      teams are a first-class shape)
+ *   3. No Lead + Coder + Reviewer → "__review__" (mechanical review)
+ *   4. Has Lead → Lead's alias (case-insensitive via getLeader)
+ *   5. >1 members with no Lead → error listing available aliases
+ */
+export declare function resolveTeamTarget(config: TeamConfig, targetAlias?: string): {
+    kind: "direct";
+    alias: string;
+} | {
+    kind: "review";
+} | {
+    kind: "error";
+    message: string;
+};
+/** A node in the team tree (or DAG if diamonds exist). */
+export interface TeamTreeNode {
+    /** Absolute path to this node's .lmctl file. */
+    filePath: string;
+    /** Parsed team config. */
+    config: TeamConfig;
+    /** Children: member alias → child node (only for teamfile= members). */
+    children: Map<string, TeamTreeNode>;
+}
+/**
+ * Build a team tree (DAG) by recursively resolving all `teamfile=`
+ * references starting from `rootPath`.
+ *
+ * Uses two data structures for correctness:
+ * - `chain` (Set): tracks the current ancestor path from root to
+ *   detect cycles. Added on entry, deleted on backtrack. A path
+ *   appearing twice in the chain IS a cycle.
+ * - `visited` (Map): deduplicates diamonds. If a file was already
+ *   built by a sibling branch, returns the existing node instead of
+ *   re-reading. A path appearing in visited but not in chain is a
+ *   diamond (safe), not a cycle.
+ *
+ * Throws on: cycles, missing files, parse errors.
+ */
+export declare function buildTeamTree(rootPath: string, chain?: Set<string>, visited?: Map<string, TeamTreeNode>): TeamTreeNode;
+/**
+ * Collect all unique nodes in the tree in post-order (children before
+ * parent). Used by `create` for depth-first seeding and by `lint`
+ * for per-node reporting.
+ */
+export declare function postOrderNodes(root: TeamTreeNode): TeamTreeNode[];

package/dist/providers/config/types.d.ts

@@ -0,0 +1,146 @@
+import type { ProviderName } from "../types.js";
+export type { ProviderName };
+/** Valid member roles. */
+export type MemberRole = "coder" | "reviewer" | "leader";
+/** A team member — corresponds to [team.member] section. */
+export interface MemberEntry {
+    /** Team name (from section name, before the dot). */
+    team: string;
+    /** Member alias (from section name, after the dot). */
+    alias: string;
+    /** Provider name = tool identity. */
+    provider: ProviderName;
+    /** Native session ID. Absent for pending slots. */
+    session?: string;
+    /** Role within the team. */
+    role: MemberRole;
+    /** Absolute runtime sessiondir for this session. */
+    sessiondir?: string;
+    /** Optional profile name. */
+    profile?: string;
+    /** Optional description. */
+    description?: string;
+}
+/** An orphaned session — corresponds to [orphaned.name] section. */
+export interface OrphanedEntry {
+    /** Alias (from section name, after "orphaned."). */
+    alias: string;
+    /** Provider name = tool identity. */
+    provider: ProviderName;
+    /** Native session ID. */
+    session?: string;
+    /** Absolute path to session working directory. */
+    sessiondir: string;
+    /** Optional description. */
+    description?: string;
+    /** Optional profile name. */
+    profile?: string;
+}
+/** A team — corresponds to [team] section. */
+export interface TeamEntry {
+    /** Team name (from section header). */
+    name: string;
+    /** Team description. */
+    description?: string;
+    /** Absolute path to the actual code/project directory for this team. */
+    workdir?: string;
+}
+/** Full parsed representation of an lmctl.config file. */
+export interface WorkspaceConfig {
+    /** Workspace name (bare key at top of file). */
+    name: string;
+    /** Teams indexed by name. */
+    teams: Record<string, TeamEntry>;
+    /** All team members. */
+    members: MemberEntry[];
+    /** Standalone sessions not in any team. */
+    orphaned: OrphanedEntry[];
+    /** PM session pointer (top-level, optional). */
+    pmProvider?: ProviderName;
+    pmSession?: string;
+    /** Absolute runtime sessiondir for the PM session. */
+    pmSessiondir?: string;
+}
+/** A validation error found by validateConfig. */
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+/** Result of a find operation (append-only discovery). */
+export interface FindResult {
+    added: number;
+    errors: string[];
+}
+/** Provider names that cannot be used as member aliases. */
+export declare const RESERVED_NAMES: ReadonlySet<string>;
+/** All valid provider names. */
+export declare const VALID_PROVIDERS: ReadonlySet<string>;
+/** Providers allowed for orchestrator roles (leader).
+ *  All providers allowed. Codex leaders use exec_command with yield-based
+ *  polling for shell commands. Long lmctl chat turns may need multiple
+ *  polls (yield_time_ms up to 30s, then re-poll). The Codex model
+ *  sometimes gives up too early — a behavioral issue, not a platform limit. */
+export declare const VALID_ORCHESTRATOR_PROVIDERS: ReadonlySet<string>;
+/** All valid member roles. */
+export declare const VALID_ROLES: ReadonlySet<string>;
+/** User-scoped tool configuration from ~/.lmctl/config.toml. */
+export interface ToolProfileConfig {
+    description?: string;
+    flags?: string;
+}
+export interface ToolConfig {
+    start?: string;
+    resume?: string;
+    /** Optional override for the non-interactive one-shot command. */
+    agent?: string;
+    profiles?: Record<string, ToolProfileConfig>;
+    /** Legacy fallback for older configs written before named profiles existed. */
+    profile_flag?: string;
+}
+/** Per-provider compact threshold overrides. Either or both may be present. */
+export interface CompactProviderConfig {
+    /** Minimum context tokens before `lmctl compact` will even prompt. */
+    min?: number;
+    /** Context tokens at or above which `lmctl compact` auto-runs without prompting. */
+    max?: number;
+}
+/** Compaction-gate configuration parsed from the [compact] / [compact.<provider>]
+ *  sections of ~/.lmctl/config.toml. The resolver
+ *  (`resolveCompactThresholds`) applies precedence: provider override beats
+ *  global beats built-in defaults. */
+export interface CompactConfig {
+    /** Global defaults for any provider that has no override. */
+    global?: CompactProviderConfig;
+    /** Per-provider overrides keyed by provider name (claude, codex, ...). */
+    providers?: Record<string, CompactProviderConfig>;
+}
+/** Full parsed representation of ~/.lmctl/config.toml. */
+export interface UserConfig {
+    tools: Record<string, ToolConfig>;
+    /** Optional compaction gating thresholds. Absent ⇒ all defaults. */
+    compact?: CompactConfig;
+    /** Optional operator-chosen name for this environment/computer (flat
+     * top-level `site_name = "..."` key). Purely informational today; the
+     * forward motivation is cross-site agent identification, but nothing
+     * requires it — readers must treat absence as normal. */
+    site_name?: string;
+}
+/** Get the leader of a team (if any). */
+export declare function getTeamLeader(config: WorkspaceConfig, teamName: string): MemberEntry | undefined;
+/** Get all members of a team. */
+export declare function getTeamMembers(config: WorkspaceConfig, teamName: string): MemberEntry[];
+/** Check if a team is managed (has a leader). */
+export declare function isTeamManaged(config: WorkspaceConfig, teamName: string): boolean;
+/** Check whether a provider can be used for orchestrator roles (PM, leader). */
+export declare function isValidOrchestratorProvider(provider: string): boolean;
+/**
+ * Find any member or orphaned entry by native session ID.
+ * Returns the entry and whether it's a member or orphaned.
+ */
+export declare function findBySessionId(config: WorkspaceConfig, sessionId: string): {
+    type: "member";
+    entry: MemberEntry;
+} | {
+    type: "orphaned";
+    entry: OrphanedEntry;
+} | null;

package/dist/providers/config/user-config.d.ts

@@ -0,0 +1,88 @@
+import type { UserConfig } from "./types.js";
+type OneShotMode = "argv" | "stdin";
+type OneShotProviderConfig = {
+    mode: OneShotMode;
+    argv: string[];
+};
+export declare const DEFAULT_ONE_SHOT_OPTIONS: Record<string, OneShotProviderConfig>;
+/** Default path for the user config file. */
+export declare function getDefaultUserConfigPath(): string;
+/**
+ * Read and parse the user config file.
+ *
+ * The format is INI-like with:
+ * - [tool.<name>] sections containing key=value pairs for start/resume
+ * - [tool.<name>.profile.<profile>] sections containing description/flags
+ *
+ * If the file does not exist, returns an empty config.
+ */
+export declare function readUserConfig(filePath?: string): UserConfig;
+/**
+ * Parse a token-count value with optional shorthand suffix.
+ *
+ * Accepted forms:
+ *   - "128000"  → 128000
+ *   - "128K"    → 128000   (K = ×1000)
+ *   - "1.5K"    → 1500     (fractional allowed)
+ *   - "1M"      → 1000000  (M = ×1000000)
+ *   - 128000    → 128000   (raw number)
+ *
+ * Returns null on unparseable input. Suffix matching is case-insensitive
+ * (lowercase `k` / `m` are accepted).
+ */
+export declare function parseTokenShorthand(raw: string | number): number | null;
+/** Internal: parse user config from string. */
+export declare function parseUserConfigText(raw: string): UserConfig;
+/**
+ * Safe reader for the optional site name. Null when unset — the value is
+ * informational and never required, so callers must not treat null as an
+ * error. (NOTE: `debug=true` handling lives in src/providers/debug.ts with
+ * its own scan and is deliberately untouched by the top-level capture here.)
+ */
+export declare function getSiteName(cfg: UserConfig): string | null;
+/** Built-in defaults applied when neither config nor CLI flag overrides. */
+export declare const COMPACT_DEFAULT_MIN = 128000;
+export declare const COMPACT_DEFAULT_MAX = 300000;
+/**
+ * Resolve effective {min, max} compact thresholds for a given provider.
+ *
+ * Precedence (highest wins, per-key):
+ *   1. `[compact.<provider>]` from user config
+ *   2. `[compact]` global from user config
+ *   3. Built-in defaults (`COMPACT_DEFAULT_MIN` / `COMPACT_DEFAULT_MAX`)
+ *
+ * `min` and `max` are resolved independently — a provider override may
+ * supply only `min` and inherit `max` from the global. Same for global
+ * inheriting from defaults.
+ */
+export declare function resolveCompactThresholds(cfg: UserConfig, provider: string): {
+    min: number;
+    max: number;
+};
+/**
+ * Check if the user has an explicit [tool.<name>] section in their config.
+ * Returns false if only DEFAULT_TOOLS would be used.
+ */
+export declare function hasUserToolConfig(cfg: UserConfig, toolName: string): boolean;
+export declare function hasConfiguredProfile(cfg: UserConfig, toolName: string, profile?: string): boolean;
+export declare function buildResumeCommand(cfg: UserConfig, toolName: string, sessionId: string, profile?: string): string;
+/**
+ * Build a shell command to start a new session.
+ *
+ * If a named profile is specified, its configured flags are appended.
+ */
+export declare function buildStartCommand(cfg: UserConfig, toolName: string, profile?: string): string;
+/**
+ * Build a non-interactive (one-shot) command to send a prompt to an existing
+ * session and get the response back. The tool runs, prints output, and exits.
+ *
+ * Replaces {{session_id}} and {{prompt}} placeholders. The prompt is
+ * shell-escaped (single-quoted with internal single-quotes escaped).
+ */
+export declare function buildAgentCommand(cfg: UserConfig, toolName: string, sessionId: string, prompt: string, profile?: string): string;
+/**
+ * Create a default user config file with templates for all supported tools.
+ * Creates parent directories as needed.
+ */
+export declare function writeDefaultUserConfig(filePath: string): void;
+export {};

package/dist/providers/copilot.d.ts

@@ -0,0 +1,21 @@
+import type { SessionProvider, SessionSummary, SessionDetail } from "./types.js";
+interface CopilotProviderOptions {
+    copilotDir?: string;
+}
+export declare class CopilotProvider implements SessionProvider {
+    name: "copilot";
+    private sessionStateDir;
+    constructor(options?: CopilotProviderOptions);
+    getWatchPaths(): {
+        directory: string;
+        filePattern: RegExp;
+    }[];
+    discoverSessions(): Promise<SessionSummary[]>;
+    loadSession(sessionId: string): Promise<SessionDetail | null>;
+    private extractSummary;
+    private readWorkspaceYaml;
+    resolveSessionPath(sessionId: string): Promise<string | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    private resolveSessionDir;
+}
+export {};