@bendyline/gezel-service 1.0.7 → 1.1.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _bendyline_gezel from '@bendyline/gezel';
-import { SessionParent, SessionLink, ChatSessionSource, ChatEvent, ChatEventEnvelope, HistoryEvent, HistoryFilter, HistoryEntry, ProjectFileEntry, GezelGender, Poppetje, GezelDetail, PendingGezelMessage, GezelConfig, GezelSummary, ProviderName, RetrievalPolicy, ChatModelTuning, GezelTrait, ProjectLocalConfig, ImportProvenance, PendingImports, ProjectTypeOverlay, GezelFrontmatter, Project, ProjectIconId, ProjectDetail, FileReviewIssue, BoekwachterIssueStatus, BoekwachterIssueDismissalReason, ProjectManagedWorkspaceWritePolicy, ProjectNudgeConfig, ProjectTabVisibility, ProjectActivity, MeesterStatusReport, MeesterStatusState, ProjectGitHub, ChatSession, ChatSessionSummary, TimelineMessage, TerminalTimelineEntry, TerminalThread, TerminalThreadSummary, TerminalMessage, GezelGrowthState, Task, Question, TaskNote, ToolsetsScope, InstalledToolset, ToolsetConfig, CraftbookSummary, Craftbook, ProjectCraftbookProvenance, AmbientDashboardResolution, AmbientDashboardTheme, AmbientDashboardDisplayTarget, AmbientDashboardStyle, AmbientDashboardState, HookSpec, HookPhase, HookResult, ModelTier, ModelStyle, BehaviorId, ModelFamily, ChatMessageToolCall, SamplingBlock, CodexPermissionModeCompat, ModelFitnessTrigger, ModelFitnessRecord, OutlineFileResponse, FileContextResponse, FindSymbolResponse, ReadSymbolResponse, MapRepoResponse, SecurityScanResponse, ScanFindingsRequest, ScanFindingsResponse, SecurityFindingWire, MapAttackSurfaceResponse, ListDependenciesResponse, SecurityOverviewResponse, TraceTaintResponse, FileMapRequest, FileMapResponse, SearchCodeResponse, FileReviewResponse, ListFileIssuesRequest, ListFileIssuesResponse, BoekwachterIssue, SearchDocsResponse, SearchDocumentsResponse, ReadDocAsMarkdownResponse, SearchImagesResponse, FindSimilarImagesResponse, DescribeFolderResponse, FindEntityResponse, ListPeopleResponse, ListEntityMentionsResponse, KeurmeesterCaseRecord, TaskStatus, KeurmeesterTriggerKind, KeurmeesterAction, KeurmeesterCaseOutcome, GateCheck, TaskCraftbookStep, TaskCraftbookSource, CraftbookConnectorNeed, CreateTaskRequest, UpdateTaskRequest, TaskAssignee, NewCraftbookStep, StepPosition, UpdateTaskStepRequest, TaskNoteAuthor, TaskVariation, ScriptCapability, WorkspaceIndexStatus, IndexReadinessReport, ScriptScope, ScriptRunTrigger, ScriptRun, NativeEngineResolveEvent, NativeEngineName, ImageRecognition, RecognitionMode, RecognitionHealth, PreviewLogEntry, WorkspaceCommandIndex, WorkspaceSkillIndex, WorkspaceInstructionIndex, UnifiedSearchResult, RetrievalSource, SessionTurnPhase, SessionGpuTask, SessionTelemetry, AIEngagementMode, TurnCancelReason, ChatMessage, SessionDebugSnapshot, ExpectedDeliverable, AppServeSiteStatus, AppServeStartRequest, AppServeStartResponse, ChannelStatus, ChannelName, CodexSetupStatusResponse, ConfigureCodexRequest, KeyedLock, ProjectConnectorBinding, DiffpackOrigin, DiffpackRecord, Diffpack, GildeUpdateStatusResponse, GitWorkingChange, GitFileDiffResponse, CodeReviewKind, GitLogEntry, GitCommitDetailResponse, GitSyncResponse, GitConflictFile, GitConflictVersionsResponse, TaskWaitState, CodeReviewRecord, CodeReview, GitHubPullSummary, GitHubPullDetail, GitHubPullFile, GitHubPullComment, KnowledgeUserRegistry, KnowledgeCatalogRef, ProjectKnowledgeCatalogs, OpenCodeSetupStatusResponse, ConfigureOpenCodeRequest, InstallOpenCodePluginRequest, PiSetupStatusResponse, ConfigurePiRequest, InstallPiExtensionRequest, ImageModelPullEvent as ImageModelPullEvent$1, VideoAccelerator, RenderImageRequest, ReportActionsResponse, FireReportActionResponse, ReportActionRecord, StorageJobKind, StorageJob, StorageJobPhase, SystemToolsetInstallEvent, SystemToolsetInstallSnapshot, NightShiftWindow, TerminalEventEnvelope, DiscoveredCommand, VSCodeSetupStatusResponse, ConfigureVSCodeRequest, ServiceRole, ScriptMeta } from '@bendyline/gezel';
+import { SessionParent, SessionLink, ChatSessionSource, ChatEvent, ChatEventEnvelope, HistoryEvent, HistoryFilter, HistoryEntry, ProjectFileEntry, GezelGender, Poppetje, GezelDetail, PendingGezelMessage, GezelConfig, GezelSummary, ProviderName, RetrievalPolicy, ChatModelTuning, GezelTrait, ProjectLocalConfig, ImportProvenance, PendingImports, ProjectTypeOverlay, GezelFrontmatter, Project, ProjectIconId, ProjectDetail, FileReviewIssue, BoekwachterIssueStatus, BoekwachterIssueDismissalReason, ProjectManagedWorkspaceWritePolicy, ProjectNudgeConfig, ProjectTabVisibility, ProjectActivity, MeesterStatusReport, MeesterStatusState, ProjectGitHub, ChatSession, ChatSessionSummary, TimelineMessage, TerminalTimelineEntry, TerminalThread, TerminalThreadSummary, TerminalMessage, GezelGrowthState, Task, Question, TaskNote, ToolsetsScope, InstalledToolset, ToolsetConfig, CraftbookSummary, Craftbook, ProjectCraftbookProvenance, AmbientDashboardResolution, AmbientDashboardTheme, AmbientDashboardDisplayTarget, AmbientDashboardStyle, AmbientDashboardState, HookSpec, HookPhase, HookResult, ModelTier, ModelStyle, BehaviorId, ModelFamily, ChatMessageToolCall, SamplingBlock, CodexPermissionModeCompat, ModelFitnessTrigger, ModelFitnessRecord, PromptDraftStatus, PromptDraftSummary, PromptDraft, CreatePromptDraftRequest, PatchPromptDraftRequest, DuplicatePromptDraftRequest, OutlineFileResponse, FileContextResponse, FindSymbolResponse, ReadSymbolResponse, MapRepoResponse, SecurityScanResponse, ScanFindingsRequest, ScanFindingsResponse, SecurityFindingWire, MapAttackSurfaceResponse, ListDependenciesResponse, SecurityOverviewResponse, TraceTaintResponse, FileMapRequest, FileMapResponse, SearchCodeResponse, FileReviewResponse, ListFileIssuesRequest, ListFileIssuesResponse, BoekwachterIssue, SearchDocsResponse, SearchDocumentsResponse, ReadDocAsMarkdownResponse, SearchImagesResponse, FindSimilarImagesResponse, DescribeFolderResponse, FindEntityResponse, ListPeopleResponse, ListEntityMentionsResponse, KeurmeesterCaseRecord, TaskStatus, KeurmeesterTriggerKind, KeurmeesterAction, KeurmeesterCaseOutcome, GateCheck, TaskCraftbookStep, TaskCraftbookSource, CraftbookConnectorNeed, CreateTaskRequest, UpdateTaskRequest, TaskAssignee, NewCraftbookStep, StepPosition, UpdateTaskStepRequest, TaskNoteAuthor, TaskVariation, ScriptCapability, WorkspaceIndexStatus, IndexReadinessReport, ScriptScope, ScriptRunTrigger, ScriptRun, NativeEngineResolveEvent, NativeEngineName, ImageRecognition, RecognitionMode, RecognitionHealth, PreviewLogEntry, WorkspaceCommandIndex, WorkspaceSkillIndex, WorkspaceInstructionIndex, UnifiedSearchResult, RetrievalSource, SessionTurnPhase, SessionGpuTask, SessionTelemetry, AIEngagementMode, TurnCancelReason, ChatMessage, SessionDebugSnapshot, ExpectedDeliverable, AppServeSiteStatus, AppServeStartRequest, AppServeStartResponse, ChannelStatus, ChannelName, CodexSetupStatusResponse, ConfigureCodexRequest, KeyedLock, ProjectConnectorBinding, DiffpackOrigin, DiffpackRecord, Diffpack, GildeUpdateStatusResponse, GitWorkingChange, GitFileDiffResponse, CodeReviewKind, GitLogEntry, GitCommitDetailResponse, GitSyncResponse, GitConflictFile, GitConflictVersionsResponse, TaskWaitState, CodeReviewRecord, CodeReview, GitHubPullSummary, GitHubPullDetail, GitHubPullFile, GitHubPullComment, KnowledgeUserRegistry, KnowledgeCatalogRef, KnowledgeInstallSourceKind, TrustedKnowledgeCoordinate, KnowledgeInstallEvent, ProjectKnowledgeCatalogs, KnowledgeEmbeddingProfile, KnowledgeInstallRequest, KnowledgeCatalogStatus, KnowledgeUpdateCandidate, KnowledgeAvailableCatalog, KnowledgeSemanticSearchMode, KnowledgeInstallJob, KnowledgeActiveInstall, IncompleteKnowledgeDownload, OpenCodeSetupStatusResponse, ConfigureOpenCodeRequest, InstallOpenCodePluginRequest, PiSetupStatusResponse, ConfigurePiRequest, InstallPiExtensionRequest, ImageModelPullEvent as ImageModelPullEvent$1, VideoAccelerator, RenderImageRequest, ReportActionsResponse, FireReportActionResponse, ReportActionRecord, StorageJobKind, StorageJob, StorageJobPhase, SystemToolsetInstallEvent, SystemToolsetInstallSnapshot, NightShiftWindow, TerminalEventEnvelope, DiscoveredCommand, VSCodeSetupStatusResponse, ConfigureVSCodeRequest, ServiceRole, ResolvedDistributionPolicy, ScriptMeta } from '@bendyline/gezel';
 import { ServerType } from '@hono/node-server';
 import { CatalogService } from '@bendyline/gezel-catalog';
 import { ExternalFolders } from '@bendyline/gezel/paths';
