@lucasreiners/lead 0.1.0

package/dist/agents/tester/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentFactory } from "../types";
+export declare const TESTER_DEFAULTS: AgentConfig;
+export declare const createTesterAgent: AgentFactory;

package/dist/agents/types.d.ts

@@ -0,0 +1,37 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export type LeadAgentName = "tech-lead" | "lead-dev" | "engineer" | "architect" | "code-analyst" | "researcher" | "reviewer" | "tester" | "guardian";
+/**
+ * primary — user-facing agent, uses UI-selected model
+ * subagent — spawned by other agents, uses its own fallback model
+ * all — available in both contexts
+ */
+export type AgentMode = "primary" | "subagent" | "all";
+export type AgentFactory = ((model: string) => AgentConfig) & {
+    mode: AgentMode;
+};
+export type AgentSource = AgentFactory | AgentConfig;
+export interface DelegationTrigger {
+    domain: string;
+    trigger: string;
+}
+export interface AgentCost {
+    tier: "cheap" | "moderate" | "expensive";
+    label: string;
+}
+export interface AgentPromptMetadata {
+    name: LeadAgentName | string;
+    displayName: string;
+    description: string;
+    mode: AgentMode;
+    triggers?: DelegationTrigger[];
+    cost?: AgentCost;
+    skills?: string[];
+    category?: string;
+}
+export declare function isFactory(source: AgentSource): source is AgentFactory;
+/**
+ * Returns true if the model string looks like a GPT-series model.
+ * Used for temperature adjustment (GPT models have different defaults).
+ */
+export declare function isGptModel(model: string): boolean;
+export type { AgentConfig };

package/dist/config/continuation.d.ts

@@ -0,0 +1,13 @@
+import type { ContinuationConfig } from "./schema";
+export interface ResolvedContinuationConfig {
+    recovery: {
+        compaction: boolean;
+    };
+    idle: {
+        enabled: boolean;
+        work: boolean;
+        workflow: boolean;
+        todo_prompt: boolean;
+    };
+}
+export declare function resolveContinuationConfig(raw?: ContinuationConfig): ResolvedContinuationConfig;

package/dist/config/index.d.ts

@@ -0,0 +1,6 @@
+export { LeadConfigSchema } from "./schema";
+export type { LeadConfig, AgentOverrideConfig, CustomAgentConfig, CategoryConfig, CategoriesConfig, BackgroundConfig, ContinuationConfig, WorkflowConfig, ExperimentalConfig, ToolPermissionMap, } from "./schema";
+export { mergeConfigs } from "./merge";
+export { loadLeadConfig } from "./loader";
+export { resolveContinuationConfig } from "./continuation";
+export type { ResolvedContinuationConfig } from "./continuation";

package/dist/config/loader.d.ts

@@ -0,0 +1,12 @@
+import type { LeadConfig } from "./schema";
+/**
+ * Load and merge Lead config from:
+ * 1. User global config: ~/.config/opencode/lead.jsonc
+ * 2. Project config: {directory}/.opencode/lead.jsonc
+ *
+ * Project config overrides user config.
+ * Returns valid LeadConfig even if no files exist (empty defaults).
+ */
+export declare function loadLeadConfig(directory: string, options?: {
+    homeDir?: string;
+}): LeadConfig;

package/dist/config/merge.d.ts

@@ -0,0 +1,8 @@
+import type { LeadConfig } from "./schema";
+/**
+ * Deep-merges two LeadConfig objects.
+ * - Objects (agents, custom_agents, categories): deep-merged, project overrides
+ * - Arrays (disabled_*): unioned and deduplicated
+ * - Scalars: project overrides user
+ */
+export declare function mergeConfigs(user: LeadConfig, project: LeadConfig): LeadConfig;

package/dist/config/scaffold.d.ts

