agenr 2.0.1 → 3.0.0

package/dist/adapters/skeln/index.d.ts

@@ -0,0 +1,1951 @@
+import { ExtensionContext, ExtensionAPI } from 'skeln';
+import { C as ClaimSlotPolicyConfig, a as ClaimSlotPolicy } from '../../claim-slot-policy-CdrW_1l4.js';
+import { E as EntryType, b as RecallPorts, r as ProcedureDatabasePort, t as Entry, u as DatabasePort, v as EpisodeDatabasePort, w as EmbeddingPort, L as LlmPort } from '../../ports-CpzWESmZ.js';
+import { AgentMessage } from '@earendil-works/pi-agent-core';
+
+/**
+ * Canonical feature flags for staged working-memory, session-memory, and goal rollout.
+ */
+/**
+ * Feature-flag keys supported across agenr config and app services.
+ */
+declare const AGENR_FEATURE_FLAG_KEYS: readonly ["workingMemory", "sessionTreeLineage", "sessionTreeCompaction", "goalContinuation"];
+/**
+ * Union of feature-flag keys supported by agenr config.
+ */
+type AgenrFeatureFlagKey = (typeof AGENR_FEATURE_FLAG_KEYS)[number];
+/**
+ * Sparse persisted feature-flag overrides.
+ *
+ * Only `true` values are written to disk. Explicit `false` is accepted during
+ * parse and reflected in resolved runtime flags, but canonicalization strips
+ * false entries because every flag defaults to off.
+ */
+type AgenrFeatureFlagConfig = Partial<Record<AgenrFeatureFlagKey, boolean>>;
+/**
+ * Fully resolved runtime feature flags.
+ */
+type AgenrFeatureFlags = Record<AgenrFeatureFlagKey, boolean>;
+
+/**
+ * Runtime configuration for optional claim-key extraction.
+ */
+interface ClaimExtractionConfig {
+    enabled: boolean;
+    confidenceThreshold: number;
+    eligibleTypes: EntryType[];
+    /** Maximum preview workers used by cleanup flows that parallelize claim extraction. Defaults to `10`. */
+    concurrency?: number;
+}
+
+/**
+ * Dependencies needed by the app-layer before-turn service.
+ */
+interface BeforeTurnDeps {
+    /** Shared durable recall ports reused for turn-time memory selection. */
+    recall: RecallPorts;
+    /** Dedicated procedure database port used for proactive procedure selection. */
+    procedures: ProcedureDatabasePort;
+    /** Optional semantic embedding helper reused by dedicated procedure recall. */
+    embedQuery?: (text: string) => Promise<number[]>;
+    /** Optional runtime claim-slot-policy overrides used during claim-aware shaping. */
+    slotPolicyConfig?: ClaimSlotPolicyConfig;
+}
+
+/**
+ * Recent recall event metadata returned by memory trace surfaces.
+ */
+interface EntryRecallEvent {
+    query?: string;
+    sessionKey?: string;
+    recalledAt: string;
+}
+/**
+ * Narrow claim-family lineage view returned by trace surfaces.
+ */
+interface ClaimFamily {
+    /** Shared claim key for the family. */
+    claimKey: string;
+    /** Runtime slot-policy used when reading this lineage. */
+    slotPolicy: ClaimSlotPolicy;
+    /** Human-readable explanation of how the slot policy was chosen. */
+    slotPolicyReason?: string;
+    /** Family rows ordered oldest-first for lineage inspection. */
+    entries: Entry[];
+}
+/**
+ * Minimal provenance view available from the current v1 schema.
+ */
+interface EntryTrace {
+    entry: Entry;
+    supersededBy?: Entry;
+    supersedes: Entry[];
+    claimFamily?: ClaimFamily;
+    recallEvents: EntryRecallEvent[];
+}
+/**
+ * Aggregate memory status facts used by host memory runtimes.
+ */
+interface MemoryStatusSnapshot {
+    activeEntries: number;
+    coreEntries: number;
+    sourceFiles: number;
+}
+/**
+ * Host-neutral memory read model used by prompt injection, trace, and status flows.
+ */
+interface MemoryRepository {
+    /**
+     * Finds the most recent entry matching a subject string.
+     *
+     * @param subject - Free-form subject text to resolve.
+     * @returns Matching entry, or `null` when no match exists.
+     */
+    findEntryBySubject(subject: string): Promise<Entry | null>;
+    /**
+     * Finds the most recently created entry from any state.
+     *
+     * @returns Newest entry, or `null` when none exist.
+     */
+    findMostRecentEntry(): Promise<Entry | null>;
+    /**
+     * Loads the current trace view for one entry.
+     *
+     * @param entryId - Entry identifier to inspect.
+     * @returns Trace payload, or `null` when the entry is missing.
+     */
+    getEntryTrace(entryId: string): Promise<EntryTrace | null>;
+    /**
+     * Reads aggregate counts for host status surfaces.
+     *
+     * @returns Current memory status snapshot.
+     */
+    getMemoryStatusSnapshot(): Promise<MemoryStatusSnapshot>;
+    /**
+     * Checks whether the configured vector index is available.
+     *
+     * @returns `true` when vector search is usable.
+     */
+    probeVectorAvailability(): Promise<boolean>;
+}
+
+/**
+ * One next action in a working snapshot.
+ */
+interface WorkingNextAction {
+    /** Human-readable action text. */
+    text: string;
+    /** Current action status. */
+    status?: "pending" | "in_progress" | "blocked" | "done";
+    /** Optional reference to a file, issue, or event. */
+    ref?: string;
+}
+/**
+ * Checkpoint payload used before handoff, compaction, fork, or shutdown.
+ */
+interface WorkingCheckpoint {
+    /** Compact summary of current progress. */
+    summary: string;
+    /** ISO timestamp when the checkpoint was recorded. */
+    recordedAt: string;
+    /** Expected next actions after the checkpoint. */
+    nextActions?: string[];
+    /** Known blockers at checkpoint time. */
+    blockers?: string[];
+}
+/**
+ * File observation attached to a working set.
+ */
+interface WorkingFileNote {
+    /** File path as observed by the host or model. */
+    path: string;
+    /** Optional note about why the file matters. */
+    note?: string;
+    /** ISO timestamp when the observation was made. */
+    observedAt?: string;
+}
+/**
+ * Command observation attached to a working set.
+ */
+interface WorkingCommandNote {
+    /** Command text. */
+    command: string;
+    /** Compact observed outcome. */
+    outcome?: string;
+    /** ISO timestamp when the command was observed. */
+    observedAt?: string;
+}
+/**
+ * Decision note attached to a working set.
+ */
+interface WorkingDecisionNote {
+    /** Decision text. */
+    decision: string;
+    /** Optional rationale. */
+    rationale?: string;
+    /** ISO timestamp when the decision was made. */
+    decidedAt?: string;
+}
+/**
+ * Assumption note attached to a working set.
+ */
+interface WorkingAssumptionNote {
+    /** Assumption text. */
+    assumption: string;
+    /** Confidence in the assumption. */
+    confidence?: "low" | "medium" | "high";
+    /** Whether the assumption has been validated. */
+    validated?: boolean;
+}
+/**
+ * External reference attached to a working set.
+ */
+interface WorkingReference {
+    /** Display label for the reference. */
+    label: string;
+    /** Optional URI or stable identifier. */
+    uri?: string;
+    /** Reference kind. */
+    kind?: "doc" | "issue" | "pr" | "url" | "entry" | "episode";
+}
+/**
+ * Continuation state stored for future host-side schedulers.
+ */
+interface WorkingContinuationState {
+    /** Host continuation policy. */
+    policy?: WorkingContinuationPolicy;
+    /** ISO timestamp after which the host may resume. */
+    resumeAfter?: string;
+    /** ISO timestamp after which context should be treated as stale. */
+    staleAfter?: string;
+    /** Reason continuation is currently stopped. */
+    stopReason?: string;
+}
+/**
+ * Budget state stored for future host-side schedulers.
+ */
+interface WorkingBudgetState {
+    /** Token budget assigned by the host. */
+    tokenBudget?: number;
+    /** Tokens used so far according to the host. */
+    tokenUsed?: number;
+    /** Wall-clock budget in seconds. */
+    wallClockBudgetSeconds?: number;
+    /** Wall-clock seconds used so far according to the host. */
+    wallClockUsedSeconds?: number;
+    /** Maximum continuation turns allowed by the host. */
+    turnBudget?: number;
+    /** Continuation turns used so far according to the host. */
+    turnsUsed?: number;
+    /** Review interval in seconds before the host should pause for user review. */
+    requireReviewAfterSeconds?: number;
+    /** ISO timestamp when review becomes due. */
+    reviewDueAt?: string;
+    /** Budget dimension that most recently limited continuation. */
+    limitReason?: WorkingBudgetLimitReason;
+    /** ISO timestamp when a budget limit was reached. */
+    limitedAt?: string;
+}
+/**
+ * Delta supplied by host accounting hooks after a goal turn or tool result.
+ */
+interface WorkingUsageDelta {
+    /** Additional tokens consumed since the last accounting write. */
+    tokenDelta?: number;
+    /** Additional wall-clock seconds consumed since the last accounting write. */
+    wallClockSecondsDelta?: number;
+    /** Additional continuation turns consumed since the last accounting write. */
+    turnDelta?: number;
+    /** ISO timestamp when the host recorded this accounting update. */
+    recordedAt?: string;
+}
+/**
+ * Provenance for a memory candidate derived from working events.
+ */
+interface CandidateProvenance {
+    /** Working-event sequence numbers that support the candidate. */
+    evidenceEventSequences: number[];
+    /** Optional compact source reference. */
+    sourceRef?: string;
+    /** Optional reviewer note. */
+    note?: string;
+}
+/**
+ * Episode candidate emitted by close or consolidation.
+ */
+interface WorkingEpisodicCandidate {
+    /** Candidate discriminator. */
+    kind: "episodic";
+    /** Candidate episode summary. */
+    summary: string;
+    /** Event-level provenance for the candidate. */
+    provenance: CandidateProvenance;
+    /** Promotion lifecycle state. */
+    promotionStatus: WorkingCandidatePromotionStatus;
+}
+/**
+ * Semantic or procedural candidate emitted by close or consolidation.
+ */
+interface WorkingDurableCandidate {
+    /** Candidate discriminator. */
+    kind: "semantic" | "procedural";
+    /** Suggested durable subject or procedure name. */
+    subject: string;
+    /** Suggested durable content. */
+    content: string;
+    /** Optional suggested claim key for semantic promotion. */
+    suggestedClaimKey?: string;
+    /** Event-level provenance for the candidate. */
+    provenance: CandidateProvenance;
+    /** Promotion lifecycle state. */
+    promotionStatus: WorkingCandidatePromotionStatus;
+}
+/**
+ * Candidate emitted from a working set for later review.
+ */
+type WorkingCandidate = WorkingEpisodicCandidate | WorkingDurableCandidate;
+/**
+ * Snapshot JSON stored for the active task state.
+ *
+ * This is the authoritative task-state payload. Row-level indexes may mirror
+ * scope facts, but task content lives here only.
+ */
+interface WorkingSnapshot {
+    /** Monotonic goal identity generation; assigned on create and bumps on objective replace. */
+    goalGeneration?: number;
+    /** Current task objective. */
+    objective?: string;
+    /** Success criteria for the task. */
+    successCriteria?: string[];
+    /** Compact task-state summary. */
+    summary?: string;
+    /** Current ordered plan steps. */
+    currentPlan?: string[];
+    /** Next actions the agent or user expects. */
+    nextActions?: WorkingNextAction[];
+    /** Completed task steps. */
+    completedSteps?: string[];
+    /** Latest checkpoint for handoff or lifecycle transitions. */
+    checkpoint?: WorkingCheckpoint;
+    /** File observations relevant to the active task. */
+    files?: WorkingFileNote[];
+    /** Command observations relevant to the active task. */
+    commands?: WorkingCommandNote[];
+    /** Decisions made during the active task. */
+    decisions?: WorkingDecisionNote[];
+    /** Assumptions that may need validation. */
+    assumptions?: WorkingAssumptionNote[];
+    /** Open questions that block or shape the task. */
+    openQuestions?: string[];
+    /** Current blockers. */
+    blockers?: string[];
+    /** External references used by the task. */
+    references?: WorkingReference[];
+    /** Candidate memories emitted from the working set. */
+    candidates?: WorkingCandidate[];
+    /** Continuation state stored for the host scheduler. */
+    continuation?: WorkingContinuationState;
+    /** Budget state stored for the host scheduler. */
+    budgets?: WorkingBudgetState;
+    /** ISO timestamp or short reason for the last material change. */
+    lastMaterialChange?: string;
+}
+
+/**
+ * Typed mutation operations accepted by the normal working-memory tool path.
+ */
+type AgenrWorkUpdateOperation = {
+    type: "set_objective";
+    objective: string;
+    title?: string;
+} | {
+    type: "replace_plan";
+    currentPlan: string[];
+    nextActions?: WorkingNextAction[];
+} | {
+    type: "merge_checkpoint";
+    checkpoint: WorkingCheckpoint;
+} | {
+    type: "add_file_note";
+    file: WorkingFileNote;
+} | {
+    type: "add_command_note";
+    command: WorkingCommandNote;
+} | {
+    type: "record_decision";
+    decision: WorkingDecisionNote;
+} | {
+    type: "record_assumption";
+    assumption: WorkingAssumptionNote;
+} | {
+    type: "set_next_actions";
+    nextActions: WorkingNextAction[];
+} | {
+    type: "set_status";
+    status: WorkingSetStatus;
+} | {
+    type: "add_candidate";
+    candidate: WorkingCandidate;
+} | {
+    type: "configure_budget";
+    budget: WorkingBudgetState;
+} | {
+    type: "account_usage";
+    usage: WorkingUsageDelta;
+} | {
+    type: "set_continuation_policy";
+    policy: WorkingContinuationPolicy;
+    resumeAfter?: string;
+    staleAfter?: string;
+    stopReason?: string;
+};
+/** External goal mutation intents that require progress accounting first. */
+type WorkingExternalGoalMutationKind = "set" | "clear" | "pause" | "resume" | "compact" | "fork" | "handoff" | "scheduled_delay" | "shutdown" | "other";
+/** Explicit terminal intent for close actions. */
+type AgenrWorkCloseMode = "close" | "abandon";
+/**
+ * Parameters accepted by the `agenr_work` tool.
+ */
+interface AgenrWorkParams {
+    /** Action to execute. */
+    action: AgenrWorkAction;
+    /** Explicit working-set id when known. */
+    workingSetId?: string;
+    /** Raw scope facts supplied by the host. */
+    scope?: Partial<WorkingScope>;
+    /** Granular operation for `create` and `update`. */
+    operation?: AgenrWorkUpdateOperation;
+    /** Required observed revision for update and close operations. */
+    expectedRevision?: number;
+    /** Required audit reason for create and update operations. */
+    updateReason?: string;
+    /** Actor that initiated update or close. */
+    actor?: AgenrWorkMutationActor;
+    /** Runtime surface that emitted update or close. */
+    source?: AgenrWorkMutationSource;
+    /** Whether event details should be included in read responses. */
+    includeEvents?: boolean;
+    /** Maximum event count to include in read responses. */
+    eventLimit?: number;
+    /** Maximum working sets to return for list responses. */
+    listLimit?: number;
+    /** Reason supplied when closing or abandoning a working set. */
+    closeReason?: string;
+    /** Explicit terminal intent for close actions. */
+    closeMode?: AgenrWorkCloseMode;
+    /** Whether close should request an episode when thresholds pass. */
+    createEpisode?: boolean;
+    /** Initial budget state supplied by a goal alias or host command. */
+    initialBudget?: WorkingBudgetState;
+    /** Initial continuation policy supplied by a trusted host command. */
+    continuationPolicy?: WorkingContinuationPolicy;
+}
+/**
+ * Trusted host request to account progress before mutating goal state externally.
+ */
+interface PrepareExternalGoalMutationParams {
+    /** External mutation that is about to run. */
+    mutationKind: WorkingExternalGoalMutationKind;
+    /** Explicit working-set id when known. */
+    workingSetId?: string;
+    /** Raw scope facts supplied by the host. */
+    scope?: Partial<WorkingScope>;
+    /** Optional checkpoint to merge before the external mutation. */
+    checkpoint?: WorkingCheckpoint;
+    /** Optional usage delta to account before the external mutation. */
+    usage?: WorkingUsageDelta;
+    /** Whether an active goal must have a checkpoint before the mutation proceeds. */
+    requireCheckpoint?: boolean;
+    /** Actor that initiated the external mutation. */
+    actor?: AgenrWorkMutationActor;
+    /** Trusted host surface that emitted the mutation. */
+    source: TrustedHostMutationSource;
+    /** Optional audit reason used for generated accounting writes. */
+    updateReason?: string;
+}
+
+/**
+ * Status values accepted by working sets.
+ */
+declare const WORKING_SET_STATUSES: readonly ["active", "paused", "blocked", "waiting", "needs_review", "budget_limited", "complete", "closed", "abandoned"];
+/**
+ * Canonical scope kinds produced by the working-memory scope resolver.
+ */
+declare const WORKING_SCOPE_KINDS: readonly ["task", "conversation", "git_branch", "git_cwd", "session", "session_id"];
+/**
+ * Supported working-memory tool actions.
+ */
+declare const AGENR_WORK_ACTIONS: readonly ["get", "list", "create", "update", "close"];
+/**
+ * Actors allowed to mutate the working-memory ledger.
+ */
+declare const AGENR_WORK_MUTATION_ACTORS: readonly ["model", "user", "runtime", "system"];
+/**
+ * Source surfaces that can emit working-memory mutations.
+ */
+declare const AGENR_WORK_MUTATION_SOURCES: readonly ["tool", "goal_command", "lifecycle_hook", "consolidation_job"];
+/**
+ * Trusted host surfaces allowed to close working sets and omit expectedRevision.
+ */
+declare const TRUSTED_HOST_MUTATION_SOURCES: readonly ["goal_command", "lifecycle_hook", "consolidation_job"];
+/**
+ * Candidate promotion states emitted by close and consolidation paths.
+ */
+declare const WORKING_CANDIDATE_PROMOTION_STATUSES: readonly ["pending", "promoted", "dismissed"];
+/**
+ * Host continuation policies stored on active working sets.
+ */
+declare const WORKING_CONTINUATION_POLICIES: readonly ["manual", "on_idle"];
+/**
+ * Budget dimensions that can stop autonomous goal continuation.
+ */
+declare const WORKING_BUDGET_LIMIT_REASONS: readonly ["token", "wall_clock", "turn"];
+
+/**
+ * Union of all supported working-set statuses.
+ */
+type WorkingSetStatus = (typeof WORKING_SET_STATUSES)[number];
+/**
+ * Union of canonical working-scope kinds.
+ */
+type WorkingScopeKind = (typeof WORKING_SCOPE_KINDS)[number];
+/**
+ * Union of supported working-memory tool actions.
+ */
+type AgenrWorkAction = (typeof AGENR_WORK_ACTIONS)[number];
+/**
+ * Union of actors that can mutate a working set.
+ */
+type AgenrWorkMutationActor = (typeof AGENR_WORK_MUTATION_ACTORS)[number];
+/**
+ * Union of surfaces that can emit working-memory mutations.
+ */
+type AgenrWorkMutationSource = (typeof AGENR_WORK_MUTATION_SOURCES)[number];
+/**
+ * Union of trusted host surfaces that may close working sets and default revision.
+ */
+type TrustedHostMutationSource = (typeof TRUSTED_HOST_MUTATION_SOURCES)[number];
+/**
+ * Union of candidate promotion states.
+ */
+type WorkingCandidatePromotionStatus = (typeof WORKING_CANDIDATE_PROMOTION_STATUSES)[number];
+/**
+ * Union of host continuation policies.
+ */
+type WorkingContinuationPolicy = (typeof WORKING_CONTINUATION_POLICIES)[number];
+/**
+ * Union of budget dimensions that can stop continuation.
+ */
+type WorkingBudgetLimitReason = (typeof WORKING_BUDGET_LIMIT_REASONS)[number];
+
+/**
+ * Raw scope facts supplied by a host runtime.
+ */
+interface WorkingScope {
+    /** Host session id used for provenance columns. */
+    sessionId?: string;
+    /** Git repository root when known. */
+    gitRoot?: string;
+    /** Active Git branch when known. */
+    gitBranch?: string;
+    /** Current working directory when known. */
+    cwd?: string;
+    /** Project label supplied by the host or config. */
+    project?: string;
+    /** Explicit task identifier for multiple concurrent work items. */
+    taskId?: string;
+    /** Host-neutral conversation identifier. */
+    conversationKey?: string;
+}
+/**
+ * Canonical working scope selected by agenr.
+ */
+interface ResolvedWorkingScope extends WorkingScope {
+    /** Canonical scope key used by persistence and cardinality checks. */
+    scopeKey: string;
+    /** Resolution strategy that produced the canonical scope key. */
+    scopeKind: WorkingScopeKind;
+}
+
+/**
+ * Phase 2 session-memory contracts.
+ */
+/**
+ * Artifact kinds accepted by schema v12.
+ */
+declare const SESSION_ARTIFACT_KINDS: readonly ["continuity_summary", "recent_session", "compaction_checkpoint", "branch_abandonment", "session_episode"];
+/**
+ * Host transition reasons that create session-lineage edges.
+ */
+declare const SESSION_LINEAGE_REASONS: readonly ["fork", "clone", "resume", "subagent_spawn"];
+/**
+ * Host transition reasons accepted at session start.
+ */
+declare const SESSION_START_TRANSITION_REASONS: readonly ["new", "unknown", "fork", "clone", "resume", "subagent_spawn"];
+/**
+ * Lifecycle trigger names that can matter to session-memory routing.
+ */
+declare const SESSION_MEMORY_TRIGGER_TYPES: readonly ["session_start", "session_before_fork", "session_before_compact", "session_compact", "session_before_tree", "session_tree", "session_shutdown"];
+
+/**
+ * Union of schema v12 session-artifact kinds.
+ */
+type SessionArtifactKind = (typeof SESSION_ARTIFACT_KINDS)[number];
+/**
+ * Union of host transition reasons that create lineage edges.
+ */
+type SessionLineageReason = (typeof SESSION_LINEAGE_REASONS)[number];
+/**
+ * Union of accepted session-start transition reasons.
+ */
+type SessionStartTransitionReason = (typeof SESSION_START_TRANSITION_REASONS)[number];
+/**
+ * Union of lifecycle triggers accepted by the session-memory router.
+ */
+type SessionMemoryTriggerType = (typeof SESSION_MEMORY_TRIGGER_TYPES)[number];
+/**
+ * Schema v12 lineage edge row shape frozen for the session-tree phase.
+ */
+interface SessionLineageEdge {
+    /** Primary key. */
+    id: string;
+    /** Child session key. */
+    childSessionKey: string;
+    /** Parent session key when known. */
+    parentSessionKey?: string;
+    /** Parent source reference when a parent key is unavailable. */
+    parentSourceRef?: string;
+    /** Host-supplied transition reason. */
+    reason: SessionLineageReason;
+    /** Host entry id at fork time when known. */
+    forkEntryId?: string;
+    /** Host fork position when known. */
+    forkPosition?: string;
+    /** ISO timestamp when the edge was observed. */
+    observedAt: string;
+}
+/**
+ * Parent session facts carried by host lifecycle events.
+ */
+interface SessionPredecessorRef {
+    /** Parent session key when the host can resolve it. */
+    sessionKey?: string;
+    /** Compact parent source reference when no stable key exists. */
+    sourceRef?: string;
+    /** Host entry id at fork time when known. */
+    forkEntryId?: string;
+    /** Host fork position when known. */
+    forkPosition?: string;
+}
+/**
+ * Schema v12 session-artifact row shape frozen for the session-tree phase.
+ */
+interface SessionArtifact {
+    /** Primary key. */
+    id: string;
+    /** Artifact kind. */
+    kind: SessionArtifactKind;
+    /** Host session key. */
+    sessionKey: string;
+    /** Source adapter or runtime. */
+    source: string;
+    /** Source-local id. */
+    sourceId: string;
+    /** Optional compact source reference. */
+    sourceRef?: string;
+    /** Hash of artifact content. */
+    contentHash: string;
+    /** Artifact summary. */
+    summary: string;
+    /** Optional typed metadata. */
+    metadata?: unknown;
+    /** Creation timestamp. */
+    createdAt: string;
+    /** Expiry timestamp when retention is bounded. */
+    expiresAt?: string;
+}
+/**
+ * Session artifact payload accepted by lifecycle intake.
+ */
+interface SessionArtifactInput {
+    /** Artifact kind. */
+    kind: SessionArtifactKind;
+    /** Optional explicit session key. Defaults to the trigger session key. */
+    sessionKey?: string;
+    /** Source adapter or runtime. */
+    source: string;
+    /** Source-local id. */
+    sourceId: string;
+    /** Optional compact source reference. */
+    sourceRef?: string;
+    /** Artifact summary stored in schema v12. */
+    summary: string;
+    /** Optional caller-supplied content hash. */
+    contentHash?: string;
+    /** Optional typed metadata. */
+    metadata?: unknown;
+    /** Expiry timestamp when retention is bounded. */
+    expiresAt?: string;
+}
+/**
+ * Normalized session artifact payload ready for repository persistence.
+ */
+type NormalizedSessionArtifactInput = SessionArtifactInput & Required<Pick<SessionArtifactInput, "sessionKey" | "source" | "sourceId" | "summary" | "contentHash">>;
+/**
+ * Host lifecycle event routed into future session-memory services.
+ */
+interface SessionMemoryTriggerEvent {
+    /** Trigger discriminator. */
+    type: SessionMemoryTriggerType;
+    /** Host session key when known. */
+    sessionKey?: string;
+    /** Explicit child session key when different from `sessionKey`. */
+    childSessionKey?: string;
+    /** Host transition reason when this event represents session movement. */
+    transitionReason?: SessionStartTransitionReason;
+    /** Parent session facts for lineage persistence. */
+    predecessor?: SessionPredecessorRef;
+    /** Optional session artifact to persist for this trigger. */
+    artifact?: SessionArtifactInput;
+    /** Optional working-memory scope facts for lifecycle checkpoint refreshes. */
+    workingScope?: Partial<WorkingScope>;
+    /** Normalized shutdown reason when `type` is `session_shutdown`. */
+    shutdownReason?: string;
+    /** Optional raw host payload retained for adapter-specific parsing. */
+    payload?: unknown;
+    /** ISO timestamp when the trigger was observed. */
+    observedAt: string;
+}
+
+/** Input used to persist one schema v12 lineage edge. */
+interface UpsertSessionLineageEdgeInput {
+    /** Child session key receiving predecessor context. */
+    childSessionKey: string;
+    /** Parent session key when known. */
+    parentSessionKey?: string;
+    /** Parent source reference when a parent key is unavailable. */
+    parentSourceRef?: string;
+    /** Host-supplied transition reason. */
+    reason: SessionLineageReason;
+    /** Host entry id at fork time when known. */
+    forkEntryId?: string;
+    /** Host fork position when known. */
+    forkPosition?: string;
+    /** ISO timestamp when the edge was observed. */
+    observedAt: string;
+}
+/** Filter accepted by session-artifact list queries scoped to one session key. */
+interface SessionArtifactListFilter {
+    /** Session key that owns the artifacts. */
+    sessionKey: string;
+    /** Optional artifact kinds to include. */
+    kinds?: SessionArtifactKind[];
+    /** Maximum number of artifacts to return. */
+    limit?: number;
+}
+/** Filter accepted by session-artifact list queries scoped to one source ref. */
+interface SessionArtifactSourceRefListFilter {
+    /** Compact source reference stored on artifact rows. */
+    sourceRef: string;
+    /** Optional artifact kinds to include. */
+    kinds?: SessionArtifactKind[];
+    /** Maximum number of artifacts to return. */
+    limit?: number;
+}
+/** Optional facts persisted together from one lifecycle trigger intake. */
+interface RecordTriggerIntakeInput {
+    /** Normalized artifact payload when the trigger includes artifact facts. */
+    artifact?: NormalizedSessionArtifactInput;
+    /** Normalized lineage payload when the trigger includes lineage facts. */
+    lineage?: UpsertSessionLineageEdgeInput;
+}
+/** Persisted facts returned from one lifecycle trigger intake. */
+interface RecordTriggerIntakeResult {
+    /** Persisted artifact when one was written. */
+    artifact?: SessionArtifact;
+    /** Persisted lineage edge when one was written. */
+    lineageEdge?: SessionLineageEdge;
+}
+/** Persistence port for schema v12 session-memory storage. */
+interface SessionMemoryRepository {
+    /**
+     * Inserts one lineage edge, or returns the existing matching edge.
+     *
+     * @param input - Normalized lineage edge payload.
+     * @returns Persisted lineage edge.
+     */
+    upsertLineageEdge(input: UpsertSessionLineageEdgeInput): Promise<SessionLineageEdge>;
+    /**
+     * Inserts or updates one session artifact by `(kind, source, sourceId)`.
+     *
+     * @param input - Normalized artifact payload.
+     * @returns Persisted session artifact.
+     */
+    upsertSessionArtifact(input: NormalizedSessionArtifactInput): Promise<SessionArtifact>;
+    /**
+     * Persists one or more trigger facts atomically.
+     *
+     * @param input - Optional artifact and lineage payloads from one lifecycle event.
+     * @returns Persisted facts written during the intake.
+     */
+    recordTriggerIntake(input: RecordTriggerIntakeInput): Promise<RecordTriggerIntakeResult>;
+    /**
+     * Lists artifacts for one session key.
+     *
+     * @param filter - Session key, optional kinds, and bounded limit.
+     * @returns Matching artifacts ordered by newest first.
+     */
+    listSessionArtifacts(filter: SessionArtifactListFilter): Promise<SessionArtifact[]>;
+    /**
+     * Lists artifacts linked to one source reference.
+     *
+     * @param filter - Source ref, optional kinds, and bounded limit.
+     * @returns Matching artifacts ordered by newest first.
+     */
+    listSessionArtifactsBySourceRef(filter: SessionArtifactSourceRefListFilter): Promise<SessionArtifact[]>;
+    /**
+     * Loads the newest lineage edge for one child session.
+     *
+     * @param childSessionKey - Child session key.
+     * @returns Matching lineage edge, or null when none exists.
+     */
+    getLatestLineageEdgeForChild(childSessionKey: string): Promise<SessionLineageEdge | null>;
+}
+
+/**
+ * Lifecycle event types written outside typed mutation operations.
+ */
+declare const WORKING_LIFECYCLE_EVENT_TYPES: readonly ["created", "closed", "abandoned", "heartbeat", "lease_acquired", "lease_released"];
+
+/**
+ * Union of lifecycle event types stored in the working-event ledger.
+ */
+type WorkingLifecycleEventType = (typeof WORKING_LIFECYCLE_EVENT_TYPES)[number];
+/**
+ * Closed union of event types stored in schema v11 `working_events.event_type`.
+ */
+type WorkingEventType = AgenrWorkUpdateOperation["type"] | WorkingLifecycleEventType;
+
+/**
+ * Lean working-set row shape for the goal control plane.
+ *
+ * Task state lives in `snapshot` only. Top-level scope columns exist for
+ * provenance and one-open-set cardinality checks, not as a second source of truth.
+ */
+interface WorkingSetRecord {
+    /** Primary key. */
+    id: string;
+    /** Canonical scope key used for one-open-set cardinality. */
+    scopeKey: string;
+    /** Canonical scope kind. */
+    scopeKind: WorkingScopeKind;
+    /** Optional display title. */
+    title?: string;
+    /** Objective mirrored from the snapshot for list and audit surfaces. */
+    objective?: string;
+    /** Current working-set status. */
+    status: WorkingSetStatus;
+    /** Summary mirrored from the snapshot for list and audit surfaces. */
+    summary?: string;
+    /** Canonical snapshot JSON and sole source of task-state truth. */
+    snapshot: WorkingSnapshot;
+    /** Monotonic optimistic-concurrency revision advanced only on semantic writes. */
+    revision: number;
+    /** Optional project label. */
+    project?: string;
+    /** Optional host session id. */
+    sessionId?: string;
+    /** Optional host-neutral conversation key. */
+    conversationKey?: string;
+    /** Optional current working directory. */
+    cwd?: string;
+    /** Optional Git repository root. */
+    gitRoot?: string;
+    /** Optional Git branch. */
+    gitBranch?: string;
+    /** Optional explicit task id. */
+    taskId?: string;
+    /** Source adapter or runtime that created the set. */
+    source?: string;
+    /** Creation timestamp. */
+    createdAt: string;
+    /** Last update timestamp. */
+    updatedAt: string;
+    /** Last material activity timestamp. */
+    lastActiveAt: string;
+    /** Close timestamp when closed. */
+    closedAt?: string;
+    /** Close or abandon reason. */
+    closeReason?: string;
+    /** Episode emitted from this set when one exists. */
+    episodeId?: string;
+}
+/**
+ * Working-event row shape stored in the append-only event log.
+ */
+interface WorkingEventRecord {
+    /** Primary key. */
+    id: string;
+    /** Owning working-set id. */
+    workingSetId: string;
+    /** Monotonic sequence within the working set, aligned with revision on semantic writes. */
+    sequence: number;
+    /** Closed event type union. */
+    eventType: WorkingEventType;
+    /** JSON-serializable payload. */
+    payload: unknown;
+    /** Actor that caused the event. */
+    actor?: AgenrWorkMutationActor;
+    /** Runtime source that emitted the event. */
+    source?: AgenrWorkMutationSource;
+    /** Optional host event id for idempotency or tracing. */
+    hostEventId?: string;
+    /** Optional host turn id. */
+    turnId?: string;
+    /** Creation timestamp. */
+    createdAt: string;
+}
+
+/**
+ * Non-persistent projection returned to host adapters for model-visible context.
+ */
+interface WorkingContextProjection {
+    /** Projection discriminator used by host adapters. */
+    kind: "working_set";
+    /** Rendering depth selected by agenr. */
+    renderMode: "stub" | "full";
+    /** Fully rendered context block or conservative stub. */
+    content: string;
+    /** Working set that produced the projection when one was selected. */
+    workingSetId?: string;
+    /** Snapshot revision represented by the projection. */
+    revision?: number;
+    /** Stable provenance pointer for audits and debugging. */
+    sourceRef: string;
+    /** UTF-8 byte length of `content`. */
+    byteLength: number;
+}
+/**
+ * Compact audit pointer a host may persist outside replay text.
+ */
+interface WorkingContextAuditPointer {
+    /** Pointer source discriminator. */
+    source: "agenr_work";
+    /** Working set that produced the rendered projection. */
+    workingSetId: string;
+    /** Snapshot revision represented by the projection. */
+    revision: number;
+    /** Stable provenance pointer for audits and debugging. */
+    sourceRef: string;
+    /** UTF-8 byte length of the rendered projection. */
+    bytes: number;
+    /** Optional compact summary safe for audit views. */
+    summary?: string;
+}
+
+/** Filter accepted by working-set list queries. */
+interface WorkingSetListFilter {
+    /** Optional raw scope facts used to narrow the list to one resolved scope. */
+    scope?: ResolvedWorkingScope;
+    /** Optional explicit statuses to include. */
+    statuses?: WorkingSetStatus[];
+    /** Maximum number of rows to return. */
+    limit?: number;
+}
+/** Successful create response from the repository. */
+interface WorkingSetCreateSuccess {
+    /** Newly persisted working set. */
+    workingSet: WorkingSetRecord;
+    /** Created lifecycle event. */
+    event: WorkingEventRecord;
+}
+/** Failure returned when one open set already exists for the scope. */
+interface WorkingSetCreateFailure {
+    /** Failure discriminator. */
+    kind: "active_set_exists";
+    /** Canonical scope key that already has an open set. */
+    scopeKey: string;
+}
+/** Result returned when a repository creates one working set. */
+type WorkingSetCreateResult = WorkingSetCreateSuccess | WorkingSetCreateFailure;
+/** Result returned when a repository mutates one working set. */
+interface WorkingSetMutationResult {
+    /** Updated working set after the event is committed. */
+    workingSet: WorkingSetRecord;
+    /** Event written for the mutation. */
+    event: WorkingEventRecord;
+}
+/** Input used to persist a newly created working set. */
+interface CreateWorkingSetInput {
+    /** Resolved canonical scope for the set. */
+    scope: ResolvedWorkingScope;
+    /** Initial display title. */
+    title?: string;
+    /** Initial objective mirrored for list surfaces. */
+    objective?: string;
+    /** Initial status. */
+    status: WorkingSetStatus;
+    /** Initial snapshot. */
+    snapshot: WorkingSnapshot;
+    /** Actor that initiated creation. */
+    actor?: AgenrWorkMutationActor;
+    /** Source surface that initiated creation. */
+    source?: AgenrWorkMutationSource;
+    /** Adapter or runtime source label stored on the row. */
+    sourceLabel?: string;
+    /** Stable host session id when available. */
+    sessionId?: string;
+    /** Timestamp to use for row and event creation. */
+    now: string;
+}
+/** Input used to persist an update event and snapshot revision. */
+interface UpdateWorkingSetInput {
+    /** Working-set id to mutate. */
+    workingSetId: string;
+    /** Revision observed by the caller. */
+    expectedRevision: number;
+    /** Event type to append. */
+    eventType: WorkingEventType;
+    /** JSON-serializable event payload. */
+    payload: unknown;
+    /** Next status for the working set. */
+    status: WorkingSetStatus;
+    /** Next snapshot payload. */
+    snapshot: WorkingSnapshot;
+    /** Optional display title update. */
+    title?: string;
+    /** Optional objective mirror update. */
+    objective?: string;
+    /** Close timestamp for terminal updates. */
+    closedAt?: string;
+    /** Close or abandon reason for terminal updates. */
+    closeReason?: string;
+    /** Episode id emitted from the set when one exists. */
+    episodeId?: string;
+    /** Actor that initiated the mutation. */
+    actor?: AgenrWorkMutationActor;
+    /** Source surface that initiated the mutation. */
+    source?: AgenrWorkMutationSource;
+    /** Timestamp to use for row and event updates. */
+    now: string;
+}
+/** Failure returned when a revision-guarded repository mutation cannot apply. */
+type WorkingSetWriteFailure = {
+    kind: "not_found";
+} | {
+    kind: "revision_conflict";
+    actualRevision: number;
+} | {
+    kind: "terminal_status";
+    status: WorkingSetStatus;
+};
+/** Repository response for revision-guarded updates. */
+type WorkingSetWriteResult = WorkingSetMutationResult | WorkingSetWriteFailure;
+/** Input used to persist a trusted usage patch without advancing revision. */
+interface PatchWorkingSetUsageInput {
+    /** Working-set id to mutate. */
+    workingSetId: string;
+    /** Revision observed by the caller; must match the stored row without incrementing. */
+    expectedRevision: number;
+    /** Next status for the working set. */
+    status: WorkingSetStatus;
+    /** Next snapshot payload. */
+    snapshot: WorkingSnapshot;
+    /** Optional display title update. */
+    title?: string;
+    /** Optional objective mirror update. */
+    objective?: string;
+    /** Timestamp to use for row updates. */
+    now: string;
+}
+/** Successful usage patch response from the repository. */
+interface WorkingSetUsagePatchResult {
+    /** Updated working set after the patch is committed. */
+    workingSet: WorkingSetRecord;
+}
+/** Repository response for trusted usage patches. */
+type WorkingSetUsagePatchWriteResult = WorkingSetUsagePatchResult | WorkingSetWriteFailure;
+/** Persistence port for Phase 1 working-memory storage. */
+interface WorkingMemoryRepository {
+    /**
+     * Loads one working set by id.
+     *
+     * @param id - Working-set identifier.
+     * @returns Stored set, or null when it does not exist.
+     */
+    getWorkingSet(id: string): Promise<WorkingSetRecord | null>;
+    /**
+     * Finds current working sets for one resolved scope, including completed
+     * goals that still occupy the scope until explicit user clear.
+     *
+     * @param scope - Canonical scope selected by the app service.
+     * @returns Matching current working sets ordered by recency.
+     */
+    findCurrentWorkingSets(scope: ResolvedWorkingScope): Promise<WorkingSetRecord[]>;
+    /**
+     * Lists working sets for inspection or tool output.
+     *
+     * @param filter - Optional scope, status, and limit filters.
+     * @returns Matching working sets ordered by recency.
+     */
+    listWorkingSets(filter: WorkingSetListFilter): Promise<WorkingSetRecord[]>;
+    /**
+     * Lists recent events for one working set.
+     *
+     * @param workingSetId - Working set to inspect.
+     * @param limit - Maximum number of events to return.
+     * @returns Events ordered by sequence ascending.
+     */
+    listWorkingEvents(workingSetId: string, limit?: number): Promise<WorkingEventRecord[]>;
+    /**
+     * Creates one working set and its initial event atomically.
+     *
+     * @param input - Initial working-set state.
+     * @returns Persisted working set plus created event.
+     */
+    createWorkingSet(input: CreateWorkingSetInput): Promise<WorkingSetCreateResult>;
+    /**
+     * Applies one revision-guarded working-set mutation atomically.
+     *
+     * @param input - Update event, expected revision, and next snapshot.
+     * @returns Updated row and event, or a stable write failure.
+     */
+    updateWorkingSet(input: UpdateWorkingSetInput): Promise<WorkingSetWriteResult>;
+    /**
+     * Applies one trusted usage patch without advancing revision or appending events.
+     *
+     * @param input - Next snapshot and status guarded by expectedRevision compare-and-swap.
+     * @returns Updated row or a stable write failure.
+     */
+    patchWorkingSetUsage(input: PatchWorkingSetUsageInput): Promise<WorkingSetUsagePatchWriteResult>;
+}
+
+/**
+ * Stable error codes returned by the working-memory service.
+ */
+type WorkingMemoryErrorCode = "feature_disabled" | "misconfigured" | "invalid_request" | "missing_scope" | "missing_active_set" | "ambiguous_scope" | "active_set_exists" | "close_not_allowed" | "not_found" | "revision_conflict" | "terminal_status";
+/** Failed working-memory service result. */
+interface WorkingMemoryFailure {
+    /** Failure discriminator. */
+    ok: false;
+    /** Stable failure code. */
+    code: WorkingMemoryErrorCode;
+    /** Human-readable failure message. */
+    message: string;
+    /** Optional machine-readable details. */
+    details?: Record<string, unknown>;
+}
+/** Successful working-memory get result. */
+interface WorkingMemoryGetSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Action discriminator. */
+    action: "get";
+    /** Selected working set. */
+    workingSet: WorkingSetRecord;
+    /** Optional bounded event tail. */
+    events?: WorkingEventRecord[];
+    /** Full transient projection for the selected set. */
+    projection: WorkingContextProjection;
+}
+/** Successful working-memory list result. */
+interface WorkingMemoryListSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Action discriminator. */
+    action: "list";
+    /** Matching working sets. */
+    workingSets: WorkingSetRecord[];
+}
+/** Successful working-memory create result. */
+interface WorkingMemoryCreateSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Action discriminator. */
+    action: "create";
+    /** Newly created working set. */
+    workingSet: WorkingSetRecord;
+    /** Event committed for the creation. */
+    event: WorkingEventRecord;
+    /** Full transient projection after creation. */
+    projection: WorkingContextProjection;
+}
+/** Successful working-memory update result. */
+interface WorkingMemoryUpdateSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Action discriminator. */
+    action: "update";
+    /** Updated working set. */
+    workingSet: WorkingSetRecord;
+    /** Event committed for semantic mutations; omitted for trusted usage patches. */
+    event?: WorkingEventRecord;
+    /** Full transient projection after the mutation. */
+    projection: WorkingContextProjection;
+}
+/** Successful working-memory close result. */
+interface WorkingMemoryCloseSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Action discriminator. */
+    action: "close";
+    /** Closed working set. */
+    workingSet: WorkingSetRecord;
+    /** Terminal event committed for the close. */
+    event: WorkingEventRecord;
+    /** Candidates retained or emitted for later review. */
+    candidates: WorkingCandidate[];
+}
+/** Successful prepare-before-external-mutation result. */
+interface WorkingMemoryPrepareExternalMutationSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Action discriminator. */
+    action: "prepare_external_goal_mutation";
+    /** Whether an active working set was found and prepared. */
+    prepared: boolean;
+    /** Active working set after preparation when one matched. */
+    workingSet?: WorkingSetRecord;
+    /** Events committed during preparation. */
+    events: WorkingEventRecord[];
+}
+/** Result returned by `agenr_work` actions. */
+type WorkingMemoryResult = WorkingMemoryFailure | WorkingMemoryGetSuccess | WorkingMemoryListSuccess | WorkingMemoryCreateSuccess | WorkingMemoryUpdateSuccess | WorkingMemoryCloseSuccess | WorkingMemoryPrepareExternalMutationSuccess;
+
+/** Result emitted when lifecycle refresh touches an active working set. */
+interface WorkingCheckpointRefreshSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Stable action discriminator. */
+    action: "working_checkpoint_refreshed";
+    /** Working set updated from the lifecycle checkpoint. */
+    workingSetId: string;
+    /** New working-set revision. */
+    revision: number;
+}
+/** Result emitted when lifecycle refresh cannot or should not update WIP. */
+interface WorkingCheckpointRefreshSkipped {
+    /** Failure or skip discriminator. */
+    ok: false;
+    /** Stable reason for the skipped refresh. */
+    reason: "not_applicable" | "missing_scope" | "missing_summary" | "no_active_working_set" | "working_memory_unavailable";
+    /** Working-memory error code when the working service rejected the update. */
+    code?: WorkingMemoryErrorCode;
+    /** Human-readable status for diagnostics. */
+    message: string;
+}
+/** Result returned from lifecycle working-checkpoint refresh. */
+type WorkingCheckpointRefreshResult = WorkingCheckpointRefreshSuccess | WorkingCheckpointRefreshSkipped;
+
+/**
+ * Stable reasons returned when session-memory intake cannot run.
+ */
+type SessionMemoryTriggerFailureReason = "feature_disabled" | "misconfigured" | "invalid_event";
+/**
+ * Successful session-memory intake action.
+ */
+type SessionMemoryTriggerAction = "lineage_recorded" | "artifact_recorded" | "recorded" | "checkpoint_relevant" | "no_lineage";
+/** Result returned when session-memory intake accepts an event. */
+interface SessionMemoryTriggerAcceptedResult {
+    /** Whether the event was accepted for persistence or lifecycle handling. */
+    accepted: true;
+    /** Stable action performed by the intake service. */
+    action: SessionMemoryTriggerAction;
+    /** Human-readable status message. */
+    message: string;
+    /** Persisted lineage edge when one was recorded. */
+    lineageEdge?: SessionLineageEdge;
+    /** Persisted artifact when one was recorded. */
+    artifact?: SessionArtifact;
+    /** Working-set checkpoint refresh result for compaction lifecycle events. */
+    workingCheckpointRefresh?: WorkingCheckpointRefreshResult;
+}
+/** Result returned when session-memory intake rejects an event. */
+interface SessionMemoryTriggerRejectedResult {
+    /** Whether the event was accepted for persistence or lifecycle handling. */
+    accepted: false;
+    /** Stable reason no behavior ran. */
+    reason: SessionMemoryTriggerFailureReason;
+    /** Human-readable status message. */
+    message: string;
+}
+/** Result returned by the session-memory trigger router. */
+type SessionMemoryTriggerResult = SessionMemoryTriggerAcceptedResult | SessionMemoryTriggerRejectedResult;
+
+/** Input accepted by projection rendering. */
+interface WorkingProjectionRequest {
+    /** Stable source reference for the render decision. */
+    sourceRef: string;
+    /** Explicit working set id when known. */
+    workingSetId?: string;
+    /** Raw scope facts used to find an active set. */
+    scope?: Partial<WorkingScope>;
+}
+/** Working-memory service surface. */
+interface WorkingMemoryService {
+    /**
+     * Handles `agenr_work` actions.
+     *
+     * @param params - Tool parameters from the host adapter.
+     * @returns Working-memory action result.
+     */
+    run(params: AgenrWorkParams): Promise<WorkingMemoryResult>;
+    /**
+     * Accounts progress before a trusted host mutates goal state externally.
+     *
+     * @param params - Trusted external mutation preparation request.
+     * @returns Preparation result, including any committed accounting events.
+     */
+    prepareExternalGoalMutation(params: PrepareExternalGoalMutationParams): Promise<WorkingMemoryResult>;
+    /**
+     * Builds a transient working-context projection for host adapters.
+     *
+     * @param input - Source reference or full projection request.
+     * @returns A full projection when an active set resolves, otherwise a conservative stub.
+     */
+    renderProjection(input: string | WorkingProjectionRequest): Promise<WorkingContextProjection>;
+}
+
+/**
+ * Feature-scoped durable-memory lookup contract used by session-start selection.
+ */
+interface SessionStartRepository {
+    /**
+     * Lists active always-on core entries ordered for session-start use.
+     *
+     * @param limit - Maximum number of core entries to return.
+     * @returns Ordered active core entries.
+     */
+    listCoreEntries(limit: number): Promise<Entry[]>;
+}
+/**
+ * Dependencies needed by the app-layer session-start service.
+ */
+interface SessionStartDeps {
+    /** Feature-scoped repository for always-on core memory lookup. */
+    repository: SessionStartRepository;
+    /** Shared durable recall ports reused for artifact-grounded memory selection. */
+    recall: RecallPorts;
+    /** Optional runtime claim-slot-policy overrides used during claim-aware shaping. */
+    slotPolicyConfig?: ClaimSlotPolicyConfig;
+}
+
+/**
+ * Slot-policy overrides shared by host plugin adapters at runtime.
+ */
+interface PluginClaimSlotPolicyConfig extends ClaimSlotPolicyConfig {
+    /** Optional attribute-head policy overrides keyed by canonical attribute head. */
+    attributeHeads?: Readonly<Record<string, ClaimSlotPolicy>>;
+}
+/**
+ * Narrow read-time memory-policy settings shared by host plugin adapters.
+ */
+interface PluginMemoryPolicyConfig {
+    /** Read-time slot-policy overrides used by recall surfaces. */
+    slotPolicies?: PluginClaimSlotPolicyConfig;
+}
+/**
+ * Session-start overrides for prompt-time memory injection behavior.
+ */
+interface PluginSessionStartMemoryPolicyConfig {
+    /** Enables or disables session-start memory injection. Defaults to true. */
+    enabled?: boolean;
+    /** Enables or disables always-on core memory injection at session start. Defaults to true. */
+    coreMemory?: boolean;
+    /** Enables or disables artifact-grounded relevant durable memory injection. */
+    relevantDurableMemory?: boolean;
+}
+/**
+ * Before-turn overrides for proactive prompt-time memory injection behavior.
+ */
+interface PluginBeforeTurnMemoryPolicyConfig {
+    /** Enables or disables the proactive before-turn patch path. */
+    enabled?: boolean;
+    /** Enables or disables proactive procedure suggestion inside the patch. */
+    procedureSuggestion?: boolean;
+    /** Normal durable-item cap before very-high-confidence expansion applies. */
+    maxDurableEntries?: number;
+    /** Durable-recall score threshold required before an entry can surface. */
+    recallThreshold?: number;
+    /** Durable-recall score threshold required before surfacing more than the normal cap. */
+    highConfidenceRecallThreshold?: number;
+    /** Procedure-recall score threshold required before a proactive procedure can surface. */
+    procedureThreshold?: number;
+}
+/**
+ * Working-context overrides for transient per-turn WIP injection.
+ */
+interface PluginWorkingContextMemoryPolicyConfig {
+    /** Enables or disables automatic working-context injection. Defaults to true when working memory is enabled. */
+    enabled?: boolean;
+}
+/**
+ * Memory-policy settings shared by host plugin adapters, including injection knobs.
+ */
+interface PluginInjectionMemoryPolicyConfig extends PluginMemoryPolicyConfig {
+    /** Session-start overrides for prompt-time memory injection behavior. */
+    sessionStart?: PluginSessionStartMemoryPolicyConfig;
+    /** Before-turn overrides for proactive prompt-time memory injection behavior. */
+    beforeTurn?: PluginBeforeTurnMemoryPolicyConfig;
+    /** Working-context overrides for transient per-turn WIP injection. */
+    workingContext?: PluginWorkingContextMemoryPolicyConfig;
+}
+/**
+ * Infrastructure path overrides shared by host plugin adapters.
+ */
+interface PluginPathConfig {
+    /** Path to the shared agenr SQLite database. */
+    dbPath?: string;
+    /** Path to the agenr config.json file. */
+    configPath?: string;
+}
+/**
+ * Concrete runtime paths derived from plugin config and agenr defaults.
+ */
+interface ResolvedPluginPaths {
+    dbPath: string;
+    configPath: string;
+}
+/**
+ * Static embedding availability facts derived from agenr configuration.
+ */
+interface PluginEmbeddingStatus {
+    available: boolean;
+    provider: string;
+    requestedProvider: string;
+    model: string;
+    error?: string;
+}
+/**
+ * Optional claim-extraction runtime wired by host plugin composition.
+ */
+interface PluginClaimExtractionRuntime {
+    llm: LlmPort;
+    config: ClaimExtractionConfig;
+}
+/**
+ * Process-lifetime memory services shared by host plugin runtimes.
+ */
+interface PluginMemoryRuntimeServices {
+    entries: DatabasePort;
+    episodes: EpisodeDatabasePort;
+    procedures: ProcedureDatabasePort;
+    memory: MemoryRepository;
+    workingMemoryRepository?: WorkingMemoryRepository;
+    sessionMemoryRepository?: SessionMemoryRepository;
+    sessionStart: SessionStartDeps;
+    beforeTurn: BeforeTurnDeps;
+    embedding: EmbeddingPort;
+    recall: RecallPorts;
+    claimExtraction?: PluginClaimExtractionRuntime;
+    embeddingStatus: PluginEmbeddingStatus;
+    close(): Promise<void>;
+}
+
+/**
+ * Skeln-native scope facts gathered by the host extension and passed into the
+ * agenr adapter for recall, store provenance, and session-start routing.
+ */
+interface SkelnHostContext {
+    /** Current working directory for the active Skeln session. */
+    cwd: string;
+    /** Repository root when the session cwd is inside a git work tree. */
+    gitRoot?: string;
+    /** Current git branch when available from the host extension. */
+    gitBranch?: string;
+    /** Optional project label supplied by the host extension. */
+    project?: string;
+    /** Optional host-neutral conversation identifier supplied by Skeln. */
+    conversationKey?: string;
+    /** Stable recall/session key derived from Skeln session identity and cwd. */
+    sessionKey: string;
+}
+/**
+ * Options accepted by {@link registerAgenrSkelnMemory}.
+ */
+interface RegisterAgenrSkelnMemoryOptions {
+    /** Path to the shared agenr SQLite database. */
+    dbPath?: string;
+    /** Path to the agenr config.json file. */
+    configPath?: string;
+    /** Narrow runtime memory-policy overrides for claim-aware read surfaces. */
+    memoryPolicy?: PluginInjectionMemoryPolicyConfig;
+    /** Optional Skeln host feature-flag overrides merged over agenr config features. */
+    featureFlags?: AgenrFeatureFlagConfig;
+    /**
+     * Optional host callback that supplies Skeln-native scope facts. When absent,
+     * the adapter derives cwd and sessionKey from the active extension context.
+     */
+    getHostContext?: (context: ExtensionContext) => Partial<SkelnHostContext> | Promise<Partial<SkelnHostContext>>;
+}
+/**
+ * Resolved session scope used by Skeln lifecycle hooks and recall routing.
+ */
+interface AgenrSkelnSessionScope {
+    /** Ephemeral Skeln session identifier. */
+    sessionId: string;
+    /** Stable recall/session key for durable memory routing. */
+    sessionKey: string;
+    /** Current working directory for the active session. */
+    cwd: string;
+    /** Repository root when available. */
+    gitRoot?: string;
+    /** Current git branch when available. */
+    gitBranch?: string;
+    /** Optional project label when available. */
+    project?: string;
+    /** Optional host-neutral conversation identifier. */
+    conversationKey?: string;
+}
+
+/**
+ * Supported auth methods for agenr-managed LLM access.
+ */
+type AgenrAuthMethod = "openai-api-key" | "openai-subscription" | "anthropic-api-key" | "anthropic-oauth" | "anthropic-token";
+/**
+ * Manually entered credentials persisted in `config.json`.
+ *
+ * OAuth and subscription credentials are auto-detected from external CLIs and
+ * should not be stored here.
+ */
+interface AgenrStoredCredentials {
+    /** OpenAI API key used for extraction, embeddings, or both. */
+    openaiApiKey?: string;
+    /** Anthropic API key used for extraction requests. */
+    anthropicApiKey?: string;
+    /** Anthropic long-lived token used for subscription auth. */
+    anthropicOauthToken?: string;
+}
+/**
+ * Per-pipeline model configuration.
+ *
+ * Each pipeline stage can use a different provider/model combination.
+ * Falls back to the top-level provider/model when not set.
+ */
+interface ModelConfig {
+    /** Provider name (for example `openai` or `anthropic`). */
+    provider?: string;
+    /** Model ID (for example `gpt-5.4` or `gpt-5.4-nano`). */
+    model?: string;
+}
+/**
+ * Per-pass surgeon configuration.
+ */
+interface SurgeonPassConfig {
+    /** Protect entries recalled within this many days. */
+    protectRecalledDays?: number;
+    /** Protect entries at or above this importance. */
+    protectMinImportance?: number;
+    /** Skip entries evaluated by surgeon in the last N days. */
+    skipRecentlyEvaluatedDays?: number;
+}
+/**
+ * Surgeon module configuration persisted in `config.json`.
+ */
+interface SurgeonConfig {
+    /** Model override for surgeon runs. */
+    model?: ModelConfig;
+    /** Maximum cost per run in USD. */
+    costCap?: number;
+    /** Maximum total surgeon cost in the last 24 hours. */
+    dailyCostCap?: number;
+    /** Context token limit override. */
+    contextLimit?: number;
+    /** Custom instructions appended to the surgeon system prompt. */
+    customInstructions?: string;
+    /** Per-pass configuration. */
+    passes?: {
+        retirement?: SurgeonPassConfig;
+    };
+}
+/**
+ * Persisted config overrides for optional claim-key extraction.
+ */
+interface AgenrClaimExtractionConfig extends Partial<ClaimExtractionConfig> {
+    /** Model override for claim-key extraction. */
+    model?: ModelConfig;
+}
+/**
+ * Raw persisted agenr config shape as it appears on disk.
+ */
+interface AgenrConfigInput {
+    /** Selected auth method for the default extraction provider. */
+    auth?: AgenrAuthMethod;
+    /** Default LLM provider. */
+    provider?: string;
+    /** Default model for LLM tasks. */
+    model?: string;
+    /** Stored manual credentials. */
+    credentials?: AgenrStoredCredentials;
+    /** Embedding model override. */
+    embeddingModel?: string;
+    /** Prompt context appended to extraction requests. */
+    extractionContext?: string;
+    /** Model override for extraction. */
+    extractionModel?: ModelConfig;
+    /** Model override for dedup. */
+    dedupModel?: ModelConfig;
+    /** Model override for episode summaries. */
+    episodeModel?: ModelConfig;
+    /**
+     * Model override for the cross-encoder rerank stage.
+     *
+     * The cross-encoder requires OpenAI chat completions with
+     * `logprobs`/`logit_bias` support. Set `provider` to `openai` and
+     * `model` to any model with logprob support (for example
+     * `gpt-4.1-nano`).
+     */
+    crossEncoderModel?: ModelConfig;
+    /** Best-effort claim-key extraction settings. */
+    claimExtraction?: AgenrClaimExtractionConfig;
+    /** Surgeon module configuration. */
+    surgeon?: SurgeonConfig;
+    /** Staged rollout feature flags. All default to false. */
+    features?: AgenrFeatureFlagConfig;
+    /** Database file path. */
+    dbPath?: string;
+    /** HTTP API port. */
+    apiPort?: number;
+}
+/**
+ * Backward-compatible alias for the persisted config shape.
+ */
+type AgenrConfig = AgenrConfigInput;
+
+/**
+ * Stable failure codes returned by the goal-continuation boundary.
+ */
+type GoalContinuationErrorCode = "feature_disabled" | "host_callback_missing";
+/** Failed goal-continuation service result. */
+interface GoalContinuationFailure {
+    /** Failure discriminator. */
+    ok: false;
+    /** Stable failure code. */
+    code: GoalContinuationErrorCode;
+    /** Human-readable failure message. */
+    message: string;
+}
+/**
+ * Successful host-owned goal-continuation result.
+ */
+interface GoalContinuationSuccess {
+    /** Success discriminator. */
+    ok: true;
+    /** Optional host-authored result message. */
+    message?: string;
+}
+/** Result returned by the goal-continuation boundary. */
+type GoalContinuationResult = GoalContinuationSuccess | GoalContinuationFailure;
+/**
+ * Goal-continuation service surface.
+ */
+interface GoalContinuationService {
+    /**
+     * Routes future `/goal` or host-equivalent continuation commands to the host.
+     *
+     * @param params - Host command payload reserved for later phases.
+     * @returns A fail-closed result unless a host callback is registered.
+     */
+    runCommand(params: {
+        command: string;
+    }): Promise<GoalContinuationResult>;
+}
+
+/** Resolved runtime capability state for one feature surface. */
+type RuntimeCapabilityState = "enabled" | "disabled" | "misconfigured";
+/** Derived runtime capabilities resolved once per host adapter startup. */
+interface RuntimeCapabilities {
+    /** Working-memory ledger and tool surface. */
+    workingMemory: RuntimeCapabilityState;
+    /** Session-memory lifecycle intake and persistence. */
+    sessionMemory: RuntimeCapabilityState;
+    /** Whether shutdown lifecycle hooks may attempt bounded episode writes. */
+    shutdownEpisodes: boolean;
+    /** Goal-continuation host contract surface. */
+    goalContinuation: RuntimeCapabilityState;
+}
+
+/** Unified runtime policy resolved once per host adapter startup. */
+interface RuntimePolicy {
+    /** Fully resolved runtime feature flags. */
+    featureFlags: AgenrFeatureFlags;
+    /** Derived capability map for host adapters. */
+    capabilities: RuntimeCapabilities;
+    /** Optional host memory-policy overrides for prompt injection. */
+    memoryPolicy?: PluginInjectionMemoryPolicyConfig;
+}
+
+/**
+ * Host-facing memory surface exposed on plugin runtime services.
+ */
+interface AgenrHostMemorySurface {
+    /** Feature-gated working-memory service used by host tools and projections. */
+    workingMemory: WorkingMemoryService;
+    /** Goal-continuation service for host-owned /goal runtime parity. */
+    goalContinuation: GoalContinuationService;
+    /**
+     * Routes session-memory lifecycle triggers through feature gates and persistence.
+     *
+     * @param event - Host lifecycle event.
+     * @returns Accepted intake result when enabled and configured, otherwise a fail-closed rejection.
+     */
+    routeSessionMemoryTrigger(event: SessionMemoryTriggerEvent): Promise<SessionMemoryTriggerResult>;
+}
+
+/**
+ * Runtime configuration accepted by the agenr Skeln adapter.
+ *
+ * Infrastructure fields point the plugin at the shared agenr database and
+ * config file on disk. Embeddings and claim extraction resolve from agenr
+ * config credentials, not Skeln host auth.
+ */
+interface AgenrSkelnConfig extends PluginPathConfig {
+    /** Narrow runtime memory-policy overrides for claim-aware read surfaces. */
+    memoryPolicy?: PluginInjectionMemoryPolicyConfig;
+    /** Optional Skeln host feature-flag overrides merged over agenr config features. */
+    featureFlags?: AgenrFeatureFlagConfig;
+}
+/**
+ * Shared Skeln runtime services composed outside the adapter package.
+ */
+interface AgenrSkelnServices extends PluginMemoryRuntimeServices, AgenrHostMemorySurface {
+    config: ResolvedPluginPaths;
+    skelnConfig: AgenrSkelnConfig;
+    agenrConfig: AgenrConfig;
+    /** Derived runtime capabilities resolved once at startup. */
+    capabilities: RuntimePolicy["capabilities"];
+    /** Unified runtime policy resolved once at startup. */
+    runtimePolicy: RuntimePolicy;
+}
+
+/**
+ * Creates the shared Skeln runtime services used by the plugin process.
+ *
+ * @param config - Optional plugin config with path overrides and memory policy.
+ * @returns Shared services reused for the process lifetime.
+ */
+declare function createAgenrSkelnServices(config?: AgenrSkelnConfig): Promise<AgenrSkelnServices>;
+
+/** Trusted Skeln host surfaces allowed to bypass model-facing work-tool limits. */
+type AgenrSkelnWorkCommandSource = TrustedHostMutationSource;
+/** Shared trusted mutation metadata for Skeln work-command calls. */
+interface AgenrSkelnWorkCommandMutationMetadata {
+    /** Actor that initiated the trusted host command. */
+    actor?: AgenrWorkMutationActor;
+    /** Trusted host surface that emitted the command. */
+    source: AgenrSkelnWorkCommandSource;
+}
+/** Read command accepted by the trusted Skeln work-command controller. */
+interface AgenrSkelnWorkGetCommandParams {
+    /** Read the current working set. */
+    action: "get";
+    /** Explicit working-set id when known. */
+    workingSetId?: string;
+    /** Raw scope facts supplied by Skeln. */
+    scope?: Partial<WorkingScope>;
+    /** Whether recent event details should be included. */
+    includeEvents?: boolean;
+    /** Maximum event count to include. */
+    eventLimit?: number;
+}
+/** List command accepted by the trusted Skeln work-command controller. */
+interface AgenrSkelnWorkListCommandParams {
+    /** List working sets. */
+    action: "list";
+    /** Raw scope facts supplied by Skeln. */
+    scope?: Partial<WorkingScope>;
+    /** Maximum working sets to return. */
+    listLimit?: number;
+}
+/** Create command accepted by the trusted Skeln work-command controller. */
+interface AgenrSkelnWorkCreateCommandParams extends AgenrSkelnWorkCommandMutationMetadata {
+    /** Create one scoped working set. */
+    action: "create";
+    /** Raw scope facts supplied by Skeln. */
+    scope?: Partial<WorkingScope>;
+    /** Initial objective operation. */
+    operation: Extract<AgenrWorkUpdateOperation, {
+        type: "set_objective";
+    }>;
+    /** Human-readable audit reason. */
+    updateReason: string;
+    /** Initial budget state supplied by the trusted host command. */
+    initialBudget?: WorkingBudgetState;
+    /** Initial continuation policy supplied by trusted Skeln `/goal set`. */
+    continuationPolicy?: WorkingContinuationPolicy;
+}
+/** Update command accepted by the trusted Skeln work-command controller. */
+interface AgenrSkelnWorkUpdateCommandParams extends AgenrSkelnWorkCommandMutationMetadata {
+    /** Update an existing working set. */
+    action: "update";
+    /** Explicit working-set id when known. */
+    workingSetId?: string;
+    /** Raw scope facts supplied by Skeln. */
+    scope?: Partial<WorkingScope>;
+    /** Revision observed before mutation. Omit to inherit the selected working-set revision. */
+    expectedRevision?: number;
+    /** Granular mutation operation. */
+    operation: AgenrWorkUpdateOperation;
+    /** Human-readable audit reason. */
+    updateReason: string;
+}
+/** Close command accepted by the trusted Skeln work-command controller. */
+interface AgenrSkelnWorkCloseCommandParams extends AgenrSkelnWorkCommandMutationMetadata {
+    /** Close or abandon an existing working set. */
+    action: "close";
+    /** Explicit working-set id when known. */
+    workingSetId?: string;
+    /** Raw scope facts supplied by Skeln. */
+    scope?: Partial<WorkingScope>;
+    /** Revision observed before close. Omit to inherit the selected working-set revision. */
+    expectedRevision?: number;
+    /** User-visible close reason. */
+    closeReason: string;
+    /** Explicit terminal close intent. */
+    closeMode?: AgenrWorkCloseMode;
+    /** Whether close should request episode creation when thresholds pass. */
+    createEpisode?: boolean;
+}
+/** Prepare command accepted before trusted external goal mutations. */
+interface AgenrSkelnWorkPrepareExternalGoalMutationCommandParams extends AgenrSkelnWorkCommandMutationMetadata {
+    /** Account progress before a host mutates goal state externally. */
+    action: "prepare_external_goal_mutation";
+    /** External mutation that is about to run. */
+    mutationKind: WorkingExternalGoalMutationKind;
+    /** Explicit working-set id when known. */
+    workingSetId?: string;
+    /** Raw scope facts supplied by Skeln. */
+    scope?: Partial<WorkingScope>;
+    /** Optional checkpoint to merge before the external mutation. */
+    checkpoint?: WorkingCheckpoint;
+    /** Optional usage delta to account before the external mutation. */
+    usage?: WorkingUsageDelta;
+    /** Whether an active goal must have a checkpoint before the mutation proceeds. */
+    requireCheckpoint?: boolean;
+    /** Optional audit reason used for generated accounting writes. */
+    updateReason?: string;
+}
+/** Trusted command params accepted by the Skeln controller. */
+type AgenrSkelnWorkCommandParams = AgenrSkelnWorkGetCommandParams | AgenrSkelnWorkListCommandParams | AgenrSkelnWorkCreateCommandParams | AgenrSkelnWorkUpdateCommandParams | AgenrSkelnWorkCloseCommandParams | AgenrSkelnWorkPrepareExternalGoalMutationCommandParams;
+/** Trusted working-memory command result returned to Skeln UI code. */
+interface AgenrSkelnWorkCommandOutcome {
+    /** Text formatted the same way as the model-facing agenr_work tool. */
+    text: string;
+    /** Structured details formatted the same way as the model-facing agenr_work tool. */
+    details: Record<string, unknown>;
+    /** True when Agenr returned a failed working-memory result. */
+    failed: boolean;
+}
+/** Trusted host command capability returned by {@link registerAgenrSkelnMemory}. */
+interface AgenrSkelnMemoryController {
+    /**
+     * Executes a working-memory command from trusted Skeln UI or lifecycle code.
+     *
+     * @param context - Active Skeln extension context.
+     * @param params - Working-memory params supplied by the trusted host command.
+     * @returns Host-neutral working-memory outcome.
+     */
+    executeWorkCommand(context: ExtensionContext, params: AgenrSkelnWorkCommandParams): Promise<AgenrSkelnWorkCommandOutcome>;
+}
+
+/**
+ * Structured tracking facts returned by the session-start tracker.
+ */
+interface SessionStartConsumeResult {
+    /**
+     * Reports whether the caller should run session-start recall.
+     */
+    isFirst: boolean;
+    /**
+     * Reports how many distinct session identities are currently tracked.
+     */
+    activeCount: number;
+}
+/**
+ * Tracks which host sessions have already consumed session-start recall.
+ */
+interface SessionStartTracker {
+    /**
+     * Marks a session as started and reports whether this is the first start signal.
+     *
+     * @param sessionId - Ephemeral host session identifier when available.
+     * @param sessionKey - Stable host session key fallback.
+     * @returns Tracking facts for the attempted session-start event.
+     */
+    consume(sessionId?: string, sessionKey?: string): SessionStartConsumeResult;
+    /**
+     * Remembers a session-start transition emitted by the host.
+     *
+     * @param sessionId - New ephemeral host session identifier.
+     * @param sessionKey - Stable host session key for the active lane.
+     * @param resumedFrom - Previous session identifier when the host provides it.
+     */
+    rememberSessionStart(sessionId?: string, sessionKey?: string, resumedFrom?: string): void;
+    /**
+     * Returns the predecessor session identifier remembered for a new session.
+     *
+     * @param sessionId - New ephemeral host session identifier lookup.
+     * @returns Previous session identifier, or `undefined` when unavailable.
+     */
+    getResumedFrom(sessionId?: string): string | undefined;
+}
+
+/** Describes one agenr memory surface observed during a prompt turn. */
+type MemoryTraceKind = "working_context" | "session_start_recall" | "before_turn_recall" | "system_prompt";
+/** Describes whether a memory surface changed provider context for the turn. */
+type MemoryTraceAction = "injected" | "skipped" | "failed";
+/** Structured audit event for one agenr memory decision on a turn. */
+interface MemoryTraceEvent {
+    kind: MemoryTraceKind;
+    action: MemoryTraceAction;
+    reason?: string;
+    bytes?: number;
+    summary?: string;
+    preview?: string;
+    workingSetId?: string;
+    revision?: number;
+    sourceRef?: string;
+}
+
+/** Skeln before_agent_start event payload used by the agenr adapter. */
+interface AgenrSkelnBeforeAgentStartEvent {
+    type: "before_agent_start";
+    prompt: string;
+    systemPrompt: string;
+}
+/** Skeln before_agent_start result payload returned by the agenr adapter. */
+interface AgenrSkelnBeforeAgentStartResult {
+    message?: AgentMessage;
+    messages?: AgentMessage[];
+    transientMessages?: AgentMessage[];
+    workingContextAudit?: WorkingContextAuditPointer;
+    memoryTrace?: MemoryTraceEvent[];
+    systemPrompt?: string;
+}
+/** Dependencies required by the Skeln before_agent_start handler. */
+interface AgenrSkelnBeforeAgentStartDeps {
+    servicesPromise: Promise<AgenrSkelnServices>;
+    sessionStartTracker: SessionStartTracker;
+    resolveScope: (context: ExtensionContext) => Promise<AgenrSkelnSessionScope>;
+}
+/**
+ * Runs agenr session-start or before-turn recall and injects the result into one Skeln turn.
+ *
+ * @param event - Current before-agent-start payload from Skeln.
+ * @param context - Active extension context with session branch access.
+ * @param deps - Shared services, session-start tracker, and scope resolver.
+ * @returns Hidden user messages, transient working context, and optional system-prompt mutation.
+ */
+declare function handleAgenrSkelnBeforeAgentStart(event: AgenrSkelnBeforeAgentStartEvent, context: ExtensionContext, deps: AgenrSkelnBeforeAgentStartDeps): Promise<AgenrSkelnBeforeAgentStartResult>;
+
+/**
+ * Registers agenr durable-memory tools and lifecycle hooks on a Skeln extension API.
+ *
+ * @param skeln - Skeln extension API for the active runtime.
+ * @param options - Optional path overrides and host scope callback.
+ */
+declare function registerAgenrSkelnMemory(skeln: ExtensionAPI, options?: RegisterAgenrSkelnMemoryOptions): AgenrSkelnMemoryController;
+/** Default Skeln extension factory for direct `@agenr/skeln-plugin` loads. */
+declare function extension(skeln: ExtensionAPI): void;
+
+export { type AgenrSkelnConfig, type AgenrSkelnMemoryController, type AgenrSkelnServices, type AgenrSkelnSessionScope, type AgenrSkelnWorkCloseCommandParams, type AgenrSkelnWorkCommandMutationMetadata, type AgenrSkelnWorkCommandOutcome, type AgenrSkelnWorkCommandParams, type AgenrSkelnWorkCommandSource, type AgenrSkelnWorkCreateCommandParams, type AgenrSkelnWorkGetCommandParams, type AgenrSkelnWorkListCommandParams, type AgenrSkelnWorkPrepareExternalGoalMutationCommandParams, type AgenrSkelnWorkUpdateCommandParams, type RegisterAgenrSkelnMemoryOptions, type SkelnHostContext, createAgenrSkelnServices, extension as default, handleAgenrSkelnBeforeAgentStart, registerAgenrSkelnMemory };