import { CHAT_EVENTS_SLOT, MemoryRecord, MemoryService, PreStepDecision, ReviewSnapshot, RpcResult, SELF_IMPROVEMENT_RPC_CHANNEL, SelfImprovementSettings, SessionWatermark, SkillRecord } from "./contracts.js";
import { LlmTextCaller } from "@klarkxy/dsh-plugin-kit";
import { Context } from "@deepseek-ai/cordis";
//#region src/detect.d.ts
interface SessionEventLike {
  type: string;
  seq: number;
  data: unknown;
}
//#endregion
//#region src/engine.d.ts
interface KvTableLike<V> {
  get(key: string): V | undefined;
  entries(): IterableIterator<[string, V]>;
  put(key: string, value: V): Promise<void>;
}
interface SessionLike {
  id?: unknown;
  header?: {
    cwd?: string;
    parentSession?: unknown;
    origin?: unknown;
    delegationDepth?: unknown;
  };
  meta?: {
    cwd?: string;
  };
  snapshotEvents(): readonly SessionEventLike[];
}
interface EngineOptions {
  memory: () => MemoryService | undefined;
  llm?: LlmTextCaller;
  host?: unknown;
  sessionOf: (sessionId: string) => SessionLike | undefined;
  skills: KvTableLike<SkillRecord>;
  watermarks: KvTableLike<SessionWatermark>;
  /** Plugin-page settings row; absent keeps the shared purpose route. */
  settings?: KvTableLike<SelfImprovementSettings>;
  now?: () => number;
}
declare class SelfImprovementEngine {
  private readonly options;
  private generation;
  private active;
  private lifetime;
  private storageFailed;
  private chain;
  private readonly extractJobs;
  private seenProjects;
  private settings;
  private settingsPending;
  private readonly now;
  constructor(options: EngineOptions);
  getSettings(): SelfImprovementSettings;
  /** Empty saved route means no override at all. */
  private modelOverride;
  updateSettings(model: SelfImprovementSettings['model'], expectedRevision: number): Promise<SelfImprovementSettings>;
  getGeneration(): number;
  isActive(): boolean;
  dispose(): void;
  private memoryOrError;
  private asMemory;
  private requireActive;
  private persist;
  private currentSignal;
  private rememberProject;
  private knownProjectIds;
  private sameMemory;
  private beginWork;
  private isWork;
  /** Linearize disable/replace against captured generation + Memory. Never start a new write after this fails. */
  private revalidate;
  private failed;
  private mutationGuards;
  private isGuardRejection;
  /** Invoke a Memory/Skill write only while still current. Queued Memory work receives captured generation/identity + lifetime abort. An already-started write is not rolled back; the RPC still fails if we are no longer current after it. */
  private mutateWhileCurrent;
  private rejectionOrThrow;
  listAllLessons(projectId?: string, expectedMemory?: MemoryService): Promise<MemoryRecord[]>;
  currentRequestText(session: SessionLike, decision?: PreStepDecision): string;
  recordsForInjection(projectId: string | undefined, requestText: string, expectedMemory?: MemoryService): Promise<MemoryRecord[]>;
  applyPreStep(session: SessionLike, decision: PreStepDecision, signal: AbortSignal): Promise<PreStepDecision>;
  private writeWatermark;
  private draftTrigger;
  private noteExtractStart;
  private noteExtractEnd;
  private isExtracting;
  private enqueue;
  /** Queue auto and manual extract on the existing chain. Counts rise synchronously at request entry. */
  private enqueueExtract;
  extractFromSession(session: SessionLike, signal: AbortSignal, mode?: 'auto' | 'manual'): Promise<RpcResult<{
    created: MemoryRecord[];
    skipped: number;
  }>>;
  considerSession(session: SessionLike, signal: AbortSignal): Promise<void>;
  private runExtractFromSession;
  private requireLesson;
  acceptLesson(id: string, expectedRevision: number, scope: 'project' | 'global', currentProjectId?: string): Promise<RpcResult<MemoryRecord>>;
  setLessonStatus(id: string, expectedRevision: number, status: 'rejected' | 'revoked', extraProjectId?: string): Promise<RpcResult<MemoryRecord>>;
  private skills;
  private liveSkillLessons;
  previewSkill(lessonIds: string[]): Promise<RpcResult<SkillRecord>>;
  private skillOrError;
  private requireCurrentSkillSources;
  patchSkill(id: string, expectedRevision: number, patch: (current: SkillRecord) => SkillRecord): Promise<RpcResult<SkillRecord>>;
  private changeSkill;
  acceptSkill(id: string, expectedRevision: number): Promise<RpcResult<SkillRecord>>;
  prepareSkillExport(id: string, expectedRevision: number): Promise<RpcResult<{
    filename: string;
    markdown: string;
    skill: SkillRecord;
  }>>;
  recordSkillExport(id: string, expectedRevision: number, filename: string): Promise<RpcResult<SkillRecord>>;
  snapshot(sessionId?: string): Promise<RpcResult<ReviewSnapshot>>;
  call(endpoint: string, payload: unknown, signal: AbortSignal): Promise<RpcResult>;
}
//#endregion
//#region src/index.d.ts
declare const name = "@klarkxy/dsh-self-improvement";
declare const inject: readonly ["storageDomain", "connection", "webServer", "llm"];
declare module '@deepseek-ai/cordis' {
  interface Context {
    selfImprovement: SelfImprovementEngine;
  }
}
declare function listen(ctx: Context, name: string, handler: (...args: never[]) => unknown): (() => void) | undefined;
declare function apply(ctx: Context): Promise<void>;
//#endregion
export { CHAT_EVENTS_SLOT, SELF_IMPROVEMENT_RPC_CHANNEL, SelfImprovementEngine, apply, inject, listen, name };
//# sourceMappingURL=index.d.ts.map