agent-afk 5.1.0 → 5.3.0

package/dist/paths.d.ts

@@ -0,0 +1,57 @@
+export declare function getAfkHome(): string;
+export declare function getSdkHomeDir(): string;
+export declare function getAgentFrameworkDir(): string;
+export declare function getTelemetryPath(): string;
+export declare function getSdkSchemaViolationsPath(): string;
+export declare function getBriefsDir(): string;
+export declare function getFacetCacheDir(): string;
+export declare function getSkillsDir(): string;
+export declare function getPluginsDir(): string;
+export declare function getProjectAfkDir(): string;
+export declare function getProjectSkillsDir(): string;
+export declare function getProjectPluginsDir(): string;
+export declare function getProjectPlansDir(cwd?: string): string;
+export declare function getPluginsIndexPath(): string;
+export declare function getSchedulesPath(): string;
+export declare function getMarketplaceCacheDir(): string;
+export declare function getMarketplaceDir(name: string): string;
+export declare function getBundledPluginsDir(): string;
+export declare function getAfkConfigDir(): string;
+export declare function getAfkStateDir(): string;
+export declare function getAfkCacheDir(): string;
+export declare function getLogsDir(): string;
+export declare function getSessionsDir(): string;
+export declare function getPresenceDir(): string;
+export declare function getTodosDir(): string;
+export declare function getTranscriptsDir(): string;
+export declare function getMemoryDir(): string;
+export declare function getQueueDir(): string;
+export declare function getSessionGrantsPath(): string;
+export declare function getPermissionsStorePath(): string;
+export declare function getFarmsDir(): string;
+export declare function getFarmDir(taskSlug: string): string;
+export declare function validateSessionId(sessionId: string): void;
+export declare function getTraceDir(sessionId: string): string;
+export declare function getReceiptsDir(): string;
+export declare function getDaemonStateDir(instanceId?: string): string;
+export declare function getWorktreeSweepLockPath(): string;
+export declare function getEnvConfigPath(): string;
+export declare function getJsonConfigPath(): string;
+export declare function getSettingsPath(): string;
+export declare function getProjectSettingsPath(cwd?: string): string;
+export declare function getLegacyEnvConfigPath(): string;
+export declare function getLegacyJsonConfigPath(): string;
+export declare function ensureSessionsMigrated(): void;
+export declare function ensureTodosMigrated(): void;
+export declare function ensureTranscriptsMigrated(): void;
+export declare function getReplHistoryPath(): string;
+export declare function assertSafeJobId(jobId: string): void;
+export declare function getBgJobsRoot(): string;
+export declare function getBgJobDir(jobId: string): string;
+export declare function getBgJobLog(jobId: string): string;
+export declare function getBgJobMeta(jobId: string): string;
+export declare function isSafeLedgerSessionId(sessionId: string): boolean;
+export declare function getSessionLedgerDir(sessionId: string): string;
+export declare function getSessionLedgerPath(sessionId: string): string;
+export declare function getSessionKeyPath(sessionId: string): string;
+export declare function getOauthPendingPath(): string;

package/dist/service/launchd/install.d.ts

@@ -0,0 +1,35 @@
+import { type ServiceName } from './paths.js';
+export type InstallResult = {
+    kind: 'installed';
+    plistPath: string;
+    label: string;
+    watchPathsActive: boolean;
+} | {
+    kind: 'already-installed';
+    plistPath: string;
+    label: string;
+} | {
+    kind: 'failed';
+    reason: string;
+};
+export type UninstallResult = {
+    kind: 'uninstalled';
+    plistPath: string;
+} | {
+    kind: 'not-installed';
+    plistPath: string;
+} | {
+    kind: 'failed';
+    reason: string;
+};
+export interface InstallOptions {
+    noWatch?: boolean;
+    skipBootstrap?: boolean;
+    environment?: Record<string, string>;
+    _entrypointExistsCheck?: (p: string) => boolean;
+}
+export declare function installService(name: ServiceName, opts?: InstallOptions): InstallResult;
+export declare function uninstallService(name: ServiceName, opts?: {
+    skipBootout?: boolean;
+}): UninstallResult;
+export declare function readPlistFile(name: ServiceName): string | undefined;