@@ -0,0 +1,12 @@
+interface ScaffoldOptions {
+    directory: string;
+}
+/**
+ * Checks if a project-level lead.jsonc exists.
+ * If not, creates one with the default model chains documented.
+ *
+ * Synchronous — safe to call during plugin init without blocking.
+ * Returns true if a config was scaffolded, false if one already existed.
+ */
+export declare function scaffoldConfigIfMissing(options: ScaffoldOptions): boolean;
+export {};

package/dist/config/schema.d.ts

@@ -0,0 +1,140 @@
+import { z } from "zod";
+declare const ToolPermissionMapSchema: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    display_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CustomAgentConfigSchema: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    prompt_file: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    display_name: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        subagent: "subagent";
+        primary: "primary";
+        all: "all";
+    }>>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        trigger: z.ZodString;
+    }, z.core.$strip>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CategoryConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const CategoriesConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+declare const BackgroundConfigSchema: z.ZodObject<{
+    max_concurrent: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ContinuationRecoveryConfigSchema: z.ZodObject<{
+    compaction: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ContinuationIdleConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    work: z.ZodOptional<z.ZodBoolean>;
+    workflow: z.ZodOptional<z.ZodBoolean>;
+    todo_prompt: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ContinuationConfigSchema: z.ZodObject<{
+    recovery: z.ZodOptional<z.ZodObject<{
+        compaction: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    idle: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        work: z.ZodOptional<z.ZodBoolean>;
+        workflow: z.ZodOptional<z.ZodBoolean>;
+        todo_prompt: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const WorkflowConfigSchema: z.ZodObject<{
+    disabled_workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    directories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const ExperimentalConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const LeadConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        display_name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    custom_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        prompt: z.ZodOptional<z.ZodString>;
+        prompt_file: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        display_name: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            subagent: "subagent";
+            primary: "primary";
+            all: "all";
+        }>>;
+        triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            trigger: z.ZodString;
+        }, z.core.$strip>>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disabled_skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skill_directories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    background: z.ZodOptional<z.ZodObject<{
+        max_concurrent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    continuation: z.ZodOptional<z.ZodObject<{
+        recovery: z.ZodOptional<z.ZodObject<{
+            compaction: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        idle: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            work: z.ZodOptional<z.ZodBoolean>;
+            workflow: z.ZodOptional<z.ZodBoolean>;
+            todo_prompt: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    workflows: z.ZodOptional<z.ZodObject<{
+        disabled_workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        directories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    experimental: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    log_level: z.ZodOptional<z.ZodEnum<{
+        DEBUG: "DEBUG";
+        INFO: "INFO";
+        WARN: "WARN";
+        ERROR: "ERROR";
+    }>>;
+}, z.core.$strip>;
+export type LeadConfig = z.infer<typeof LeadConfigSchema>;
+export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+export type CustomAgentConfig = z.infer<typeof CustomAgentConfigSchema>;
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
+export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>;
+export type BackgroundConfig = z.infer<typeof BackgroundConfigSchema>;
+export type ContinuationConfig = z.infer<typeof ContinuationConfigSchema>;
+export type ContinuationRecoveryConfig = z.infer<typeof ContinuationRecoveryConfigSchema>;
+export type ContinuationIdleConfig = z.infer<typeof ContinuationIdleConfigSchema>;
+export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>;
+export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
+export type ToolPermissionMap = z.infer<typeof ToolPermissionMapSchema>;
+export {};

package/dist/create-managers.d.ts

@@ -0,0 +1,32 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LeadConfig } from "./config/schema";
+import type { ResolvedContinuationConfig } from "./config/continuation";
+import type { ResolveSkillsFn } from "./agents/agent-builder";
+import { ConfigHandler } from "./managers/config-handler";
+import { BackgroundManager } from "./managers/background-manager";
+import { SkillMcpManager } from "./managers/skill-mcp-manager";
+/**
+ * L.E.A.D. manager instances created during plugin initialization.
+ */
+export interface LeadManagers {
+    /** Handles registering agents into OpenCode config */
+    configHandler: ConfigHandler;
+    /** Manages background task spawning and lifecycle */
+    backgroundManager: BackgroundManager;
+    /** Manages MCP server connections from skills (v0.1: stub) */
+    skillMcpManager: SkillMcpManager;
+    /** All registered agent configs (builtin + custom) */
+    agents: Record<string, AgentConfig>;
+}
+export interface CreateManagersOptions {
+    ctx: PluginInput;
+    pluginConfig: LeadConfig;
+    continuation: ResolvedContinuationConfig;
+    resolveSkills?: ResolveSkillsFn;
+}
+/**
+ * Create all L.E.A.D. manager instances.
+ * Builds builtin agents, applies config overrides, adds custom agents.
+ */
+export declare function createManagers(options: CreateManagersOptions): Promise<LeadManagers>;

package/dist/create-tools.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LeadConfig } from "./config/schema";
+import type { ResolveSkillsFn } from "./agents/agent-builder";
+import type { LoadedSkill } from "./features/skill-loader/types";
+/**
+ * Result of the tools creation step.
+ */
+export interface ToolsResult {
+    /** Loaded skill instances */
+    availableSkills: LoadedSkill[];
+    /** Resolver function for skill prompt injection */
+    resolveSkills: ResolveSkillsFn;
+    /** (Empty in v0.1 — tools come from OpenCode, not the plugin) */
+    tools: Record<string, never>;
+}
+export interface CreateToolsOptions {
+    ctx: PluginInput;
+    pluginConfig: LeadConfig;
+}
+/**
+ * Load skills, create the resolver, and return the tools result.
+ * In v0.1, the plugin does not register custom tools — OpenCode provides them.
+ */
+export declare function createTools(options: CreateToolsOptions): Promise<ToolsResult>;

package/dist/domain/plans/index.d.ts

@@ -0,0 +1,2 @@
+export type { WorkState, PlanProgress } from "../../features/work-state/types";
+export { STATE_FILE, STATE_DIR, ADHOC_DIR } from "../../features/work-state/constants";

package/dist/domain/policy/policy-result.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Policy result types for the L.E.A.D. policy engine.
+ * Policies are evaluated at lifecycle hooks (chat, tool, session).
+ * Deny wins over allow when merging multiple policy results.
+ */
+export type PolicyVerdict = "allow" | "deny";
+export interface PolicyResult {
+    /** Whether this policy allows or denies the action */
+    verdict: PolicyVerdict;
+    /** Optional reason explaining the verdict */
+    reason?: string;
+    /** Optional metadata for downstream handling */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Merge multiple policy results.
+ * Deny wins over allow — if any policy denies, the merged result is deny.
+ */
+export declare function mergePolicyResults(results: PolicyResult[]): PolicyResult;
+/** Convenience factory — creates an allow result */
+export declare function allow(reason?: string): PolicyResult;
+/** Convenience factory — creates a deny result */
+export declare function deny(reason: string, metadata?: Record<string, unknown>): PolicyResult;

package/dist/domain/session/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Session state tracking interfaces.
+ * Tracks per-session token usage and idle state for hook coordination.
+ */
+export interface SessionTokenState {
+    /** Session identifier */
+    sessionId: string;
+    /** Total input tokens consumed in this session */
+    inputTokens: number;
+    /** Total output tokens consumed in this session */
+    outputTokens: number;
+    /** Timestamp of last activity */
+    lastActivityAt: Date;
+}
+export interface SessionIdleState {
+    /** Session identifier */
+    sessionId: string;
+    /** Whether the session is currently idle */
+    isIdle: boolean;
+    /** Last assistant message content, if any */
+    lastAssistantMessage?: string;
+    /** Last user message content, if any */
+    lastUserMessage?: string;
+}
+/**
+ * Owner of the execution lease — determines which system drives the session.
+ * Workflow takes precedence when both active.
+ */
+export type ExecutionLeaseOwner = "none" | "plan" | "workflow";
+export interface ExecutionLeaseSnapshot {
+    owner: ExecutionLeaseOwner;
+    hasActivePlan: boolean;
+    hasActiveWorkflow: boolean;
+    activePlanPaused: boolean;
+    activeWorkflowPaused: boolean;
+}
+/**
+ * Determine which system owns the current execution lease.
+ * Workflow takes precedence if both are active and running.
+ */
+export declare function determineExecutionOwner(snapshot: ExecutionLeaseSnapshot): ExecutionLeaseOwner;

package/dist/domain/workflows/index.d.ts

@@ -0,0 +1,4 @@
+export type { WorkflowRepository } from "./workflow-repository";
+export type { WorkflowService } from "./workflow-service";
+export type { WorkflowCompletion } from "./workflow-completion";
+export type { WorkflowContext } from "./workflow-context";

package/dist/domain/workflows/workflow-completion.d.ts

@@ -0,0 +1,9 @@
+import type { CompletionContext, CompletionCheckResult, CompletionMethod } from "../../features/workflow/types";
+/**
+ * Interface for step completion detection.
+ * Implementation lives in features/workflow/completion.
+ */
+export interface WorkflowCompletion {
+    /** Check if the current step is complete */
+    check(method: CompletionMethod, context: CompletionContext): CompletionCheckResult;
+}

package/dist/domain/workflows/workflow-context.d.ts

@@ -0,0 +1,9 @@
+import type { WorkflowInstance, WorkflowStepDefinition, WorkflowDefinition } from "../../features/workflow/types";
+/**
+ * Interface for workflow prompt composition.
+ * Implementation lives in features/workflow/context.
+ */
+export interface WorkflowContext {
+    /** Build the step prompt with variable substitution and context threading */
+    buildStepPrompt(instance: WorkflowInstance, stepDef: WorkflowStepDefinition, definition: WorkflowDefinition): string;
+}

package/dist/domain/workflows/workflow-repository.d.ts

@@ -0,0 +1,19 @@
+import type { WorkflowInstance } from "../../features/workflow/types";
+/**
+ * Repository interface for workflow instance persistence.
+ * Implementation lives in features/workflow/storage.
+ */
+export interface WorkflowRepository {
+    /** Save or update a workflow instance */
+    save(directory: string, instance: WorkflowInstance): boolean;
+    /** Load a workflow instance by ID */
+    load(directory: string, instanceId: string): WorkflowInstance | null;
+    /** Get the currently active workflow instance */
+    getActive(directory: string): WorkflowInstance | null;
+    /** Set the active instance pointer */
+    setActive(directory: string, instanceId: string): boolean;
+    /** Clear the active instance pointer */
+    clearActive(directory: string): boolean;
+    /** List all instance IDs */
+    list(directory: string): string[];
+}

package/dist/domain/workflows/workflow-service.d.ts

@@ -0,0 +1,32 @@
+import type { EngineAction, WorkflowDefinition } from "../../features/workflow/types";
+/**
+ * Service interface for workflow lifecycle operations.
+ * Implementation lives in features/workflow/engine.
+ */
+export interface WorkflowService {
+    /** Start a new workflow instance */
+    start(input: {
+        definition: WorkflowDefinition;
+        definitionPath: string;
+        goal: string;
+        sessionId: string;
+        directory: string;
+    }): EngineAction;
+    /** Check if current step is complete and advance if so */
+    checkAndAdvance(input: {
+        directory: string;
+        context: {
+            lastAssistantMessage?: string;
+            lastUserMessage?: string;
+            directory: string;
+        };
+    }): EngineAction;
+    /** Pause the active workflow */
+    pause(directory: string, reason?: string): boolean;
+    /** Resume the active workflow */
+    resume(directory: string): EngineAction;
+    /** Skip the current step */
+    skipStep(directory: string): EngineAction;
+    /** Abort the active workflow */
+    abort(directory: string): boolean;
+}

package/dist/features/skill-loader/discovery.d.ts

@@ -0,0 +1,36 @@
+import type { LoadedSkill } from "./types";
+interface SkillFrontmatter {
+    name?: string;
+    description?: string;
+    model?: string;
+    tools?: string | string[];
+}
+/**
+ * Parse YAML frontmatter from a SKILL.md file.
+ * Manual parsing — no external YAML dependency.
+ */
+export declare function parseFrontmatter(text: string): {
+    metadata: SkillFrontmatter;
+    content: string;
+};
+/**
+ * Load a single SKILL.md file as a LoadedSkill.
+ * Returns null if the file cannot be read or lacks a name.
+ */
+export declare function loadSkillFile(filePath: string, source: LoadedSkill["source"]): LoadedSkill | null;
+/**
+ * Recursively scan a directory for SKILL.md files.
+ */
+export declare function scanDirectory(dir: string, source: LoadedSkill["source"]): LoadedSkill[];
+export interface DiscoverSkillsOptions {
+    projectDirectory: string;
+    customDirs?: string[];
+}
+/**
+ * Discover skills from filesystem:
+ * 1. User skills: ~/.config/opencode/skills/
+ * 2. Project skills: {projectDirectory}/.opencode/skills/
+ * 3. Custom dirs from config (sandboxed via resolveSafePath)
+ */
+export declare function discoverSkillsFromDirs(options: DiscoverSkillsOptions): LoadedSkill[];
+export {};

package/dist/features/skill-loader/index.d.ts

@@ -0,0 +1,6 @@
+export type { LoadedSkill, SkillLoadResult } from "./types";
+export { loadSkills } from "./loader";
+export type { LoadSkillsOptions } from "./loader";
+export { createSkillResolver } from "./resolver";
+export { discoverSkillsFromDirs, scanDirectory, parseFrontmatter, loadSkillFile } from "./discovery";
+export { fetchSkillsFromApi } from "./opencode-client";

package/dist/features/skill-loader/loader.d.ts

@@ -0,0 +1,15 @@
+import type { SkillLoadResult } from "./types";
+export interface LoadSkillsOptions {
+    serverUrl?: URL | string;
+    projectDirectory: string;
+    customDirs?: string[];
+    disabledSkills?: string[];
+}
+/**
+ * Orchestrate skill loading:
+ * 1. Try OpenCode API (serverUrl/skill endpoint)
+ * 2. Fallback to filesystem discovery
+ * 3. Deduplicate by name (API wins)
+ * 4. Filter disabled skills
+ */
+export declare function loadSkills(options: LoadSkillsOptions): Promise<SkillLoadResult>;

package/dist/features/skill-loader/opencode-client.d.ts

@@ -0,0 +1,6 @@
+import type { LoadedSkill } from "./types";
+/**
+ * Fetch skills from the OpenCode server skill endpoint.
+ * Returns an empty array on any error (connection refused, timeout, etc.)
+ */
+export declare function fetchSkillsFromApi(serverUrl: URL | string, directory: string, timeoutMs?: number): Promise<LoadedSkill[]>;

package/dist/features/skill-loader/resolver.d.ts

@@ -0,0 +1,8 @@
+import type { SkillLoadResult } from "./types";
+import type { ResolveSkillsFn } from "../../agents/agent-builder";
+/**
+ * Create a skill resolver from a SkillLoadResult.
+ * Returns a ResolveSkillsFn closure that, when called with skill names
+ * and an optional disabled set, returns concatenated skill content.
+ */
+export declare function createSkillResolver(loadResult: SkillLoadResult): ResolveSkillsFn;

package/dist/features/skill-loader/types.d.ts

@@ -0,0 +1,14 @@
+export interface LoadedSkill {
+    name: string;
+    content: string;
+    source: "api" | "user" | "project" | "custom";
+    metadata?: {
+        description?: string;
+        model?: string;
+        tools?: string[];
+    };
+}
+export interface SkillLoadResult {
+    skills: LoadedSkill[];
+    errors: string[];
+}

package/dist/features/work-state/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const STATE_DIR = ".lead";
+export declare const STATE_FILE = ".lead/state.json";
+/** Directory for ad-hoc plans (no ticket linked) */
+export declare const ADHOC_DIR = ".lead/_adhoc";

package/dist/features/work-state/index.d.ts

@@ -0,0 +1,5 @@
+export type { WorkState, PlanProgress } from "./types";
+export type { PlanValidationResult, PlanValidationIssue } from "./validation-types";
+export { readWorkState, writeWorkState, clearWorkState, getPlanProgress } from "./storage";
+export { validatePlanFile } from "./validation";
+export { STATE_DIR, STATE_FILE, ADHOC_DIR } from "./constants";

package/dist/features/work-state/storage.d.ts

@@ -0,0 +1,20 @@
+import type { WorkState, PlanProgress } from "./types";
+/**
+ * Read the active work state from .lead/state.json.
+ * Returns null if the file does not exist or cannot be parsed.
+ */
+export declare function readWorkState(dir: string): WorkState | null;
+/**
+ * Write work state to .lead/state.json.
+ * Creates the directory if it does not exist.
+ */
+export declare function writeWorkState(dir: string, state: WorkState): void;
+/**
+ * Remove the active work state file.
+ */
+export declare function clearWorkState(dir: string): void;
+/**
+ * Count plan checkboxes in a markdown plan file.
+ * Returns PlanProgress with total, completed, and isComplete.
+ */
+export declare function getPlanProgress(planPath: string): PlanProgress;

package/dist/features/work-state/types.d.ts

@@ -0,0 +1,16 @@
+export interface WorkState {
+    active_plan: string;
+    started_at: string;
+    session_ids: string[];
+    plan_name: string;
+    agent?: string;
+    start_sha?: string;
+    paused?: boolean;
+    continuation_completed_snapshot?: number;
+    stale_continuation_count?: number;
+}
+export interface PlanProgress {
+    total: number;
+    completed: number;
+    isComplete: boolean;
+}

package/dist/features/work-state/validation-types.d.ts

@@ -0,0 +1,8 @@
+export interface PlanValidationResult {
+    valid: boolean;
+    issues: PlanValidationIssue[];
+}
+export interface PlanValidationIssue {
+    severity: "error" | "warning";
+    message: string;
+}

package/dist/features/work-state/validation.d.ts

@@ -0,0 +1,6 @@
+import type { PlanValidationResult } from "./validation-types";
+/**
+ * Validate a plan markdown file.
+ * Checks for required sections and at least one checkbox.
+ */
+export declare function validatePlanFile(path: string): PlanValidationResult;

package/dist/features/workflow/commands.d.ts

@@ -0,0 +1,10 @@
+import type { EngineAction } from "./types";
+export interface WorkflowCommandResult {
+    message: string;
+    action?: EngineAction;
+}
+/**
+ * Parse and execute workflow subcommands.
+ * Supported: status, pause, resume, skip [stepId], abort
+ */
+export declare function executeWorkflowCommand(command: string, directory: string, customDirs?: string[]): WorkflowCommandResult;

package/dist/features/workflow/completion.d.ts

@@ -0,0 +1,5 @@
+import type { CompletionContext, CompletionCheckResult, CompletionMethod } from "./types";
+/**
+ * Check if the current workflow step is complete based on its completion method.
+ */
+export declare function checkStepCompletion(method: CompletionMethod, ctx: CompletionContext): CompletionCheckResult;

package/dist/features/workflow/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const WORKFLOW_STATE_DIR = ".lead/workflows";
+export declare const ACTIVE_INSTANCE_FILE = ".lead/workflows/active-instance.json";
+export declare const WORKFLOW_DIRS: {
+    project: string;
+    user: string;
+};
+export declare const WORKFLOW_CONTINUATION_MARKER = "<!-- lead:workflow-continuation -->";
+export declare const WORKFLOW_STEP_COMPLETE_SIGNAL = "<!-- workflow:step-complete -->";