@@ -1355,10 +1355,17 @@ declare class Store {
      */
     writeProjectArtifactBinary(id: string, filePath: string, data: Buffer, options?: {
         createOnly?: boolean;
+        initiatedByGezel?: boolean;
+    }): Promise<string>;
+    deleteProjectArtifact(id: string, filePath: string, opts?: {
+        initiatedByGezel?: boolean;
+    }): Promise<void>;
+    createProjectArtifactFolder(id: string, folderPath: string, opts?: {
+        initiatedByGezel?: boolean;
     }): Promise<string>;
-    deleteProjectArtifact(id: string, filePath: string): Promise<void>;
-    createProjectArtifactFolder(id: string, folderPath: string): Promise<string>;
-    renameProjectArtifactPath(id: string, fromPath: string, toPath: string): Promise<{
+    renameProjectArtifactPath(id: string, fromPath: string, toPath: string, opts?: {
+        initiatedByGezel?: boolean;
+    }): Promise<{
         fromPath: string;
         toPath: string;
     }>;
@@ -1625,6 +1632,7 @@ declare class Store {
     listDocumentsRecursiveDetailed(opts?: {
         withStats?: boolean;
         includeHidden?: boolean;
+        subpath?: string;
     }): Promise<WalkDirResult>;
     readDocument(filePath: string): Promise<string | null>;
     documentSize(filePath: string): Promise<number | null>;
@@ -3871,6 +3879,13 @@ interface ToolCallEvent {
      * paths for the References panel.
      */
     args?: Record<string, unknown>;
+    /**
+     * Wall-clock start of the tool invocation (epoch ms). Optional so
+     * third-party producers keep working; ChatManager falls back to
+     * `now - durationMs`, which is exact for any producer that computes
+     * durationMs at fire time.
+     */
+    startedAtMs?: number;
     durationMs: number;
     success: boolean;
     errorMessage?: string;
@@ -4672,7 +4687,34 @@ declare class CapacityBroker {
     private explicitAllowRamSpillover;
     private readonly reservations;
     constructor(opts?: CapacityBrokerOptions);
+    /**
+     * The broker is built once and lives for the whole process, so the host
+     * shape it was handed at construction is the one every later admission is
+     * priced against. `gpuVramBytes: null` there means "the boot probe reported
+     * no accelerator" — which is also exactly what a probe that TIMED OUT
+     * reports, and `nvidia-smi` on a laptop dGPU parked in a low-power state
+     * routinely loses its 2s race. Pinning that answer turns one slow probe
+     * into a RAM-only budget for the life of the daemon.
+     *
+     * So a card measured SINCE construction wins, by deferring the whole host
+     * shape — VRAM and the unified flag together — to the published probe. A
+     * host that genuinely has no accelerator publishes `null` too, and nothing
+     * changes for it.
+     */
     private autoBudget;
+    /**
+     * Re-derive the auto budget when the host measurement moved under it.
+     *
+     * {@link autoBudget} recomputes per call, but `budgetBytes` — the number
+     * admission actually gates on — is assigned once by {@link applyBudget}.
+     * Without this, a card measured after construction would show up in
+     * `pools` and in `fastBudgetBytes()` while the enforced ceiling stayed on
+     * the RAM-only curve, which is the half of the figure that denies models.
+     *
+     * Called from every public read; an explicit budget is the operator's
+     * number and is never re-derived.
+     */
+    private refreshAutoBudget;
     private applyBudget;
     /**
      * Re-point the budget without rebuilding the broker. `null` reverts to
@@ -5340,6 +5382,84 @@ declare class ModelFitnessManager {
     private hardwareChanged;
 }
 
+interface PromptDraftManagerOptions {
+    store: Store;
+    events?: Pick<ChatEventBus, 'publishProjectEvent'>;
+    now?: () => Date;
+}
+interface PromptDraftListFilter {
+    gezelId?: string;
+    /** `undefined` matches any thread; `null` matches only new-thread drafts. */
+    sessionId?: string | null;
+    status?: PromptDraftStatus;
+}
+declare class PromptDraftManager {
+    private readonly store;
+    private readonly events;
+    private readonly now;
+    private readonly locks;
+    constructor(opts: PromptDraftManagerOptions);
+    rootDir(projectId: string): string;
+    draftDir(projectId: string, draftId: string): string;
+    list(projectId: string, filter?: PromptDraftListFilter): Promise<PromptDraftSummary[]>;
+    get(projectId: string, draftId: string): Promise<PromptDraft | null>;
+    create(projectId: string, input: CreatePromptDraftRequest): Promise<PromptDraft>;
+    /**
+     * Save the draft's text. A draft with nothing in it and nothing attached is
+     * deleted rather than kept: the composer clears itself on send and on
+     * discard, and a husk left behind would show up as a blank row in the
+     * picker forever.
+     */
+    writeContent(projectId: string, draftId: string, content: string): Promise<{
+        draft: PromptDraftSummary | null;
+        deleted: boolean;
+    }>;
+    /** Re-file a draft. An explicit `null` clears an optional ref. */
+    patchMeta(projectId: string, draftId: string, patch: PatchPromptDraftRequest): Promise<PromptDraftSummary>;
+    /**
+     * Record that this draft was sent. `content` is the ORIGINAL
+     * document-relative markdown, not the rewritten form the transcript
+     * carries: the draft stays an editable document, and rewriting its own
+     * refs would break the editor's Files panel and any later reuse.
+     */
+    markSent(projectId: string, draftId: string, info: {
+        sessionId: string;
+        content?: string;
+    }): Promise<PromptDraftSummary>;
+    /**
+     * Stamp the `at` of the persisted user message. Best-effort and quiet: the
+     * send route accepts before the turn writes its message, so this lands a
+     * beat later and nothing gates on it.
+     */
+    noteSentMessageAt(projectId: string, draftId: string, at: string): Promise<void>;
+    /** "Use again" — copy a draft's text and files into a fresh open draft. */
+    duplicate(projectId: string, draftId: string, input?: DuplicatePromptDraftRequest): Promise<PromptDraft>;
+    delete(projectId: string, draftId: string): Promise<boolean>;
+    /**
+     * A thread was deleted. Its sent drafts go with it — they record a
+     * conversation that no longer exists — while unsent ones are detached
+     * rather than destroyed: those words are still the user's, they just have
+     * nowhere to go yet.
+     */
+    onSessionDeleted(projectId: string, sessionId: string): Promise<{
+        deleted: number;
+        detached: number;
+    }>;
+    /** Remove sent drafts last sent before `cutoffIso`. Unsent are never swept. */
+    sweepSent(projectId: string, cutoffIso: string): Promise<number>;
+    private allocateId;
+    private listDraftIds;
+    private readMeta;
+    private writeMeta;
+    private readContent;
+    private countFiles;
+    private removeDir;
+    private derived;
+    private readSummary;
+    private summarize;
+    private publish;
+}
+
 /**
  * The read side of a draft overlay, as consumed by gate evaluation and the
  * advanceWhen deliverable watcher. A drafting task's workspace-path checks
@@ -6162,6 +6282,26 @@ declare class ContentIndex {
     private syncFindingLifecycle;
 }
 
+/**
+ * Public embedding API. Generates 384-dimensional vectors from text using a
+ * local transformers.js model (all-MiniLM-L6-v2) — runs entirely on-device, no
+ * API keys. The model downloads on first use (~23 MB) and is cached in the OS
+ * cache directory.
+ *
+ * Two robustness properties live here, both added after an out-of-memory in the
+ * model crashed the whole Electron app (a many-chunk file made ONNX attempt a
+ * multi-gigabyte allocation in `BFCArena::Extend`, which trapped — SIGTRAP — on
+ * the main thread):
+ *
+ *   1. Inference runs in BOUNDED sub-batches (see `embed-core`) so no single
+ *      ONNX `Run` can balloon, regardless of how many texts a caller passes.
+ *   2. Inference runs in a WORKER THREAD (`embed-worker`), keeping the heavy
+ *      synchronous native call off the Electron main/UI thread. When the worker
+ *      can't be created — under vitest there's no built worker file, and a raw
+ *      `new Worker('*.ts')` wouldn't load through vitest's transform — we
+ *      degrade to in-process inference, which is still bounded by (1).
+ */
+
 type EmbeddingPipelineStatus = 'cold' | 'warming' | 'ready' | 'disabled' | 'unavailable';
 declare function embed(text: string): Promise<number[]>;
 /**
@@ -7083,13 +7223,14 @@ type TaskSettledHook = (ctx: {
     task: Task;
     outcome: 'complete' | 'canceled';
 }) => Promise<void> | void;
-type TaskNeedsHelpReason = 'gate_exhausted' | 'gate_plateau' | 'gate_unsatisfiable' | 'gate_infrastructure' | 'step_stalled' | 'budget_exhausted';
+type TaskNeedsHelpReason = 'gate_exhausted' | 'gate_plateau' | 'gate_unsatisfiable' | 'gate_infrastructure' | 'step_exit_infrastructure' | 'step_stalled' | 'budget_exhausted';
 /**
  * Fired when a task PAUSES FOR HELP — a gate budget spent, a plateau, an
- * unsatisfiable-by-policy gate, a stalled assignee. Settle hooks only
- * cover complete/canceled, so without this a background task that hit a
- * wall paused silently: a note on the task and a history row, nothing
- * pushed to the user. `detail` is a one-line human summary of why.
+ * unsatisfiable-by-policy gate, a lifecycle-script failure, or a stalled
+ * assignee. Settle hooks only cover complete/canceled, so without this a
+ * background task that hit a wall paused silently: a note on the task and
+ * a history row, nothing pushed to the user. `detail` is a one-line human
+ * summary of why.
  */
 type TaskNeedsHelpHook = (ctx: {
     projectId: string;
@@ -7144,6 +7285,11 @@ interface GateHoldInfo {
     unsatisfiable?: true;
     /** Script-run identifiers and redacted log tails for gate infrastructure failures. */
     scriptRuns?: StepGateOutcome['runs'];
+    /**
+     * Present when completion was held by a lifecycle hook rather than the
+     * step's declarative completion gate. Omission means the gate.
+     */
+    hook?: 'onExit';
     /** Per-check structured outcomes from the gate's declarative floor. */
     checkResults?: GateCheckOutcome[];
     /**
@@ -7494,7 +7640,8 @@ declare class TaskManager {
     recordStepRedrive(projectId: string, num: number, stepId: string): Promise<number>;
     /**
      * Edge resolution order, in priority:
-     *   1. explicit `next` arg ("jump" — user/model agency wins)
+     *   1. explicit `next` arg ("jump" — user/model agency wins after all
+     *      onExit scripts succeed)
      *   2. an approving completion-gate script's `goto`
      *   3. the completion gate's `onApprove`
      *   4. `step.terminal === true` → no further activation; mark complete
@@ -7507,7 +7654,9 @@ declare class TaskManager {
      * this: a reject returns `held` without stamping `completedAt` — the
      * step stays active and the prescriptive message flows back to the
      * caller. `onExit` is the step's `finally`: it runs on every approved
-     * completion (including jumps and terminal), never on a reject.
+     * completion (including jumps and terminal), never on a reject. A missing,
+     * thrown, or non-OK exit script holds the step incomplete and pauses the
+     * task before any edge is resolved.
      */
     private completeStepInternal;
     /**
@@ -7607,10 +7756,18 @@ declare class TaskManager {
     private embeddedScriptSource;
     /**
      * Execute a step-attached script with the right trigger metadata.
-     * Returns `null` when the runner isn't wired or engagement mode is
-     * off — callers treat null as "no script ran".
+     * Returns `null` when the runner isn't wired or engagement mode is off.
+     * Lifecycle callers treat that as an infrastructure failure and pause the
+     * task; a declared hook is never silently skipped.
      */
     private runStepScript;
+    /**
+     * Hold a completion whose `onExit` lifecycle script could not finish.
+     * This deliberately uses the existing structured completion-hold envelope
+     * so older clients also fail closed; `hook: 'onExit'` lets current callers
+     * report the lifecycle failure instead of mislabelling it as a bad gate.
+     */
+    private holdForStepExitFailure;
     /**
      * Run one freshly-activated step's deterministic setup before its handoff.
      * A successful marker is persisted before dispatch, so overlapping kickoff
@@ -10086,6 +10243,14 @@ interface ExternalConversationTurn {
     fail(error: unknown): Promise<void>;
 }
 
+interface CompactSessionNowResult {
+    compacted: boolean;
+    reason?: 'not-found' | 'busy' | 'too-short' | 'failed';
+    removedCount?: number;
+    compactionCount?: number;
+    transcriptTokens?: number;
+}
+
 /**
  * In-memory per-session progress telemetry. Counts the live signals the
  * chat layer already observes — streamed deltas, wire pulses, heartbeats,
@@ -10205,6 +10370,8 @@ type TaskAdvancerOutcome = {
     paused?: boolean;
     /** The gate runtime/configuration failed before judging the deliverable. */
     infrastructureError?: boolean;
+    /** Present when an onExit hook, rather than the declarative gate, held completion. */
+    hook?: 'onExit';
     /** The gate cannot be met under current policy (workspace writes off); paused for a human. */
     unsatisfiable?: boolean;
     /** Gate script diagnostics for durable/user-visible failure reporting. */
@@ -10568,6 +10735,14 @@ declare class ChatManager {
      * closes. Cleared at the start of every turn.
      */
     private readonly currentTurnTools;
+    /**
+     * Question raised by `ask_user_question` during the current in-flight
+     * turn, keyed by session id. The assistant message for that turn does not
+     * exist until `sendAndWait` returns, so stamping "the last assistant" at
+     * tool-call time either hits the previous turn or (on a first turn) hits
+     * nothing. Hold the id here and attach it to the message at commit time.
+     */
+    private readonly currentTurnPendingQuestionIds;
     /**
      * Keurmeester supervision engine, setter-injected from service.ts
      * after construction (the manager needs `oneShotCompletion`, so the
@@ -10724,6 +10899,7 @@ declare class ChatManager {
     private readonly activeMemoryExtractions;
     private readonly store;
     private readonly events;
+    private readonly contextCompactor;
     private readonly externalConversations;
     private readonly memory;
     private readonly historyManager?;
@@ -10921,6 +11097,14 @@ declare class ChatManager {
      */
     setDraftReader(reader: DraftOverlayReader): void;
     private draftReader?;
+    /**
+     * Prompt drafts. Optional so every test that builds a bare ChatManager
+     * keeps working; the two things it drives — stamping a sent draft with its
+     * message time, and cleaning up after a deleted thread — are both
+     * best-effort bookkeeping, never part of a turn's success.
+     */
+    setPromptDrafts(manager: PromptDraftManager): void;
+    private promptDrafts?;
     /**
      * Fail-fast per-task budget (Theme F, F3.1). Accumulates each task's
      * UNATTENDED token/turn spend across the sessions that serve it; a soft
@@ -11022,6 +11206,8 @@ declare class ChatManager {
             projectHint?: string | undefined;
         } | undefined;
         model?: string | undefined;
+        contextWindow?: number | undefined;
+        compactionCount?: number | undefined;
         parentSession?: {
             sessionId: string;
             gezelId: string;
@@ -11034,9 +11220,12 @@ declare class ChatManager {
         archived?: boolean | undefined;
         lastTurnError?: string | undefined;
         turnStartedAt?: string | undefined;
+        contextAutoCompactRatio?: number | undefined;
+        contextEstimatedTokens?: number | undefined;
         lastHumanActivityAt?: string | undefined;
         lastMessagePreview?: string | undefined;
         involvedGezelIds?: string[] | undefined;
+        transcriptTokens?: number | undefined;
     }[]>;
     /**
      * Returns true when at least one session scoped to `projectId` has a
@@ -11284,7 +11473,9 @@ declare class ChatManager {
      * merged turn after it. On an idle session with an empty queue this
      * degrades to a plain `send()`.
      */
-    interruptWithMessage(sessionId: string, userText: string): Promise<ChatMessage>;
+    interruptWithMessage(sessionId: string, userText: string, opts?: {
+        draftId?: string;
+    }): Promise<ChatMessage>;
     getSessionRecord(sessionId: string): Promise<ChatSession | null>;
     /**
      * Begin one request in a caller-owned conversation loop (Pi, OpenCode, or VS Code).
@@ -11556,6 +11747,7 @@ declare class ChatManager {
         sessionId: string;
         toGezelName: string;
         toGezelId: string;
+        deliveryState: 'parked' | 'dispatched';
         deduplicated?: boolean;
     }>;
     /**
@@ -11692,17 +11884,13 @@ declare class ChatManager {
      */
     private deliverHandoffFailureNotice;
     /**
-     * Attach a freshly-created question to the assistant bubble that asked
-     * it, on disk AND on the live turn record.
+     * Attach a freshly-created question to the assistant bubble that asked it.
      *
-     * The disk half alone is not enough for the case it exists for: an
-     * `ask_user_question` tool call happens *mid-turn*, so the record
-     * ChatManager is about to write at turn end is a long-lived in-memory
-     * object that never saw the stamp — its wholesale write erases it, and
-     * the in-chat card silently degrades to dropdown-only. Mirroring onto
-     * the same bubble in the live record keeps the stamp through that
-     * write. Both halves target the last assistant message, which mid-turn
-     * is the same bubble: the in-flight one has not been pushed yet.
+     * During a model turn, that bubble does not exist yet: the durable "last
+     * assistant" belongs to the previous turn (and there is no such message on
+     * turn one). Hold the id in the per-turn buffer for the commit path. The
+     * idle fallback supports direct API/debug calls by stamping the existing
+     * last assistant on both the warm record and disk.
      */
     stampPendingQuestion(gezelId: string, sessionId: string, questionId: string): Promise<void>;
     /**
@@ -11791,6 +11979,13 @@ declare class ChatManager {
         primarySessionId: string;
         text: string;
         mentionGezelIds: string[];
+        /**
+         * The prompt draft the user wrote this in. Stamped on the PRIMARY
+         * message only: the fan-out copies are deliveries of that one draft, not
+         * drafts of their own, and pointing several messages at one draft would
+         * make "open the prompt this came from" ambiguous.
+         */
+        draftId?: string;
     }): Promise<{
         mentionSessionIds: string[];
     }>;
@@ -11806,7 +12001,9 @@ declare class ChatManager {
      * session bus so any composer streaming indicator clears. On error,
      * the session bus gets `error` + `done` so the composer doesn't hang.
      */
-    notifyUserMessage(sessionId: string, userText: string): Promise<ChatMessage>;
+    notifyUserMessage(sessionId: string, userText: string, opts?: {
+        draftId?: string;
+    }): Promise<ChatMessage>;
     /**
      * Pick the project a `@mention` from Meester chat should land in for the
      * given gezel. Delegates to {@link rankProjectsForGezel} and takes the
@@ -11985,10 +12182,7 @@ declare class ChatManager {
      * the same error `runSend` would have thrown.
      */
     send(sessionId: string, userText: string, opts?: {
-        from?: {
-            gezelId: string;
-            gezelName: string;
-        };
+        from?: NonNullable<ChatMessage['from']>;
         /**
          * When true, merge this send into the tail of the session's
          * pending queue IF the tail is also coalescable and shares
@@ -12036,6 +12230,12 @@ declare class ChatManager {
          * the message never queued, so it renders as a normal send.
          */
         nudge?: boolean;
+        /**
+         * The prompt draft this user turn was written in. Display-only, and
+         * carried through the queue so a message typed mid-turn still points at
+         * its draft when it finally runs.
+         */
+        draftId?: string;
         /** Strong provenance used by per-turn behavior hooks. */
         messageOrigin?: TurnMessageOrigin;
     }): Promise<ChatMessage>;
@@ -12165,23 +12365,13 @@ declare class ChatManager {
     private tryAutoRecall;
     /**
      * Local-provider context-window pressure check. Runs before each turn
-     * (including continuation nudges). Three bands keyed off the
-     * estimated outgoing-prompt tokens vs. `num_ctx`:
-     *
-     *   - `< 75%`  → no-op.
-     *   - Warning band with prior conversation → publish `context_warning`.
-     *     UI surfaces a yellow banner so the user can choose to start fresh.
-     *     A first-turn prompt never gets this warning: its standing system +
-     *     tool prefix cannot be reduced by starting a new session.
-     *   - `≥ 90%`  → run {@link compactInFlight} to collapse the older
-     *     messages into a synthetic compaction-summary bubble, tear
-     *     down the live session so the next acquire rebuilds with the
-     *     compacted history, and publish `context_compacted`. If the
-     *     compaction itself fails, fall back to the warning so the
-     *     user at least sees something — Ollama would silently
-     *     truncate from the front otherwise, which is what the model
-     *     "forgot the user's question" symptom traces back to (see
-     *     ollama.ts header).
+     * (including continuation nudges). It publishes the effective window and
+     * automatic-compaction threshold for user-facing UI, then compacts once the
+     * estimated outgoing prompt crosses that threshold. There is no ordinary
+     * "window nearly full" warning band: the runtime owns this maintenance and
+     * should not ask either the user or model to second-guess it. A warning is
+     * emitted only when compaction was actually needed but could not reduce an
+     * accumulated conversation.
      *
      * Copilot/OpenAI/CLI providers remain no-ops because they manage history
      * outside this process. RemoteGezelProvider is included: its transport is
@@ -12195,20 +12385,16 @@ declare class ChatManager {
      */
     private checkContextPressure;
     /**
-     * Collapse the older portion of a session's messages into a single
-     * synthetic `compaction-summary` assistant bubble. The newest
-     * {@link COMPACTION_KEEP_TAIL} messages stay verbatim — they're the
-     * conversational "now" the model needs in full fidelity. Everything
-     * before that is fed to a one-shot summarization on the same
-     * provider; the resulting synthesis replaces those messages
-     * in-place. Persisted via `writeSession`. Fully audit-trailed via
-     * a `chat.compacted` history event.
+     * Compact a session on demand, outside any turn. Same collapse the
+     * automatic pressure path runs, reached from the context meter's
+     * "Compact now" so a user who can see the thread filling up doesn't have
+     * to wait for the threshold — or send a throwaway message to trigger it.
      *
-     * Returns `null` when there's nothing to compact (too few messages)
-     * or the summarization failed; caller treats both as "no
-     * compaction happened" and skips the fresh-session rebuild.
+     * Refuses while a turn is pending: compaction rewrites `record.messages`
+     * out from under a live session, which is safe only because the caller
+     * then tears that session down.
      */
-    private compactInFlight;
+    compactSessionNow(sessionId: string): Promise<CompactSessionNowResult>;
     history(sessionId: string): Promise<ChatMessage[]>;
     reset(sessionId: string): Promise<void>;
     /**
@@ -15450,13 +15636,114 @@ declare class IndexingJobControl {
     private noteAuthor;
 }
 
+/**
+ * Minimal event contract shared by every chat-model installer
+ * (`LlamaCppModelManager.install`, `MlxModelManager.install`): a stream of
+ * typed events where `done` / `error` are terminal. The registry treats
+ * everything else as opaque progress it can replay to late subscribers.
+ */
+interface ChatInstallEventBase {
+    type: string;
+    error?: string;
+}
+interface ChatInstallSnapshot {
+    id: string;
+    startedAt: string;
+    /** Set once a terminal event has been observed (done, error, or cancel). */
+    finished: boolean;
+    /** Set when the install errored or was cancelled. */
+    error?: string;
+}
+type Listener$4<E> = (event: E) => void;
+/**
+ * Owns the lifecycle of in-flight chat-model installs for one engine.
+ *
+ * Installs used to be tied 1:1 to the HTTP request that started them — when
+ * the client disconnected (closed the window, navigated away mid-download),
+ * the SSE loop exited, the async install generator closed, and the download
+ * was abandoned with `.partial` files on disk and no record it ever ran.
+ * This is the chat-model twin of the image path's `ImageModelPullRegistry`,
+ * which fixed the identical failure mode for image pulls.
+ *
+ * The registry decouples the two: the install runs in a detached background
+ * task owned by this object, and HTTP requests are just consumers that
+ * subscribe to the live event fan-out. Disconnect detaches the consumer; the
+ * install keeps going. Cancel is an explicit `DELETE /models/:id/install`.
+ *
+ * Cancellation unwinds the install generator via `iterator.return()` rather
+ * than an AbortSignal — the generator only runs between yields, and the
+ * downloaders yield progress a few times a second, so the unwind lands
+ * within one progress interval and the `.partial` files stay resumable.
+ */
+declare class ChatModelInstallRegistry<E extends ChatInstallEventBase, O> {
+    private readonly entries;
+    private readonly engine;
+    private readonly run;
+    private readonly onDone;
+    private readonly finishedTtlMs;
+    constructor(opts: {
+        /** Label used in log lines only. */
+        engine: string;
+        /** Start the actual install — typically `(id, o) => manager.install(id, o)`. */
+        run: (id: string, opts: O) => AsyncIterable<E>;
+        /** Fired when an install reaches `done`, before the event is broadcast —
+         *  the place to bust caches so subscribers observing `done` re-fetch
+         *  fresh state. */
+        onDone?: (id: string) => void;
+        /** How long a finished entry stays observable (default {@link FINISHED_TTL_MS}). */
+        finishedTtlMs?: number;
+    });
+    /**
+     * Start an install for `id`, or attach to the one already in flight.
+     * Idempotent — a second `start` for a running id does not launch a second
+     * download and does not change the original's options. The install runs in
+     * a detached `void` task; the entry is claimed synchronously so callers
+     * can subscribe without racing the first event.
+     */
+    start(id: string, opts: O): {
+        alreadyRunning: boolean;
+    };
+    get(id: string): ChatInstallSnapshot | null;
+    /** The snapshot plus the events a late subscriber would be replayed. */
+    describe(id: string): (ChatInstallSnapshot & {
+        lastEvent: E | null;
+        terminalEvent: E | null;
+    }) | null;
+    /** Every install still running, with its latest progress — the polled twin of subscribe(). */
+    active(): Array<{
+        id: string;
+        startedAt: string;
+        lastEvent: E | null;
+    }>;
+    /**
+     * Subscribe to live events for an in-flight install. On subscribe, the
+     * registry replays the last known progress event (and the terminal event,
+     * when one has landed) so a late subscriber renders immediately. Returns
+     * `null` when no entry exists for `id`; otherwise an unsubscribe function.
+     * Unsubscribing does NOT cancel the install — disconnect ≠ cancel.
+     */
+    subscribe(id: string, listener: Listener$4<E>): (() => void) | null;
+    /**
+     * Cancel an in-flight install. The generator unwinds at its next yield,
+     * running the manager's cleanup (active-install deregistration) and
+     * leaving `.partial` files in place for resume. Subscribers receive a
+     * terminal `error` event stating the install was cancelled. Returns true
+     * when a live entry was cancelled.
+     */
+    cancel(id: string): boolean;
+    /** Shutdown/test hook: unwind every live install and drop all state. */
+    clear(): void;
+    private consume;
+    private broadcast;
+}
+
 /**
  * The catalog host boundary: everything that touches catalog SQLite goes
  * through this interface. Two implementations — the in-process host below
  * (tests, and the fallback when the worker cannot boot) and the worker
  * host (worker-host.ts), which confines node:sqlite's synchronous scans to
  * a dedicated thread so a 100 ms shard scan never stalls the daemon loop
- * (gezk-format-v1.md §9). The in-process implementation is test/CLI-only;
+ * (docs/gezk-format.md). The in-process implementation is test/CLI-only;
  * production fails closed if its worker becomes unavailable.
  */
 
@@ -15536,12 +15823,14 @@ declare class KnowledgeRegistry {
     find(publisherId: string, catalogId: string): KnowledgeRegistryEntry | null;
     /**
      * Add or replace the entry for this catalog identity. The same-catalogId/
-     * different-publisher conflict is rejected here — the `knowledge://` URI
-     * carries no publisher, so two publishers cannot share a catalog id.
+     * different-publisher conflict is rejected here: the catalog id is the
+     * browse and route handle (`/api/knowledge/catalogs/:id`), so one id maps
+     * to one publisher per user even though `knowledge://` references carry both.
      */
     upsert(ref: KnowledgeCatalogRef, opts?: {
         enabled?: boolean;
         autoUpdate?: boolean;
+        source?: KnowledgeInstallSourceKind;
     }): void;
     setEnabled(publisherId: string, catalogId: string, enabled: boolean): boolean;
     /** Quarantine: disable with a reason the UI/CLI can show verbatim. */
@@ -15550,75 +15839,44 @@ declare class KnowledgeRegistry {
 }
 
 /**
- * Private-tier catalog install (docs/knowledge-catalogs.md install sequence):
- * resolve source → disk preflight → resumable download (`.partial` stays on
- * kill, next attempt resumes) → archive sha256 = the ref's contentDigest →
- * verified staged extract (every file hashed against the manifest) → open +
- * count validation in staging → atomic sibling-rename publish → registry
- * pointer → prune older versions. Yields install events; the job registry
- * in manager.ts consumes them.
+ * The user daemon's side of shared knowledge placement: ask the machine
+ * broker to ensure a trusted coordinate in the machine-shared asset store,
+ * streaming its progress back through the bridge. The request is the bare
+ * coordinate — never a URL, path, or anything about this user — exactly as
+ * docs/service-boundaries.md requires. Any outcome other than success or a
+ * digest mismatch is "unavailable": the caller installs privately instead.
  */
 
-type KnowledgeInstallEvent = {
-    type: 'progress';
-    phase: 'download' | 'extract';
-    bytesDone: number;
-    bytesTotal: number;
+type SharedEnsureResult = {
+    status: 'ready';
 } | {
-    type: 'verifying';
-} | {
-    type: 'retrying';
-    attempt: number;
+    status: 'unavailable';
     reason: string;
 } | {
-    type: 'done';
-    ref: KnowledgeCatalogRef;
-    rootDir: string;
-} | {
-    type: 'error';
+    status: 'failed';
     error: string;
+    mismatch: {
+        expected: string;
+        actual: string;
+    };
 };
-type KnowledgeInstallSource = {
-    kind: 'file';
-    path: string;
-} | {
-    kind: 'url';
-    url: string;
-    expectedSha256?: string;
-};
+interface SharedKnowledgeInstaller {
+    available(): boolean;
+    ensure(coordinate: TrustedKnowledgeCoordinate, onEvent: (event: KnowledgeInstallEvent) => void, signal?: AbortSignal): Promise<SharedEnsureResult>;
+    cancel(coordinate: TrustedKnowledgeCoordinate): Promise<boolean>;
+}
 
 /**
  * KnowledgeManager — the daemon-side owner of installed `.gezk` catalogs:
  * registry + mount lifecycle (verify-before-mount → quarantine-with-reason),
- * install jobs, browse APIs for the routes, and the SearchService knowledge
- * arm. Every SQLite touch goes through the KnowledgeCatalogHost (worker
- * thread in production); this class never opens a catalog database itself.
+ * background install jobs (a client disconnect never abandons a download),
+ * the gilde join (what is available, what has a newer version), browse APIs
+ * for the routes, and the SearchService knowledge arm. Every SQLite touch
+ * goes through the KnowledgeCatalogHost (worker thread in production); this
+ * class never opens a catalog database itself.
  */
 
-interface KnowledgeCatalogStatus {
-    ref: KnowledgeCatalogRef;
-    enabled: boolean;
-    addedAt: string;
-    disabledReason?: string;
-    mounted: boolean;
-    name?: string;
-    description?: string;
-    language?: string;
-    license?: string;
-    documents?: number;
-    chunks?: number;
-    sizeBytes?: number;
-    /** False when the catalog's embedding profile differs from the daemon's
-     * embedder — semantic search degrades to FTS for this catalog. */
-    vectorCompatible?: boolean;
-}
-interface KnowledgeInstallJob {
-    id: string;
-    startedAt: string;
-    finished: boolean;
-    error?: string;
-    events: KnowledgeInstallEvent[];
-}
+type KnowledgeInstallRequestSource = KnowledgeInstallRequest['source'];
 interface MountedInfo {
     ref: KnowledgeCatalogRef;
     key: string;
@@ -15631,42 +15889,122 @@ interface MountedInfo {
     chunks: number;
     sizeBytes: number;
     vectorCompatible: boolean;
+    semanticSearch: KnowledgeSemanticSearchMode;
+    embedding: KnowledgeEmbeddingProfile;
     /** topic id → display name, from the shipped TOC. */
     topicNames: Map<string, string>;
     sourceUrlByDoc: Map<string, string>;
 }
+interface InstallStart {
+    request: KnowledgeInstallRequestSource;
+}
 interface KnowledgeManagerOptions {
     home: string;
     host: KnowledgeCatalogHost;
     env?: NodeJS.ProcessEnv;
     fetchImpl?: typeof fetch;
+    /** The gilde loader: `knowledge-catalog` entries are the download source and the update oracle. */
+    catalog?: CatalogService;
+    history?: HistoryManager;
+    /** The security policy (app network) and the auto-update default. */
+    readConfig?: () => Promise<GezelConfig | null>;
+    /** The machine broker's shared store, when a machine engine is adopted. */
+    sharedInstaller?: SharedKnowledgeInstaller;
     /** Project policy lookup (Store.getProject wrapper); null = no policy. */
     projectPolicy?: (projectId: string) => Promise<ProjectKnowledgeCatalogs | null>;
+    /** Test seam: embed a query in a catalog profile's space (default: the embed worker). */
+    embedQueryForProfile?: (text: string, profile: KnowledgeEmbeddingProfile) => Promise<number[]>;
 }
 declare class KnowledgeManager {
     private readonly opts;
     readonly registry: KnowledgeRegistry;
     private readonly mountedByKey;
-    private readonly jobs;
+    private readonly installs;
+    /** What each running job was asked to install, for the active-install listing. */
+    private readonly jobRequests;
+    /** Download temp keys of running jobs, so the incomplete listing skips live transfers. */
+    private readonly jobDownloadKeys;
+    private readonly autoUpdateTimers;
     private jobCounter;
     constructor(opts: KnowledgeManagerOptions);
     get host(): KnowledgeCatalogHost;
+    /** The job registry, for the SSE subscriber shared with the model install routes. */
+    get installRegistry(): ChatModelInstallRegistry<KnowledgeInstallEvent, InstallStart>;
     private keyFor;
     private dirFor;
     /** Mount every enabled registry entry. Failures quarantine, never throw. */
     start(): Promise<void>;
     private mountEntry;
     stop(): Promise<void>;
+    /** Every gilde `knowledge-catalog` entry (newest version), keyed by publisher/id. */
+    private gildeItems;
+    /** Coordinates present in the machine-shared asset store (public inventory, read-only). */
+    private sharedInventoryKeys;
     list(): Promise<KnowledgeCatalogStatus[]>;
+    /** Installed catalogs for which the shipped gilde content carries a strictly newer version. */
+    updates(): Promise<KnowledgeUpdateCandidate[]>;
+    /**
+     * Every gilde `knowledge-catalog` entry joined with this user's registry,
+     * the machine-shared inventory, running installs and partial downloads —
+     * what the Knowledge screen's browser renders. Offline-safe: gilde is local.
+     */
+    available(): Promise<KnowledgeAvailableCatalog[]>;
     /** Resolve a catalogId (URI authority) to its mounted info, or null. */
     mountedCatalog(catalogId: string): MountedInfo | null;
-    startInstall(source: KnowledgeInstallSource): {
+    /**
+     * Start an install, or attach to the one already running. A catalog
+     * install's job id is the catalog id, so a second click, the auto-updater
+     * and a reconnecting client all land on the same job.
+     */
+    startInstall(request: KnowledgeInstallRequestSource): {
         jobId: string;
+        alreadyRunning: boolean;
     };
+    private planInstall;
+    /**
+     * Ask the machine broker to ensure the coordinate in the shared store,
+     * relaying its progress. Cancelling this job cancels the broker's too:
+     * this daemon asked for the download, so its cancel is the honest signal.
+     */
+    private installShared;
+    /** Bytes a private install of this catalog left behind, once a shared copy replaces it. */
+    private deletePrivateBytes;
     private runInstall;
+    /** Mount the fresh version, record it, and warm the query embedder before `done`. */
+    private finishInstall;
+    /**
+     * Pull the catalog's query model now, while the user is watching the
+     * install, instead of on the first search. Never an install failure: the
+     * catalog is on disk and keyword search works without the model.
+     */
+    private prewarmProfile;
+    private recordInstallFailure;
     getJob(jobId: string): KnowledgeInstallJob | null;
+    /** Live events for a job; replays the latest progress (and the terminal event) first. */
     subscribeJob(jobId: string, listener: (event: KnowledgeInstallEvent) => void): (() => void) | null;
     cancelJob(jobId: string): boolean;
+    /** Every running install with its latest progress (the polled twin of the SSE). */
+    activeInstalls(): KnowledgeActiveInstall[];
+    private partialDownloadKeys;
+    /**
+     * Partial archives no job is writing. A key that still matches a gilde
+     * pin resumes on the next install of that catalog; anything else can only
+     * be deleted. Largest first: the most disk to reclaim.
+     */
+    listIncompleteDownloads(): Promise<IncompleteKnowledgeDownload[]>;
+    /** Delete a partial download by key. Refuses a key a running job is writing. */
+    deleteIncompleteDownload(key: string): Promise<boolean>;
+    /**
+     * Start installs for catalogs whose registry entry (or the install-wide
+     * `config.knowledge.autoUpdate` default) opted into automatic updates.
+     * Returns the `catalog@version` pairs it started.
+     */
+    checkAutoUpdates(): Promise<string[]>;
+    /** Arm the daily auto-update check (a quiet start, then every 24 h); `stop()` disarms. */
+    startAutoUpdateTimer(): void;
+    private readConfig;
+    private networkAllowed;
+    private logHistory;
     setEnabled(catalogId: string, enabled: boolean): Promise<boolean>;
     /**
      * Adopt a catalog that already exists in the machine-shared asset store:
@@ -15690,15 +16028,20 @@ declare class KnowledgeManager {
     }): ReturnType<KnowledgeCatalogHost['documentsPage']>;
     getDocument(catalogId: string, documentId: string): ReturnType<KnowledgeCatalogHost['getDocument']>;
     /**
-     * Explicit search across active catalogs. The vector is reused only for
-     * catalogs on the daemon's own embedding profile; others search FTS.
-     * Results come back FINISHED — provenance, topic names, scoring.
+     * Explicit search across active catalogs. Catalogs are grouped by how their
+     * queries are embedded — the daemon's own vector for profiles it shares,
+     * one profile-embedded vector per foreign profile, none for keyword-only —
+     * and each group searches with its own vector, so every catalog is
+     * searched in the space it was built in. Results come back FINISHED —
+     * provenance, topic names, scoring.
      */
     searchUnified(query: string, opts: {
         vector: number[] | null;
         maxResults: number;
         projectId?: string;
     }): Promise<UnifiedSearchResult[]>;
+    /** A profile's query vector, or undefined when its model is unavailable (that group searches FTS). */
+    private embedForProfile;
     private toResult;
     /** Enabled+mounted catalogs, intersected with the project policy. */
     private activeCatalogKeys;
@@ -15850,93 +16193,6 @@ interface EnsureModelOrchestrator {
     subscribeJob(jobId: string, listener: (event: EnsureEvent) => void): () => void;
 }
 
-/**
- * Minimal event contract shared by every chat-model installer
- * (`LlamaCppModelManager.install`, `MlxModelManager.install`): a stream of
- * typed events where `done` / `error` are terminal. The registry treats
- * everything else as opaque progress it can replay to late subscribers.
- */
-interface ChatInstallEventBase {
-    type: string;
-    error?: string;
-}
-interface ChatInstallSnapshot {
-    id: string;
-    startedAt: string;
-    /** Set once a terminal event has been observed (done, error, or cancel). */
-    finished: boolean;
-    /** Set when the install errored or was cancelled. */
-    error?: string;
-}
-type Listener$4<E> = (event: E) => void;
-/**
- * Owns the lifecycle of in-flight chat-model installs for one engine.
- *
- * Installs used to be tied 1:1 to the HTTP request that started them — when
- * the client disconnected (closed the window, navigated away mid-download),
- * the SSE loop exited, the async install generator closed, and the download
- * was abandoned with `.partial` files on disk and no record it ever ran.
- * This is the chat-model twin of the image path's `ImageModelPullRegistry`,
- * which fixed the identical failure mode for image pulls.
- *
- * The registry decouples the two: the install runs in a detached background
- * task owned by this object, and HTTP requests are just consumers that
- * subscribe to the live event fan-out. Disconnect detaches the consumer; the
- * install keeps going. Cancel is an explicit `DELETE /models/:id/install`.
- *
- * Cancellation unwinds the install generator via `iterator.return()` rather
- * than an AbortSignal — the generator only runs between yields, and the
- * downloaders yield progress a few times a second, so the unwind lands
- * within one progress interval and the `.partial` files stay resumable.
- */
-declare class ChatModelInstallRegistry<E extends ChatInstallEventBase, O> {
-    private readonly entries;
-    private readonly engine;
-    private readonly run;
-    private readonly onDone;
-    constructor(opts: {
-        /** Label used in log lines only. */
-        engine: string;
-        /** Start the actual install — typically `(id, o) => manager.install(id, o)`. */
-        run: (id: string, opts: O) => AsyncIterable<E>;
-        /** Fired when an install reaches `done`, before the event is broadcast —
-         *  the place to bust caches so subscribers observing `done` re-fetch
-         *  fresh state. */
-        onDone?: (id: string) => void;
-    });
-    /**
-     * Start an install for `id`, or attach to the one already in flight.
-     * Idempotent — a second `start` for a running id does not launch a second
-     * download and does not change the original's options. The install runs in
-     * a detached `void` task; the entry is claimed synchronously so callers
-     * can subscribe without racing the first event.
-     */
-    start(id: string, opts: O): {
-        alreadyRunning: boolean;
-    };
-    get(id: string): ChatInstallSnapshot | null;
-    /**
-     * Subscribe to live events for an in-flight install. On subscribe, the
-     * registry replays the last known progress event (and the terminal event,
-     * when one has landed) so a late subscriber renders immediately. Returns
-     * `null` when no entry exists for `id`; otherwise an unsubscribe function.
-     * Unsubscribing does NOT cancel the install — disconnect ≠ cancel.
-     */
-    subscribe(id: string, listener: Listener$4<E>): (() => void) | null;
-    /**
-     * Cancel an in-flight install. The generator unwinds at its next yield,
-     * running the manager's cleanup (active-install deregistration) and
-     * leaving `.partial` files in place for resume. Subscribers receive a
-     * terminal `error` event stating the install was cancelled. Returns true
-     * when a live entry was cancelled.
-     */
-    cancel(id: string): boolean;
-    /** Shutdown/test hook: unwind every live install and drop all state. */
-    clear(): void;
-    private consume;
-    private broadcast;
-}
-
 interface GgufInstallOpts {
     skipSha: boolean;
     /**
@@ -18209,6 +18465,12 @@ interface OllamaEmulationController {
 interface ServiceContext {
     /** Process responsibility; used to keep the machine route table deny-by-default. */
     serviceRole: ServiceRole;
+    /**
+     * What this build's distribution channel permits. Resolved once at boot and
+     * passed here so routes take it as a dependency instead of each re-reading
+     * the environment and risking a different answer.
+     */
+    distribution: ResolvedDistributionPolicy;
     home: string;
     store: Store;
     chatEvents: ChatEventBus;
@@ -18268,6 +18530,8 @@ interface ServiceContext {
     reportActions: ReportActionManager;
     /** Proposed change sets a gezel drafted for the user to review and apply. */
     diffpacks: DiffpackManager;
+    /** Chat prompt drafts the user is writing (artifacts/prompts/). */
+    promptDrafts: PromptDraftManager;
     connectors: ConnectorManager;
     connectorActions: ConnectorActionManager;
     /**