package/dist/service/launchd/paths.d.ts

@@ -0,0 +1,8 @@
+export type ServiceName = 'telegram' | 'daemon';
+export declare const SERVICE_NAMES: readonly ServiceName[];
+export declare function labelFor(name: ServiceName): string;
+export declare function launchAgentsDir(home?: string): string;
+export declare function plistPath(name: ServiceName, home?: string): string;
+export declare function serviceLogPath(name: ServiceName): string;
+export declare function guiDomain(): string;
+export declare const LAUNCHCTL_TIMEOUT_MS = 8000;

package/dist/service/launchd/plist.d.ts

@@ -0,0 +1,15 @@
+import { type ServiceName } from './paths.js';
+export interface PlistOptions {
+    label: string;
+    programArguments: string[];
+    workingDirectory: string;
+    standardOutPath: string;
+    standardErrorPath: string;
+    watchPaths?: string[];
+    environmentVariables?: Record<string, string>;
+}
+export declare function renderPlist(opts: PlistOptions): string;
+export declare function resolveServicePath(execPath?: string): string;
+export declare function resolveAfkBinary(candidates?: string[], existsCheck?: (p: string) => boolean, whichRunner?: () => string | undefined, realpathFn?: (p: string) => string): string;
+export declare function resolveProgramArguments(name: ServiceName, existsCheck?: (p: string) => boolean): string[];
+export declare function resolveWatchPaths(name: ServiceName, existsCheck?: (p: string) => boolean): string[] | undefined;

package/dist/service/launchd/status.d.ts

@@ -0,0 +1,15 @@
+import { type ServiceName } from './paths.js';
+export interface ServiceStatusSnapshot {
+    name: ServiceName;
+    label: string;
+    installed: boolean;
+    plistPath: string;
+    pid?: number;
+    lastExitStatus?: number;
+    logFile: string;
+}
+export declare function parseLaunchctlListRow(table: string, label: string): {
+    pid?: number;
+    lastExitStatus?: number;
+} | undefined;
+export declare function serviceStatus(name: ServiceName): ServiceStatusSnapshot;

package/dist/service/launchd.d.ts

@@ -0,0 +1,4 @@
+export * from './launchd/paths.js';
+export * from './launchd/plist.js';
+export * from './launchd/status.js';
+export * from './launchd/install.js';

package/dist/skills/_agents/contract.d.ts

@@ -0,0 +1,5 @@
+export declare const contract: {
+    name: "contract";
+    systemPrompt: string;
+    sourcePath: string;
+};

package/dist/skills/_agents/git-investigator.d.ts

@@ -0,0 +1,8 @@
+export declare const gitInvestigator: {
+    name: "git-investigator";
+    systemPrompt: string;
+    sourcePath: string;
+    allowedTools: readonly ["Bash", "Read", "Grep", "Glob"];
+    description: string;
+    model: "sonnet";
+};

package/dist/skills/_agents/index.d.ts

@@ -0,0 +1,4 @@
+export { researchAgent } from './research-agent.js';
+export { contract } from './contract.js';
+export { gitInvestigator } from './git-investigator.js';
+export { toAgentDefinition } from './to-definition.js';

package/dist/skills/_agents/research-agent.d.ts

@@ -0,0 +1,7 @@
+export declare const researchAgent: {
+    name: "research-agent";
+    systemPrompt: string;
+    sourcePath: string;
+    allowedTools: readonly ["Read", "Grep", "Glob", "WebFetch", "WebSearch"];
+    description: string;
+};

package/dist/skills/_agents/to-definition.d.ts

@@ -0,0 +1,7 @@
+import type { AgentDefinition } from '../../agent/types/sdk-types.js';
+export declare function toAgentDefinition(agent: {
+    systemPrompt: string;
+    description: string;
+    allowedTools?: readonly string[];
+    model?: string;
+}): AgentDefinition;

package/dist/skills/_lib/confidence-gate.d.ts

@@ -0,0 +1,10 @@
+export interface GateInput {
+    confidence: number;
+    coverage_gaps?: string[];
+    boundary_flag?: string;
+}
+export interface GateDecision {
+    verify: boolean;
+    reason: string;
+}
+export declare function shouldAutoVerify(input: GateInput): GateDecision;

package/dist/skills/_lib/emit-card.d.ts

@@ -0,0 +1,3 @@
+import type { CardSpec } from '../../cli/render.js';
+export declare function emitCard(spec: CardSpec): void;
+export type { CardKind, CardSpec } from '../../cli/render.js';

package/dist/skills/_lib/prompt-loader.d.ts

@@ -0,0 +1 @@
+export declare function loadSkillPrompts(name: string): Record<string, string>;

package/dist/skills/all.d.ts

@@ -0,0 +1,7 @@
+import './audit-fit/index.js';
+import './diagnose/index.js';
+import './get-started/index.js';
+import './mint/index.js';
+import './service-setup/index.js';
+import './telegram-setup/index.js';
+export { scanAndRegisterUserSkills, scanSkillsFromDir } from './user-skills.js';

package/dist/skills/audit-fit/discover.d.ts

@@ -0,0 +1,16 @@
+export type ArtifactType = 'skill' | 'command' | 'agent';
+export interface DiscoveredArtifact {
+    path: string;
+    type: ArtifactType;
+    source: 'user' | 'plugin';
+    plugin_key?: string;
+}
+export declare function discoverUserScope(afkHome?: string): DiscoveredArtifact[];
+export declare function discoverPluginScope(pluginsRoot?: string): DiscoveredArtifact[];
+export interface DiscoveredHook {
+    event: string;
+    index: number;
+    raw: unknown;
+}
+export declare function discoverHooks(settingsPath?: string): DiscoveredHook[];
+export declare function discoverHookCount(settingsPath?: string): number;

package/dist/skills/audit-fit/index.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { type SkillMetadata } from '../index.js';
+import type { SubagentResult } from '../../agent/subagent/result.js';
+import { type DiscoveredHook } from './discover.js';
+export declare const VerdictSchema: z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodEnum<{
+        agent: "agent";
+        skill: "skill";
+        command: "command";
+        hook: "hook";
+    }>;
+    source: z.ZodEnum<{
+        user: "user";
+        plugin: "plugin";
+    }>;
+    plugin_key: z.ZodOptional<z.ZodString>;
+    verdict: z.ZodEnum<{
+        correct: "correct";
+        misfit: "misfit";
+        outlier: "outlier";
+    }>;
+    recommended_type: z.ZodString;
+    rationale: z.ZodString;
+    confidence: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        med: "med";
+    }>;
+}, z.core.$strip>;
+export type Verdict = z.infer<typeof VerdictSchema>;
+export declare const InventoryMatrixSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+export type InventoryMatrix = z.infer<typeof InventoryMatrixSchema>;
+export declare const AuditFitResultSchema: z.ZodObject<{
+    inventory: z.ZodObject<{
+        user: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        plugin: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>;
+    misfits: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+            command: "command";
+            hook: "hook";
+        }>;
+        source: z.ZodEnum<{
+            user: "user";
+            plugin: "plugin";
+        }>;
+        plugin_key: z.ZodOptional<z.ZodString>;
+        verdict: z.ZodEnum<{
+            correct: "correct";
+            misfit: "misfit";
+            outlier: "outlier";
+        }>;
+        recommended_type: z.ZodString;
+        rationale: z.ZodString;
+        confidence: z.ZodEnum<{
+            low: "low";
+            high: "high";
+            med: "med";
+        }>;
+    }, z.core.$strip>>;
+    briefs_written: z.ZodNumber;
+    total_artifacts: z.ZodNumber;
+}, z.core.$strip>;
+export type AuditFitResult = z.infer<typeof AuditFitResultSchema>;
+export declare const AuditFitInputSchema: z.ZodObject<{
+    writeBriefs: z.ZodOptional<z.ZodBoolean>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        all: "all";
+        plugin: "plugin";
+    }>>;
+}, z.core.$strip>;
+export type AuditFitInput = z.infer<typeof AuditFitInputSchema>;
+type Scope = 'user' | 'plugin' | 'all';
+type FullArtifactType = 'skill' | 'command' | 'agent' | 'hook';
+export declare function planAuditScope(scope: Scope): {
+    runUserDiscovery: boolean;
+    runPluginDiscovery: boolean;
+    runHookInspector: boolean;
+};
+export declare function aggregateVerdicts(verdicts: ReadonlyArray<Verdict>): {
+    inventory: AuditFitResult['inventory'];
+    misfits: Verdict[];
+};
+export declare function shouldWriteBriefForMisfit(m: Verdict): boolean;
+export declare function renderHookList(settingsPath: string, hooks: ReadonlyArray<DiscoveredHook>): string;
+export type InspectorOutcome = {
+    kind: 'failure';
+    message: string;
+} | {
+    kind: 'success';
+    output: ReadonlyArray<Verdict>;
+};
+export declare function classifyInspectorResult(type: FullArtifactType, result: SubagentResult<ReadonlyArray<Verdict>> | undefined): InspectorOutcome;
+export declare const auditFitSkill: SkillMetadata;
+export {};

package/dist/skills/diagnose/_phases/orchestrator.d.ts

@@ -0,0 +1,4 @@
+import type { SkillExecutionContext } from '../../index.js';
+import type { IAgentSession } from '../../../agent/types.js';
+import type { DiagnosisResult } from './types.js';
+export declare function handler(input: unknown, parentSession?: IAgentSession, ctx?: SkillExecutionContext): Promise<DiagnosisResult>;

package/dist/skills/diagnose/_phases/triage.d.ts

@@ -0,0 +1,4 @@
+import type { Hypothesis, VerificationResult, DiagnosisOutcome, Triage } from './types.js';
+export declare function classifyAndExtract(failure: string, context: string): Triage;
+export declare function fixSpansMultipleFiles(hypothesis: Hypothesis): boolean;
+export declare function computeOutcome(hypotheses: Hypothesis[], verificationResults: VerificationResult[]): DiagnosisOutcome;

package/dist/skills/diagnose/_phases/types.d.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+export interface Verification {
+    claim: string;
+    verdict: 'VERIFIED' | 'REFUTED' | 'INCONCLUSIVE';
+    evidence: string;
+}
+export declare const HypothesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    claim: z.ZodString;
+    confidence: z.ZodNumber;
+    evidence_sources: z.ZodArray<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    proposed_fix: z.ZodOptional<z.ZodString>;
+    coverage_gaps: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | null | undefined>>;
+    boundary_flag: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+}, z.core.$strip>;
+export type Hypothesis = z.infer<typeof HypothesisSchema>;
+export declare const PremiseVerificationSchema: z.ZodObject<{
+    hypothesis_id: z.ZodString;
+    claim: z.ZodString;
+    verdict: z.ZodEnum<{
+        VERIFIED: "VERIFIED";
+        REFUTED: "REFUTED";
+        INCONCLUSIVE: "INCONCLUSIVE";
+    }>;
+    evidence: z.ZodString;
+    gate_reason: z.ZodString;
+}, z.core.$strip>;
+export type PremiseVerification = z.infer<typeof PremiseVerificationSchema>;
+export declare const VerificationResultSchema: z.ZodObject<{
+    hypothesis_id: z.ZodString;
+    predicted_pass: z.ZodBoolean;
+    regressions: z.ZodArray<z.ZodString>;
+    confidence: z.ZodNumber;
+    verification_log: z.ZodString;
+}, z.core.$strip>;
+export type VerificationResult = z.infer<typeof VerificationResultSchema>;
+export declare const FailureTypeSchema: z.ZodEnum<{
+    unknown: "unknown";
+    crash: "crash";
+    regression: "regression";
+    "logic-error": "logic-error";
+    flaky: "flaky";
+    environment: "environment";
+}>;
+export type FailureType = z.infer<typeof FailureTypeSchema>;
+export declare const TriageSchema: z.ZodObject<{
+    failure_type: z.ZodEnum<{
+        unknown: "unknown";
+        crash: "crash";
+        regression: "regression";
+        "logic-error": "logic-error";
+        flaky: "flaky";
+        environment: "environment";
+    }>;
+    error_signature: z.ZodString;
+    affected_area: z.ZodString;
+}, z.core.$strip>;
+export type Triage = z.infer<typeof TriageSchema>;
+export declare const DiagnosisOutcomeSchema: z.ZodEnum<{
+    dissent: "dissent";
+    clear_winner: "clear_winner";
+    multiple_plausible: "multiple_plausible";
+    all_inconclusive: "all_inconclusive";
+    no_hypotheses: "no_hypotheses";
+}>;
+export type DiagnosisOutcome = z.infer<typeof DiagnosisOutcomeSchema>;
+export declare const DiagnosisResultSchema: z.ZodObject<{
+    reproducer: z.ZodOptional<z.ZodString>;
+    triage: z.ZodOptional<z.ZodObject<{
+        failure_type: z.ZodEnum<{
+            unknown: "unknown";
+            crash: "crash";
+            regression: "regression";
+            "logic-error": "logic-error";
+            flaky: "flaky";
+            environment: "environment";
+        }>;
+        error_signature: z.ZodString;
+        affected_area: z.ZodString;
+    }, z.core.$strip>>;
+    hypotheses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        claim: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence_sources: z.ZodArray<z.ZodString>;
+        location: z.ZodOptional<z.ZodString>;
+        proposed_fix: z.ZodOptional<z.ZodString>;
+        coverage_gaps: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | null | undefined>>;
+        boundary_flag: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    }, z.core.$strip>>;
+    premise_verifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        hypothesis_id: z.ZodString;
+        claim: z.ZodString;
+        verdict: z.ZodEnum<{
+            VERIFIED: "VERIFIED";
+            REFUTED: "REFUTED";
+            INCONCLUSIVE: "INCONCLUSIVE";
+        }>;
+        evidence: z.ZodString;
+        gate_reason: z.ZodString;
+    }, z.core.$strip>>>;
+    winner: z.ZodOptional<z.ZodObject<{
+        hypothesis_id: z.ZodString;
+        verification_log: z.ZodString;
+        proposed_fix: z.ZodString;
+    }, z.core.$strip>>;
+    verification_results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        hypothesis_id: z.ZodString;
+        predicted_pass: z.ZodBoolean;
+        regressions: z.ZodArray<z.ZodString>;
+        confidence: z.ZodNumber;
+        verification_log: z.ZodString;
+    }, z.core.$strip>>>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        dissent: "dissent";
+        clear_winner: "clear_winner";
+        multiple_plausible: "multiple_plausible";
+        all_inconclusive: "all_inconclusive";
+        no_hypotheses: "no_hypotheses";
+    }>>;
+    recommended_next_skill: z.ZodOptional<z.ZodEnum<{
+        spec: "spec";
+    }>>;
+}, z.core.$strip>;
+export type DiagnosisResult = z.infer<typeof DiagnosisResultSchema>;
+export type VerifyBatchFn = (claims: string[]) => Promise<Verification[]>;
+export declare const ShadowVerifyEnvelopeSchema: z.ZodObject<{
+    verifications: z.ZodArray<z.ZodObject<{
+        claim: z.ZodOptional<z.ZodString>;
+        verdict: z.ZodString;
+        evidence: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface BaselineResult {
+    skipped: boolean;
+    reason?: string;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}

package/dist/skills/diagnose/_phases/verifier.d.ts

@@ -0,0 +1,16 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import type { Verification, Hypothesis, PremiseVerification, VerifyBatchFn, BaselineResult } from './types.js';
+declare const execFile: typeof execFileCallback.__promisify__;
+export declare function parseShadowVerifyOutput(raw: string): Verification[];
+export declare function runReproducerBaseline(command: string, cwd: string, exec?: typeof execFile): Promise<BaselineResult>;
+export declare function buildVerifierUserPrompt(hypothesis: {
+    id: string;
+    claim: string;
+    location?: string;
+    proposed_fix?: string;
+}, reproducer: string, worktreePath: string, baseline: BaselineResult): string;
+export declare function autoVerifyHypotheses(hypotheses: Hypothesis[], verify: VerifyBatchFn): Promise<{
+    premise_verifications: PremiseVerification[];
+    hypotheses_to_test: Hypothesis[];
+}>;
+export {};

package/dist/skills/diagnose/index.d.ts

@@ -0,0 +1,6 @@
+export type { Verification, Hypothesis, PremiseVerification, VerificationResult, DiagnosisResult, VerifyBatchFn, BaselineResult, FailureType, Triage, DiagnosisOutcome, } from './_phases/types.js';
+export { HypothesisSchema, PremiseVerificationSchema, VerificationResultSchema, FailureTypeSchema, TriageSchema, DiagnosisOutcomeSchema, DiagnosisResultSchema, } from './_phases/types.js';
+export { classifyAndExtract, fixSpansMultipleFiles, computeOutcome } from './_phases/triage.js';
+export { parseShadowVerifyOutput, runReproducerBaseline, buildVerifierUserPrompt, autoVerifyHypotheses, } from './_phases/verifier.js';
+import { type SkillMetadata } from '../index.js';
+export declare const diagnoseSkill: SkillMetadata;

package/dist/skills/example-template/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/skills/get-started/index.d.ts

@@ -0,0 +1,2 @@
+import { type SkillMetadata } from '../index.js';
+export declare const getStartedSkill: SkillMetadata;

package/dist/skills/index.d.ts

@@ -0,0 +1,28 @@
+import type { AgentModelInput, IAgentSession } from '../agent/types.js';
+export interface SkillExecutionContext {
+    apiKey?: string;
+    defaultModel?: AgentModelInput;
+    defaultSubagentModel?: AgentModelInput;
+    callId?: string;
+    dispatchSkill?: (name: string, args?: string) => Promise<string>;
+}
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    handler: (input: unknown, parentSession?: IAgentSession, ctx?: SkillExecutionContext) => Promise<unknown>;
+    argumentHint?: string;
+    whenToUse?: string;
+    model?: string;
+    context?: 'inline' | 'fork' | 'load';
+    loadBody?: string;
+    origin?: 'builtin' | 'user' | 'project' | `imported:${string}`;
+    flags?: readonly string[];
+    readOnly?: boolean;
+    audience?: 'public' | 'internal';
+}
+export declare function isSkillVisible(skill: Pick<SkillMetadata, 'audience'>, internalUnlocked: boolean): boolean;
+export declare function registerSkill(meta: SkillMetadata): void;
+export declare function getSkill(name: string): SkillMetadata;
+export declare function listSkills(): string[];
+export declare function listVisibleSkills(internalUnlocked: boolean): string[];
+export declare function _resetRegistry(): void;

package/dist/skills/mint/_phases/build.d.ts

@@ -0,0 +1,7 @@
+import type { AgentModelInput } from '../../../agent/types.js';
+export interface BuildResult {
+    filesChanged: string[];
+    testsPassed: boolean;
+    notes: string;
+}
+export declare function runBuildPhase(plan: string, orchestrationPlan: unknown, parentSessionId: string, parentCwd?: string, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<BuildResult>;

package/dist/skills/mint/_phases/heal.d.ts

@@ -0,0 +1,8 @@
+import type { AgentModelInput, IAgentSession } from '../../../agent/types.js';
+import type { VerifyResult } from './verify.js';
+import type { BuildResult } from './build.js';
+export declare function runHealPhase(plan: string, buildResults: BuildResult, verifyResults: VerifyResult, healIterations: number, parentSession: IAgentSession, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<{
+    healed: boolean;
+    newHealIterations: number;
+    newVerifyResults: VerifyResult;
+}>;

package/dist/skills/mint/_phases/parallelize-dispatch.d.ts

@@ -0,0 +1,12 @@
+import type { AgentModelInput, IAgentSession } from '../../../agent/types.js';
+export type ParallelizeDispatchResult = {
+    kind: 'skipped';
+    reason: 'too-few-files' | 'skill-body-missing';
+} | {
+    kind: 'plan';
+    plan: unknown;
+} | {
+    kind: 'failed';
+    error: string;
+};
+export declare function runParallelizeDispatch(plan: string, parentSession: IAgentSession, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<ParallelizeDispatchResult>;

package/dist/skills/mint/_phases/plan.d.ts

@@ -0,0 +1,2 @@
+import type { AgentModelInput } from '../../../agent/types.js';
+export declare function runPlanPhase(spec: string, research: string, parentSessionId: string, parentCwd?: string, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<string>;

package/dist/skills/mint/_phases/research.d.ts

@@ -0,0 +1,2 @@
+import type { AgentModelInput } from '../../../agent/types.js';
+export declare function runResearchPhase(spec: string, parentSessionId: string, parentCwd?: string, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<string>;

package/dist/skills/mint/_phases/ship.d.ts

@@ -0,0 +1,3 @@
+import type { AgentModelInput } from '../../../agent/types.js';
+import type { MintState } from '../index.js';
+export declare function runShipPhase(state: MintState, parentSessionId: string, parentCwd?: string, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<string>;

package/dist/skills/mint/_phases/spec.d.ts

@@ -0,0 +1,2 @@
+import type { AgentModelInput } from '../../../agent/types.js';
+export declare function runSpecPhase(idea: string, parentSessionId: string, parentCwd?: string, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<string>;

package/dist/skills/mint/_phases/verify.d.ts

@@ -0,0 +1,9 @@
+import type { BuildResult } from './build.js';
+import type { AgentModelInput } from '../../../agent/types.js';
+export interface VerifyResult {
+    testsPassed: boolean;
+    lintPassed: boolean;
+    designReviewPassed: boolean;
+    issues?: string[];
+}
+export declare function runVerifyPhase(plan: string, buildResults: BuildResult, parentSessionId: string, parentCwd?: string, skillCallId?: string, defaultSubagentModel?: AgentModelInput): Promise<VerifyResult>;

package/dist/skills/mint/index.d.ts

@@ -0,0 +1,47 @@
+import { type SkillMetadata } from '../index.js';
+import { type BuildResult } from './_phases/build.js';
+import { type VerifyResult } from './_phases/verify.js';
+type MintPhase = 'spec' | 'research' | 'plan' | 'parallelize' | 'build' | 'verify' | 'heal' | 'ship';
+interface HistoryEntry {
+    phase: MintPhase;
+    output: string;
+    timestamp: number;
+}
+export interface MintState {
+    currentPhase: MintPhase;
+    idea: string;
+    spec?: string;
+    research?: string;
+    plan?: string;
+    waveOrchestrationPlan?: unknown;
+    buildResults?: BuildResult;
+    verifyResults?: VerifyResult;
+    healIterations: number;
+    history: HistoryEntry[];
+}
+export type MintResult = {
+    paused: true;
+    phase: 'spec';
+    spec: string;
+    state: MintState;
+    nextStep: string;
+} | {
+    paused: true;
+    phase: 'heal-failed';
+    reason: string;
+    state: MintState;
+    nextStep: string;
+} | {
+    completed: true;
+    artifact: string;
+    state: MintState;
+};
+export interface MintInput {
+    idea?: string;
+    autoApprove?: boolean;
+    repoPath?: string;
+    resumeFrom?: MintState;
+    userApproved?: boolean;
+}
+declare const mintSkill: SkillMetadata;
+export { mintSkill };