@bendyline/gezel 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3217 @@
+import { R as Rect, V as VillageAnchor, a as VillageOverride, M as MapDistrict, b as MapStreet, c as MapPlaza, d as MapBuilding, C as CompassRegion, F as FileContextResponse, S as ScriptInputField, e as ScriptOutputField, f as ScriptMeta, G as GezelConfig, g as SecurityPolicy, P as Project, h as ModelFitnessRecord, i as GateScriptRef, j as ModelTier, D as DeliverableKindSchema, A as AdvanceWhen, k as GateCheck, l as StepGate, m as CraftbookStep, n as StepDeliverable, N as NewCraftbookStep, T as ToolsetRuntime, o as Craftbook, O as Outcome, p as Task } from './index-D_dch9Qh.js';
+export { q as AcceptGrowthProposalRequest, r as AcceptGrowthProposalRequestSchema, s as ActiveImagePull, t as ActiveImagePullSchema, u as ActiveVideoPull, v as ActiveVideoPullSchema, w as AdoptedTraitRecord, x as AdoptedTraitRecordSchema, y as AdvanceWhenSchema, z as AnswerQuestionRequest, B as AnswerQuestionRequestSchema, E as AppendTaskNoteRequest, H as AppendTaskNoteRequestSchema, I as AppendTaskNoteResponse, J as AppendTaskNoteResponseSchema, K as AppliedProjectType, L as AppliedProjectTypeSchema, Q as ApplyPatchToProjectWorkspaceFileRequest, U as ApplyPatchToProjectWorkspaceFileRequestSchema, W as ApplyProjectTypeRequest, X as ApplyProjectTypeRequestSchema, Y as ArchiveEntry, Z as ArchiveEntrySchema, _ as ArchiveExtractRequest, $ as ArchiveExtractRequestSchema, a0 as ArchiveExtractResponse, a1 as ArchiveExtractResponseSchema, a2 as ArchiveListRequest, a3 as ArchiveListRequestSchema, a4 as ArchiveListResponse, a5 as ArchiveListResponseSchema, a6 as ArgSpec, a7 as ArgSpecSchema, a8 as AskQuestionRequest, a9 as AskQuestionRequestSchema, aa as AskQuestionResponse, ab as AskQuestionResponseSchema, ac as AudioCatalogModel, ad as AudioCatalogModelSchema, ae as AudioEngineHealth, af as AudioEngineHealthSchema, ag as AudioEngineStatusResponse, ah as AudioEngineStatusResponseSchema, ai as AudioModelPullEvent, aj as AudioModelPullEventSchema, ak as AudioSynthesizeMeta, al as AudioSynthesizeMetaSchema, am as AudioSynthesizeRequest, an as AudioSynthesizeRequestSchema, ao as AudioSynthesizeResponse, ap as AudioSynthesizeResponseSchema, aq as AudioTranscribeRequest, ar as AudioTranscribeRequestSchema, as as AudioTranscribeResponse, at as AudioTranscribeResponseSchema, au as AudioTranscribeSegment, av as AudioTranscribeSegmentSchema, aw as AudioVoice, ax as AudioVoiceSchema, ay as BehaviorEntry, az as BehaviorEntrySchema, aA as BehaviorId, aB as BehaviorIdSchema, aC as BinaryDocumentCheck, aD as BinaryDocumentCheckSchema, aE as CANONICAL_PROFILES, aF as CRAFTBOOK_ROLE_META, aG as CRAFTBOOK_SCRIPTS_MAX_COUNT, aH as CRAFTBOOK_SCRIPTS_TOTAL_MAX_BYTES, aI as CRAFTBOOK_SCRIPT_MAX_BYTES, aJ as CRAFTBOOK_TEST_FILENAME, aK as CRAFTBOOK_TEST_SCHEMA_VERSION, aL as CancelCodeReviewResponse, aM as CancelCodeReviewResponseSchema, aN as CatalogItemDetail, aO as CatalogItemDetailSchema, aP as CatalogItemIdentity, aQ as CatalogItemIdentitySchema, aR as CatalogItemManifest, aS as CatalogItemManifestSchema, aT as CatalogItemSummary, aU as CatalogItemSummarySchema, aV as CatalogItemVersionInfo, aW as CatalogItemVersionInfoSchema, aX as CatalogKind, aY as CatalogKindSchema, aZ as ChannelName, a_ as ChannelNameSchema, a$ as ChannelStatus, b0 as ChannelStatusSchema, b1 as ChannelsConfig, b2 as ChannelsConfigSchema, b3 as ChatHistoryResponse, b4 as ChatHistoryResponseSchema, b5 as ChatModelCategory, b6 as ChatModelCategorySchema, b7 as ChatModelDs4Source, b8 as ChatModelDs4SourceSchema, b9 as ChatModelIdentity, ba as ChatModelIdentitySchema, bb as ChatModelLlamaCppSource, bc as ChatModelLlamaCppSourceSchema, bd as ChatModelManifest, be as ChatModelManifestSchema, bf as ChatModelMlxSource, bg as ChatModelMlxSourceSchema, bh as ChatModelOllamaSource, bi as ChatModelOllamaSourceSchema, bj as ChatModelTuning, bk as ChatModelTuningBase, bl as ChatModelTuningBaseSchema, bm as ChatModelTuningSchema, bn as ChatModelVersionManifest, bo as ChatModelVersionManifestSchema, bp as ChatSession, bq as ChatSessionSchema, br as ChatSessionSummary, bs as ChatSessionSummarySchema, bt as CodeReview, bu as CodeReviewKind, bv as CodeReviewKindSchema, bw as CodeReviewManifest, bx as CodeReviewManifestSchema, by as CodeReviewRecord, bz as CodeReviewRecordSchema, bA as CodeReviewResponse, bB as CodeReviewResponseSchema, bC as CodeReviewSchema, bD as CodeReviewStatus, bE as CodeReviewStatusSchema, bF as CodeSymbol, bG as CodeSymbolSchema, bH as CodexPermissionMode, bI as CodexPermissionModeCompat, bJ as CodexPermissionModeCompatSchema, bK as CodexPermissionModeSchema, bL as CodexSetupModelOption, bM as CodexSetupModelOptionSchema, bN as CodexSetupState, bO as CodexSetupStateSchema, bP as CodexSetupStatusResponse, bQ as CodexSetupStatusResponseSchema, bR as CommandApprovalIntent, bS as CommandApprovalIntentSchema, bT as CommandApprovalScope, bU as CommandApprovalScopeSchema, bV as CommandShape, bW as CommandShapeSchema, bX as CompassRegionSchema, bY as CompleteStepGateInfo, bZ as CompleteStepGateInfoSchema, b_ as CompleteStepRequest, b$ as CompleteStepRequestSchema, c0 as CompleteStepResponse, c1 as CompleteStepResponseSchema, c2 as ConfigureCodexRequest, c3 as ConfigureCodexRequestSchema, c4 as ConnectorTypeIdentity, c5 as ConnectorTypeIdentitySchema, c6 as ConnectorTypeManifest, c7 as ConnectorTypeManifestSchema, c8 as ConnectorTypeVersionManifest, c9 as ConnectorTypeVersionManifestSchema, ca as CopilotAvailability, cb as CopilotAvailabilitySchema, cc as CopilotLoginEvent, cd as CopilotLoginEventSchema, ce as CopyArtifactToWorkspaceRequest, cf as CopyArtifactToWorkspaceRequestSchema, cg as CopyArtifactToWorkspaceResponse, ch as CopyArtifactToWorkspaceResponseSchema, ci as CosmeticProposal, cj as CosmeticProposalSchema, ck as CraftbookBasedOn, cl as CraftbookBasedOnSchema, cm as CraftbookBranch, cn as CraftbookBranchSchema, co as CraftbookConnectorNeed, cp as CraftbookConnectorNeedSchema, cq as CraftbookRequirement, cr as CraftbookRequirementContext, cs as CraftbookRequirementSchema, ct as CraftbookResponse, cu as CraftbookResponseSchema, cv as CraftbookRole, cw as CraftbookRoleSchema, cx as CraftbookRunModes, cy as CraftbookRunModesSchema, cz as CraftbookSchema, cA as CraftbookScripts, cB as CraftbookScriptsSchema, cC as CraftbookSpawn, cD as CraftbookSpawnSchema, cE as CraftbookStepSchema, cF as CraftbookSuggestion, cG as CraftbookSuggestionSchema, cH as CraftbookSummary, cI as CraftbookSummarySchema, cJ as CraftbookTemplateIdentity, cK as CraftbookTemplateIdentitySchema, cL as CraftbookTemplateManifest, cM as CraftbookTemplateManifestSchema, cN as CraftbookTemplateVersionManifest, cO as CraftbookTemplateVersionManifestSchema, cP as CraftbookTestCheck, cQ as CraftbookTestCheckSchema, cR as CraftbookTestDeliverable, cS as CraftbookTestDeliverableSchema, cT as CraftbookTestFixtureFile, cU as CraftbookTestFixtureFileSchema, cV as CraftbookTestHistoryExpectation, cW as CraftbookTestHistoryExpectationSchema, cX as CraftbookTestMockExpectation, cY as CraftbookTestMockExpectationSchema, cZ as CraftbookTestRubric, c_ as CraftbookTestRubricSchema, c$ as CraftbookTestSetup, d0 as CraftbookTestSetupSchema, d1 as CraftbookTestSpec, d2 as CraftbookTestSpecSchema, d3 as CraftbookTestSuccess, d4 as CraftbookTestSuccessSchema, d5 as CraftbookTestWorker, d6 as CraftbookTestWorkerSchema, d7 as CraftbookToolsetNeed, d8 as CraftbookToolsetNeedSchema, d9 as CreateChatSessionRequest, da as CreateChatSessionRequestSchema, db as CreateCraftbookRequest, dc as CreateCraftbookRequestSchema, dd as CreateDocumentFolderRequest, de as CreateDocumentFolderRequestSchema, df as CreateGezelRequest, dg as CreateGezelRequestSchema, dh as CreatePreviewCapabilityRequest, di as CreatePreviewCapabilityRequestSchema, dj as CreatePreviewCapabilityResponse, dk as CreatePreviewCapabilityResponseSchema, dl as CreateProjectRequest, dm as CreateProjectRequestSchema, dn as CreateScriptRequest, dp as CreateScriptRequestSchema, dq as CreateScriptResponse, dr as CreateScriptResponseSchema, ds as CreateTaskRequest, dt as CreateTaskRequestSchema, du as CreateTypedProjectRequest, dv as CreateTypedProjectRequestSchema, dw as CreateTypedProjectResponse, dx as CreateTypedProjectResponseSchema, dy as CredentialCapabilitySchema, dz as CustomMcpImportWarning, dA as CustomMcpImportWarningSchema, dB as DEFAULT_LOCAL_ENGINE_IDLE_TIMEOUT_MS, dC as DEFAULT_TUNING_PROFILE_ID, dD as DeclineGrowthLevelUpRequest, dE as DeclineGrowthLevelUpRequestSchema, dF as DeclinedProposalRecord, dG as DeclinedProposalRecordSchema, dH as DelegateSecurityFindingRequest, dI as DelegateSecurityFindingRequestSchema, dJ as DelegateSecurityFindingResponse, dK as DelegateSecurityFindingResponseSchema, dL as DescribeFolderRequest, dM as DescribeFolderRequestSchema, dN as DescribeFolderResponse, dO as DescribeFolderResponseSchema, dP as DeviceSafetyPolicyConfig, dQ as DeviceSafetyPolicySchema, dR as DiffFilesRequest, dS as DiffFilesRequestSchema, dT as DiffFilesResponse, dU as DiffFilesResponseSchema, dV as DisableSuggestedWorkRequest, dW as DisableSuggestedWorkRequestSchema, dX as DiscoveredCommand, dY as DiscoveredCommandSchema, dZ as DiscoveredInstruction, d_ as DiscoveredInstructionSchema, d$ as DiscoveredSkill, e0 as DiscoveredSkillSchema, e1 as DismissSuggestedWorkRequest, e2 as DismissSuggestedWorkRequestSchema, e3 as DocumentExportOptions, e4 as DocumentExportOptionsSchema, e5 as DocumentMediaExportRequest, e6 as DocumentMediaExportRequestSchema, e7 as DocumentMediaExportSource, e8 as DocumentMediaExportSourceSchema, e9 as DocumentSearchResult, ea as DocumentSearchResultSchema, eb as DraftScriptRequest, ec as DraftScriptRequestSchema, ed as DraftScriptResponse, ee as DraftScriptResponseSchema, ef as DriveIndexEnrichmentRequest, eg as DriveIndexEnrichmentRequestSchema, eh as DriveIndexEnrichmentResponse, ei as DriveIndexEnrichmentResponseSchema, ej as DrySamplerConfig, ek as DrySamplerSchema, el as EnableSuggestedWorkRequest, em as EnableSuggestedWorkRequestSchema, en as EngineConfig, eo as EngineConfigSchema, ep as EnsureGezelRequest, eq as EnsureGezelRequestSchema, er as EnsureGezelResponse, es as EnsureGezelResponseSchema, et as Entity, eu as EntitySchema, ev as ErrorResponse, ew as ErrorResponseSchema, ex as EvalHints, ey as EvalHintsSchema, ez as ExpectedDeliverable, eA as ExpectedDeliverableSchema, eB as ExternalFolders, eC as ExternalFoldersSchema, eD as FetchDiffRequest, eE as FetchDiffRequestSchema, eF as FetchDiffResponse, eG as FetchDiffResponseSchema, eH as FetchRepoRequest, eI as FetchRepoRequestSchema, eJ as FetchRepoResponse, eK as FetchRepoResponseSchema, eL as FetchUrlRequest, eM as FetchUrlRequestSchema, eN as FetchUrlResponse, eO as FetchUrlResponseSchema, eP as FileContextFinding, eQ as FileContextFindingSchema, eR as FileContextImporter, eS as FileContextImporterSchema, eT as FileContextRequest, eU as FileContextRequestSchema, eV as FileContextResponseSchema, eW as FileMapRequest, eX as FileMapRequestSchema, eY as FileMapResponse, eZ as FileMapResponseSchema, e_ as FileMapScope, e$ as FileMapScopeSchema, f0 as FileReviewIssue, f1 as FileReviewIssueSchema, f2 as FileReviewIssueSeverity, f3 as FileReviewIssueSeveritySchema, f4 as FileReviewReply, f5 as FileReviewReplySchema, f6 as FileReviewRequest, f7 as FileReviewRequestSchema, f8 as FileReviewResponse, f9 as FileReviewResponseSchema, fa as FileReviewWire, fb as FileReviewWireSchema, fc as FindEntityRequest, fd as FindEntityRequestSchema, fe as FindEntityResponse, ff as FindEntityResponseSchema, fg as FindFilesRequest, fh as FindFilesRequestSchema, fi as FindFilesResponse, fj as FindFilesResponseSchema, fk as FindReferencesRequest, fl as FindReferencesRequestSchema, fm as FindReferencesResponse, fn as FindReferencesResponseSchema, fo as FindSimilarImagesRequest, fp as FindSimilarImagesRequestSchema, fq as FindSimilarImagesResponse, fr as FindSimilarImagesResponseSchema, fs as FindSymbolRequest, ft as FindSymbolRequestSchema, fu as FindSymbolResponse, fv as FindSymbolResponseSchema, fw as FitnessCheck, fx as FitnessCheckSchema, fy as FlagSpec, fz as FlagSpecSchema, fA as GATE_DEFAULT_MAX_ATTEMPTS, fB as GateAttemptRecord, fC as GateCheckSchema, fD as GateScriptRefSchema, fE as GateScriptResult, fF as GateScriptResultSchema, fG as GateSpec, fH as GateSpecSchema, fI as GenerateGezelAboutRequest, fJ as GenerateGezelAboutRequestSchema, fK as GenerateGezelIconRequest, fL as GenerateGezelIconRequestSchema, fM as GetScriptSourceResponse, fN as GetScriptSourceResponseSchema, fO as GezelConfigSchema, fP as GezelGrowthResponse, fQ as GezelGrowthResponseSchema, fR as GezelGrowthState, fS as GezelGrowthStateSchema, fT as GezelGrowthSummary, fU as GezelGrowthSummarySchema, fV as GezelIconHistoryEntrySchema, fW as GezelIconHistoryResponse, fX as GezelIconHistoryResponseSchema, fY as GezelResponse, fZ as GezelResponseSchema, f_ as GezelTemplateIdentity, f$ as GezelTemplateIdentitySchema, g0 as GezelTemplateManifest, g1 as GezelTemplateManifestSchema, g2 as GezelTemplateVersionManifest, g3 as GezelTemplateVersionManifestSchema, g4 as GezmodelBundleManifest, g5 as GezmodelBundleManifestSchema, g6 as GezmodelEngine, g7 as GezmodelEngineSchema, g8 as GezmodelFile, g9 as GezmodelFileSchema, ga as GezmodelImportReview, gb as GezmodelImportReviewSchema, gc as GezmodelLicense, gd as GezmodelLicenseSchema, ge as GildeUpdateCheckOutcome, gf as GildeUpdateCheckOutcomeSchema, gg as GildeUpdateCheckResult, gh as GildeUpdateCheckResultSchema, gi as GildeUpdateStatusResponse, gj as GildeUpdateStatusResponseSchema, gk as GitAbandonMergeResponse, gl as GitAbandonMergeResponseSchema, gm as GitAiMergeRequest, gn as GitAiMergeRequestSchema, go as GitAiMergeResponse, gp as GitAiMergeResponseSchema, gq as GitBranchSwitchRequest, gr as GitBranchSwitchRequestSchema, gs as GitBranchesResponse, gt as GitBranchesResponseSchema, gu as GitChangeKind, gv as GitChangeKindSchema, gw as GitChangesResponse, gx as GitChangesResponseSchema, gy as GitCloneResponse, gz as GitCloneResponseSchema, gA as GitCommitDetailResponse, gB as GitCommitDetailResponseSchema, gC as GitCommitRequest, gD as GitCommitRequestSchema, gE as GitCommitResponse, gF as GitCommitResponseSchema, gG as GitCompleteMergeRequest, gH as GitCompleteMergeRequestSchema, gI as GitCompleteMergeResponse, gJ as GitCompleteMergeResponseSchema, gK as GitConflictFile, gL as GitConflictFileSchema, gM as GitConflictKind, gN as GitConflictKindSchema, gO as GitConflictVersionsResponse, gP as GitConflictVersionsResponseSchema, gQ as GitDiscardRequest, gR as GitDiscardRequestSchema, gS as GitDiscardResponse, gT as GitDiscardResponseSchema, gU as GitFetchResponse, gV as GitFetchResponseSchema, gW as GitFileDiffResponse, gX as GitFileDiffResponseSchema, gY as GitHubAuthMeta, gZ as GitHubAuthMetaSchema, g_ as GitHubCheckStatusResponse, g$ as GitHubCheckStatusResponseSchema, h0 as GitHubCreateCommentRequest, h1 as GitHubCreateCommentRequestSchema, h2 as GitHubCreateCommentResponse, h3 as GitHubCreateCommentResponseSchema, h4 as GitHubCreatePullRequest, h5 as GitHubCreatePullRequestSchema, h6 as GitHubCreatePullResponse, h7 as GitHubCreatePullResponseSchema, h8 as GitHubCredentialSource, h9 as GitHubIdentity, ha as GitHubIdentityResponse, hb as GitHubIdentityResponseSchema, hc as GitHubIdentitySchema, hd as GitHubLoginPollRequest, he as GitHubLoginPollRequestSchema, hf as GitHubLoginPollResponse, hg as GitHubLoginPollResponseSchema, hh as GitHubLoginStartResponse, hi as GitHubLoginStartResponseSchema, hj as GitHubPullComment, hk as GitHubPullCommentSchema, hl as GitHubPullDetail, hm as GitHubPullDetailSchema, hn as GitHubPullDiffResponse, ho as GitHubPullDiffResponseSchema, hp as GitHubPullFile, hq as GitHubPullFileSchema, hr as GitHubPullSummary, hs as GitHubPullSummarySchema, ht as GitHubRepoPreviewRequest, hu as GitHubRepoPreviewRequestSchema, hv as GitHubRepoPreviewResponse, hw as GitHubRepoPreviewResponseSchema, hx as GitHubRepoSummary, hy as GitHubRepoSummarySchema, hz as GitHubReposResponse, hA as GitHubReposResponseSchema, hB as GitHubWorkflowRun, hC as GitHubWorkflowRunSchema, hD as GitLogEntry, hE as GitLogEntrySchema, hF as GitLogResponse, hG as GitLogResponseSchema, hH as GitMergeStateResponse, hI as GitMergeStateResponseSchema, hJ as GitPushResponse, hK as GitPushResponseSchema, hL as GitResolveConflictRequest, hM as GitResolveConflictRequestSchema, hN as GitResolveConflictResponse, hO as GitResolveConflictResponseSchema, hP as GitStatusResponse, hQ as GitStatusResponseSchema, hR as GitSuggestMessageResponse, hS as GitSuggestMessageResponseSchema, hT as GitSyncResponse, hU as GitSyncResponseSchema, hV as GitSyncState, hW as GitSyncStateSchema, hX as GitWorkingChange, hY as GitWorkingChangeSchema, hZ as GithubAbandonMergeResponse, h_ as GithubAbandonMergeResponseSchema, h$ as GithubAiMergeRequest, i0 as GithubAiMergeRequestSchema, i1 as GithubAiMergeResponse, i2 as GithubAiMergeResponseSchema, i3 as GithubAuthMeta, i4 as GithubAuthMetaSchema, i5 as GithubBranchSwitchRequest, i6 as GithubBranchSwitchRequestSchema, i7 as GithubBranchesResponse, i8 as GithubBranchesResponseSchema, i9 as GithubChangeKind, ia as GithubChangeKindSchema, ib as GithubChangesResponse, ic as GithubChangesResponseSchema, id as GithubCheckStatusResponse, ie as GithubCheckStatusResponseSchema, ig as GithubCloneResponse, ih as GithubCloneResponseSchema, ii as GithubCommitDetailResponse, ij as GithubCommitDetailResponseSchema, ik as GithubCommitRequest, il as GithubCommitRequestSchema, im as GithubCommitResponse, io as GithubCommitResponseSchema, ip as GithubCompleteMergeRequest, iq as GithubCompleteMergeRequestSchema, ir as GithubCompleteMergeResponse, is as GithubCompleteMergeResponseSchema, it as GithubConflictFile, iu as GithubConflictFileSchema, iv as GithubConflictKind, iw as GithubConflictKindSchema, ix as GithubConflictVersionsResponse, iy as GithubConflictVersionsResponseSchema, iz as GithubCreateCommentRequest, iA as GithubCreateCommentRequestSchema, iB as GithubCreateCommentResponse, iC as GithubCreateCommentResponseSchema, iD as GithubCreatePullRequest, iE as GithubCreatePullRequestSchema, iF as GithubCreatePullResponse, iG as GithubCreatePullResponseSchema, iH as GithubCredentialSource, iI as GithubDiscardRequest, iJ as GithubDiscardRequestSchema, iK as GithubDiscardResponse, iL as GithubDiscardResponseSchema, iM as GithubFetchResponse, iN as GithubFetchResponseSchema, iO as GithubFileDiffResponse, iP as GithubFileDiffResponseSchema, iQ as GithubIdentity, iR as GithubIdentityResponse, iS as GithubIdentityResponseSchema, iT as GithubIdentitySchema, iU as GithubLogEntry, iV as GithubLogEntrySchema, iW as GithubLogResponse, iX as GithubLogResponseSchema, iY as GithubLoginPollRequest, iZ as GithubLoginPollRequestSchema, i_ as GithubLoginPollResponse, i$ as GithubLoginPollResponseSchema, j0 as GithubLoginStartResponse, j1 as GithubLoginStartResponseSchema, j2 as GithubMergeStateResponse, j3 as GithubMergeStateResponseSchema, j4 as GithubPullComment, j5 as GithubPullCommentSchema, j6 as GithubPullDetail, j7 as GithubPullDetailSchema, j8 as GithubPullDiffResponse, j9 as GithubPullDiffResponseSchema, ja as GithubPullFile, jb as GithubPullFileSchema, jc as GithubPullSummary, jd as GithubPullSummarySchema, je as GithubPushResponse, jf as GithubPushResponseSchema, jg as GithubRepoPreviewRequest, jh as GithubRepoPreviewRequestSchema, ji as GithubRepoPreviewResponse, jj as GithubRepoPreviewResponseSchema, jk as GithubRepoSummary, jl as GithubRepoSummarySchema, jm as GithubReposResponse, jn as GithubReposResponseSchema, jo as GithubResolveConflictRequest, jp as GithubResolveConflictRequestSchema, jq as GithubResolveConflictResponse, jr as GithubResolveConflictResponseSchema, js as GithubStatusResponse, jt as GithubStatusResponseSchema, ju as GithubSuggestMessageResponse, jv as GithubSuggestMessageResponseSchema, jw as GithubSyncResponse, jx as GithubSyncResponseSchema, jy as GithubSyncState, jz as GithubSyncStateSchema, jA as GithubWorkflowRun, jB as GithubWorkflowRunSchema, jC as GithubWorkingChange, jD as GithubWorkingChangeSchema, jE as GpuProcessMemory, jF as GpuProcessMemorySchema, jG as GpuProcessOwner, jH as GpuProcessOwnerSchema, jI as GrepArtifactRequest, jJ as GrepArtifactRequestSchema, jK as GrepArtifactResponse, jL as GrepArtifactResponseSchema, jM as GrowthEvidence, jN as GrowthEvidenceSchema, jO as GrowthProposal, jP as GrowthProposalSchema, jQ as GrowthSignals, jR as GrowthSignalsSchema, jS as GzelBundleItem, jT as GzelBundleItemSchema, jU as GzelBundleManifest, jV as GzelBundleManifestSchema, jW as HandboekArea, jX as HandboekAreaSchema, jY as HandboekArticle, jZ as HandboekArticleSchema, j_ as HandboekFigure, j$ as HandboekFigureSchema, k0 as HandboekHowDoIResponse, k1 as HandboekHowDoIResponseSchema, k2 as HandboekNarrationResponse, k3 as HandboekNarrationResponseSchema, k4 as HandboekNarrationSegment, k5 as HandboekNarrationSegmentSchema, k6 as HandboekRenderMode, k7 as HandboekRenderModeSchema, k8 as HandboekToc, k9 as HandboekTocArea, ka as HandboekTocAreaSchema, kb as HandboekTocEntry, kc as HandboekTocEntrySchema, kd as HandboekTocSchema, ke as HealthResponse, kf as HealthResponseSchema, kg as HistoryEntry, kh as HistoryEntrySchema, ki as HistoryEvent, kj as HistoryEventEntrySchema, kk as HistoryEventKind, kl as HistoryEventKindSchema, km as HistoryEventSchema, kn as HistoryFilter, ko as HistoryFilterSchema, kp as HistorySessionEntry, kq as HistorySessionEntrySchema, kr as HookDecision, ks as HookDecisionSchema, kt as HookPhase, ku as HookPhaseSchema, kv as HookResult, kw as HookResultSchema, kx as HookSpec, ky as HookSpecSchema, kz as HtmlLayer, kA as HtmlLayerSchema, kB as HttpsOriginSchema, kC as ImageEngineStatusResponse, kD as ImageEngineStatusResponseSchema, kE as ImageExif, kF as ImageExifSchema, kG as ImageGenerationApprovalIntent, kH as ImageGenerationApprovalIntentSchema, kI as ImageGenerationMeta, kJ as ImageGenerationMetaSchema, kK as ImageGenerationRequest, kL as ImageGenerationRequestSchema, kM as ImageGenerationResponse, kN as ImageGenerationResponseSchema, kO as ImageInputSource, kP as ImageInputSourceSchema, kQ as ImageLayer, kR as ImageLayerSchema, kS as ImageModelAuxiliaryFile, kT as ImageModelAuxiliaryFileSchema, kU as ImageModelAuxiliaryRole, kV as ImageModelAuxiliaryRoleSchema, kW as ImageModelCategory, kX as ImageModelCategorySchema, kY as ImageModelHardwareTier, kZ as ImageModelHardwareTierSchema, k_ as ImageModelIdentity, k$ as ImageModelIdentitySchema, l0 as ImageModelManifest, l1 as ImageModelManifestSchema, l2 as ImageModelPullEvent, l3 as ImageModelPullEventSchema, l4 as ImageModelVersionManifest, l5 as ImageModelVersionManifestSchema, l6 as ImageRecognition, l7 as ImageRecognitionSchema, l8 as ImageStaticMeta, l9 as ImageStaticMetaSchema, la as ImportCustomMcpConfigRequest, lb as ImportCustomMcpConfigRequestSchema, lc as ImportCustomMcpConfigResponse, ld as ImportCustomMcpConfigResponseSchema, le as ImportProvenance, lf as ImportProvenanceSchema, lg as ImportedAboutProvenance, lh as ImportedAboutProvenanceSchema, li as ImportedCraftbookProvenance, lj as ImportedCraftbookProvenanceSchema, lk as ImportedGezelProvenance, ll as ImportedGezelProvenanceSchema, lm as InsertAtMarkerInProjectWorkspaceFileRequest, ln as InsertAtMarkerInProjectWorkspaceFileRequestSchema, lo as InstallPackageRequest, lp as InstallPackageRequestSchema, lq as InstallPackageResponse, lr as InstallPackageResponseSchema, ls as InstalledAudioModel, lt as InstalledAudioModelSchema, lu as InstalledImageModel, lv as InstalledImageModelSchema, lw as InstalledPackage, lx as InstalledPackageSchema, ly as InstalledRecognitionModel, lz as InstalledRecognitionModelSchema, lA as InstalledToolset, lB as InstalledToolsetSchema, lC as InstalledVideoModel, lD as InstalledVideoModelSchema, lE as InstructionMergeMode, lF as InstructionMergeModeSchema, lG as InstructionSourceFile, lH as InstructionSourceFileSchema, lI as InterruptSessionRequest, lJ as InterruptSessionRequestSchema, lK as InvokePageToolRequest, lL as InvokePageToolRequestSchema, lM as InvokePageToolResponse, lN as InvokePageToolResponseSchema, lO as InvokeSessionToolRequest, lP as InvokeSessionToolRequestSchema, lQ as InvokeSessionToolResponse, lR as InvokeSessionToolResponseSchema, lS as KNOWN_PROFILE_IDS, lT as KeurmeesterAction, lU as KeurmeesterActionSchema, lV as KeurmeesterCaseClosed, lW as KeurmeesterCaseClosedSchema, lX as KeurmeesterCaseOpened, lY as KeurmeesterCaseOpenedSchema, lZ as KeurmeesterCaseOutcome, l_ as KeurmeesterCaseOutcomeSchema, l$ as KeurmeesterCaseRecord, m0 as KeurmeesterCaseRecordSchema, m1 as KeurmeesterFailureClass, m2 as KeurmeesterFailureClassSchema, m3 as KeurmeesterTriggerKind, m4 as KeurmeesterTriggerKindSchema, m5 as KeurmeesterVerdict, m6 as KeurmeesterVerdictSchema, m7 as KnownProfileId, m8 as LEVEL_THRESHOLDS, m9 as Layer, ma as LayerSchema, mb as LegacyCodexPermissionMode, mc as LegacyCodexPermissionModeSchema, md as LicenseClass, me as LicenseClassSchema, mf as LicenseMetaShape, mg as ListActiveImagePullsResponse, mh as ListActiveImagePullsResponseSchema, mi as ListActiveVideoPullsResponse, mj as ListActiveVideoPullsResponseSchema, mk as ListAudioCatalogResponse, ml as ListAudioCatalogResponseSchema, mm as ListAudioVoicesResponse, mn as ListAudioVoicesResponseSchema, mo as ListCatalogItemVersionsResponse, mp as ListCatalogItemVersionsResponseSchema, mq as ListCatalogItemsResponse, mr as ListCatalogItemsResponseSchema, ms as ListChatSessionsResponse, mt as ListChatSessionsResponseSchema, mu as ListCodeReviewsResponse, mv as ListCodeReviewsResponseSchema, mw as ListCraftbooksResponse, mx as ListCraftbooksResponseSchema, my as ListDependenciesResponse, mz as ListDependenciesResponseSchema, mA as ListEntityMentionsRequest, mB as ListEntityMentionsRequestSchema, mC as ListEntityMentionsResponse, mD as ListEntityMentionsResponseSchema, mE as ListFileIssuesRequest, mF as ListFileIssuesRequestSchema, mG as ListFileIssuesResponse, mH as ListFileIssuesResponseSchema, mI as ListGezelsResponse, mJ as ListGezelsResponseSchema, mK as ListGitHubPullCommentsResponse, mL as ListGitHubPullCommentsResponseSchema, mM as ListGitHubPullFilesResponse, mN as ListGitHubPullFilesResponseSchema, mO as ListGitHubPullsResponse, mP as ListGitHubPullsResponseSchema, mQ as ListGitHubWorkflowRunsResponse, mR as ListGitHubWorkflowRunsResponseSchema, mS as ListGithubPullCommentsResponse, mT as ListGithubPullCommentsResponseSchema, mU as ListGithubPullFilesResponse, mV as ListGithubPullFilesResponseSchema, mW as ListGithubPullsResponse, mX as ListGithubPullsResponseSchema, mY as ListGithubWorkflowRunsResponse, mZ as ListGithubWorkflowRunsResponseSchema, m_ as ListHistoryResponse, m$ as ListHistoryResponseSchema, n0 as ListInstalledAudioModelsResponse, n1 as ListInstalledAudioModelsResponseSchema, n2 as ListInstalledImageModelsResponse, n3 as ListInstalledImageModelsResponseSchema, n4 as ListInstalledRecognitionModelsResponse, n5 as ListInstalledRecognitionModelsResponseSchema, n6 as ListInstalledVideoModelsResponse, n7 as ListInstalledVideoModelsResponseSchema, n8 as ListMentionCandidatesResponse, n9 as ListMentionCandidatesResponseSchema, na as ListModelsResponse, nb as ListModelsResponseSchema, nc as ListPackageScriptsResponse, nd as ListPackageScriptsResponseSchema, ne as ListProjectsForGezelResponse, nf as ListProjectsForGezelResponseSchema, ng as ListProjectsResponse, nh as ListProjectsResponseSchema, ni as ListQuestionsResponse, nj as ListQuestionsResponseSchema, nk as ListRecognitionCatalogResponse, nl as ListRecognitionCatalogResponseSchema, nm as ListScriptsResponse, nn as ListScriptsResponseSchema, no as ListSessionQueueResponse, np as ListSessionQueueResponseSchema, nq as ListSessionToolsResponse, nr as ListSessionToolsResponseSchema, ns as ListTaskNotesResponse, nt as ListTaskNotesResponseSchema, nu as ListTasksResponse, nv as ListTasksResponseSchema, nw as ListTerminalThreadsResponse, nx as ListTerminalThreadsResponseSchema, ny as ListTimelineResponse, nz as ListTimelineResponseSchema, nA as LlamaCppContextSizing, nB as LlamaCppContextSizingResponse, nC as LlamaCppContextSizingResponseSchema, nD as LlamaCppContextSizingSchema, nE as LlamaCppEngineConfig, nF as LlamaCppEngineConfigSchema, nG as LocalEngineLifecycle, nH as LocalEngineLifecycleSchema, nI as MEESTER_STATUS_HEADLINE_MAX, nJ as MODEL_TIER_ORDER, nK as MachineMemoryKind, nL as MachineMemoryKindSchema, nM as MachineMemoryUsage, nN as MachineMemoryUsageSchema, nO as MapAttackSurfaceResponse, nP as MapAttackSurfaceResponseSchema, nQ as MapBlock, nR as MapBlockHealth, nS as MapBlockHealthSchema, nT as MapBlockSchema, nU as MapBuildingSchema, nV as MapDistrictSchema, nW as MapPlazaSchema, nX as MapPrChange, nY as MapPrChangeSchema, nZ as MapPrOverlay, n_ as MapPrOverlaySchema, n$ as MapRepoRequest, o0 as MapRepoRequestSchema, o1 as MapRepoResponse, o2 as MapRepoResponseSchema, o3 as MapRoad, o4 as MapRoadSchema, o5 as MapStreetSchema, o6 as MapUrbanity, o7 as MapUrbanitySchema, o8 as McpToolInfo, o9 as McpToolInfoSchema, oa as MeesterStatusAction, ob as MeesterStatusActionSchema, oc as MeesterStatusCta, od as MeesterStatusCtaSchema, oe as MeesterStatusModelOutput, of as MeesterStatusModelOutputSchema, og as MeesterStatusReport, oh as MeesterStatusReportSchema, oi as MeesterStatusResponse, oj as MeesterStatusResponseSchema, ok as MeesterStatusState, ol as MeesterStatusStateSchema, om as MentionCandidate, on as MentionCandidateSchema, oo as MessageGezelRequest, op as MessageGezelRequestSchema, oq as MessageGezelResponse, or as MessageGezelResponseSchema, os as MessageImageDigest, ot as MessageImageDigestSchema, ou as MinGezelVersionShape, ov as MlxRuntimeStatus, ow as MlxRuntimeStatusSchema, ox as MockHttpRoute, oy as MockHttpRouteSchema, oz as MockService, oA as MockServiceSchema, oB as ModelContextOverrideUpdate, oC as ModelContextOverrideUpdateSchema, oD as ModelContextOverridesResponse, oE as ModelContextOverridesResponseSchema, oF as ModelDownloadPreflightRequest, oG as ModelDownloadPreflightRequestSchema, oH as ModelDownloadPreflightResponse, oI as ModelDownloadPreflightResponseSchema, oJ as ModelFamily, oK as ModelFamilySchema, oL as ModelFitnessRecordSchema, oM as ModelFitnessStatus, oN as ModelFitnessStatusSchema, oO as ModelFitnessTrigger, oP as ModelFitnessTriggerSchema, oQ as ModelInfo, oR as ModelInfoSchema, oS as ModelStyle, oT as ModelStyleSchema, oU as ModelTierSchema, oV as NamedScriptCapability, oW as NamedScriptCapabilitySchema, oX as NativeEngineInstallStatus, oY as NativeEngineInstallStatusSchema, oZ as NativeEngineName, o_ as NativeEngineNameSchema, o$ as NativeEngineResolveEvent, p0 as NativeEngineResolveEventSchema, p1 as NativeEngineStatusResponse, p2 as NativeEngineStatusResponseSchema, p3 as NewCraftbookStepSchema, p4 as NewTaskFanout, p5 as NewTaskFanoutSchema, p6 as NewTaskStep, p7 as NewTaskStepSchema, p8 as NightShiftBackgroundWorkBrief, p9 as NightShiftBackgroundWorkBriefSchema, pa as NightShiftCompletedTask, pb as NightShiftCompletedTaskSchema, pc as NightShiftReport, pd as NightShiftReportSchema, pe as NightShiftReviewIntent, pf as NightShiftReviewIntentSchema, pg as NightShiftReviewResponse, ph as NightShiftReviewResponseSchema, pi as NightShiftTaskBrief, pj as NightShiftTaskBriefSchema, pk as NightShiftTasksResponse, pl as NightShiftTasksResponseSchema, pm as NodeScriptPassesCheck, pn as NodeScriptPassesCheckSchema, po as NormalizedStepGate, pp as NpmInstallApprovalDecision, pq as NpmInstallApprovalDecisionSchema, pr as NpmInstallApprovalPackage, ps as NpmInstallApprovalPackageSchema, pt as OutcomeSchema, pu as OutlineFileRequest, pv as OutlineFileRequestSchema, pw as OutlineFileResponse, px as OutlineFileResponseSchema, py as PageCheckRequest, pz as PageCheckRequestSchema, pA as PageCheckResponse, pB as PageCheckResponseSchema, pC as ParseCraftbookTestSpecOptions, pD as ParseCraftbookTestSpecResult, pE as PendingImportItem, pF as PendingImportItemSchema, pG as PendingImports, pH as PendingImportsSchema, pI as PendingLevelUp, pJ as PendingLevelUpSchema, pK as PendingPersona, pL as PendingPersonaSchema, pM as PendingScript, pN as PendingScriptSchema, pO as PixelsLayer, pP as PixelsLayerSchema, pQ as PreviewLogEntry, pR as PreviewLogEntrySchema, pS as PreviewSource, pT as PreviewSourceSchema, pU as ProfileKind, pV as ProfileMeta, pW as ProjectAboutPreviewRequest, pX as ProjectAboutPreviewRequestSchema, pY as ProjectAboutPreviewResponse, pZ as ProjectAboutPreviewResponseSchema, p_ as ProjectActivity, p$ as ProjectActivitySchema, q0 as ProjectApprovalsResponse, q1 as ProjectApprovalsResponseSchema, q2 as ProjectConnectorBinding, q3 as ProjectConnectorBindingSchema, q4 as ProjectCraftbookProvenance, q5 as ProjectCraftbookProvenanceSchema, q6 as ProjectDetail, q7 as ProjectDetailSchema, q8 as ProjectFileEntry, q9 as ProjectFileEntrySchema, qa as ProjectFolderPreviewRequest, qb as ProjectFolderPreviewRequestSchema, qc as ProjectFolderPreviewResponse, qd as ProjectFolderPreviewResponseSchema, qe as ProjectForGezel, qf as ProjectForGezelSchema, qg as ProjectGitHub, qh as ProjectGitHubSchema, qi as ProjectGithub, qj as ProjectGithubSchema, qk as ProjectLocalConfig, ql as ProjectLocalConfigSchema, qm as ProjectNudgeConfig, qn as ProjectNudgeConfigSchema, qo as ProjectNudgeState, qp as ProjectNudgeStateSchema, qq as ProjectResponse, qr as ProjectResponseSchema, qs as ProjectSchema, qt as ProjectTabVisibility, qu as ProjectTabVisibilitySchema, qv as ProjectTypeCategory, qw as ProjectTypeCategorySchema, qx as ProjectTypeGezelRef, qy as ProjectTypeGezelSchema, qz as ProjectTypeIdentity, qA as ProjectTypeIdentitySchema, qB as ProjectTypeManifest, qC as ProjectTypeManifestSchema, qD as ProjectTypePages, qE as ProjectTypePagesSchema, qF as ProjectTypePreviewRead, qG as ProjectTypePreviewReadSchema, qH as ProjectTypeProvenance, qI as ProjectTypeProvenanceSchema, qJ as ProjectTypeSchedule, qK as ProjectTypeScheduleSchema, qL as ProjectTypeTool, qM as ProjectTypeToolReaction, qN as ProjectTypeToolReactionSchema, qO as ProjectTypeToolSchema, qP as ProjectTypeToolsetRef, qQ as ProjectTypeToolsetSchema, qR as ProjectTypeVersionManifest, qS as ProjectTypeVersionManifestSchema, qT as PrometheusAlertsCheck, qU as PrometheusAlertsCheckSchema, qV as PromptTags, qW as PromptTagsSchema, qX as Question, qY as QuestionAnswer, qZ as QuestionAnswerSchema, q_ as QuestionIntent, q$ as QuestionIntentSchema, r0 as QuestionSchema, r1 as QueuedMessage, r2 as QueuedMessageSchema, r3 as ReadArtifactSliceOpts, r4 as ReadArtifactSliceOptsSchema, r5 as ReadArtifactSliceResponse, r6 as ReadArtifactSliceResponseSchema, r7 as ReadDocAsMarkdownRequest, r8 as ReadDocAsMarkdownRequestSchema, r9 as ReadDocAsMarkdownResponse, ra as ReadDocAsMarkdownResponseSchema, rb as ReadImageBase64Request, rc as ReadImageBase64RequestSchema, rd as ReadImageBase64Response, re as ReadImageBase64ResponseSchema, rf as ReadSymbolRequest, rg as ReadSymbolRequestSchema, rh as ReadSymbolResponse, ri as ReadSymbolResponseSchema, rj as ReadWorkspaceFilesRequest, rk as ReadWorkspaceFilesRequestSchema, rl as ReadWorkspaceFilesResponse, rm as ReadWorkspaceFilesResponseSchema, rn as ReasoningBlock, ro as ReasoningBlockSchema, rp as ReasoningFormat, rq as ReasoningFormatSchema, rr as RecentTab, rs as RecentTabArea, rt as RecentTabAreaSchema, ru as RecentTabSchema, rv as RecoMetaShape, rw as RecognitionCatalogEntry, rx as RecognitionCatalogEntrySchema, ry as RecognitionHealth, rz as RecognitionHealthSchema, rA as RecognitionMode, rB as RecognitionModeRequest, rC as RecognitionModeRequestSchema, rD as RecognitionModeSchema, rE as RecognitionPullEvent, rF as RecognitionPullEventSchema, rG as RecognitionRequest, rH as RecognitionRequestSchema, rI as RecognitionResponse, rJ as RecognitionResponseSchema, rK as RectSchema, rL as ReferenceFileLocationRequest, rM as ReferenceFileLocationRequestSchema, rN as ReferenceFileLocationResponse, rO as ReferenceFileLocationResponseSchema, rP as ReferencePreviewRequest, rQ as ReferencePreviewRequestSchema, rR as ReferencePreviewResponse, rS as ReferencePreviewResponseSchema, rT as RemoteServingConfig, rU as RemoteServingConfigSchema, rV as RenameDocumentRequest, rW as RenameDocumentRequestSchema, rX as RenameGezelRequest, rY as RenameGezelRequestSchema, rZ as RenderImageRequest, r_ as RenderImageRequestSchema, r$ as RenderImageResponse, s0 as RenderImageResponseSchema, s1 as ReplaceInProjectWorkspaceFileRequest, s2 as ReplaceInProjectWorkspaceFileRequestSchema, s3 as ReplaceLinesInProjectWorkspaceFileRequest, s4 as ReplaceLinesInProjectWorkspaceFileRequestSchema, s5 as ReportPreviewLogRequest, s6 as ReportPreviewLogRequestSchema, s7 as RequestAskRequest, s8 as RequestAskRequestSchema, s9 as RequestAskResponse, sa as RequestAskResponseSchema, sb as RequestPermissionRequest, sc as RequestPermissionRequestSchema, sd as RequestPermissionResponse, se as RequestPermissionResponseSchema, sf as RerollGezelPoppetjeRequest, sg as RerollGezelPoppetjeRequestSchema, sh as ResidentEngineModel, si as ResidentEngineModelSchema, sj as ResolveArtifactResponse, sk as ResolveArtifactResponseSchema, sl as ResolveSecurityFindingRequest, sm as ResolveSecurityFindingRequestSchema, sn as ResolveSecurityFindingResponse, so as ResolveSecurityFindingResponseSchema, sp as RevertGezelIconRequest, sq as RevertGezelIconRequestSchema, sr as RewriteTextContext, ss as RewriteTextContextSchema, st as RewriteTextRequest, su as RewriteTextRequestSchema, sv as RewriteTextResponse, sw as RewriteTextResponseSchema, sx as RunGitRequest, sy as RunGitRequestSchema, sz as RunGitResponse, sA as RunGitResponseSchema, sB as RunNpxRequest, sC as RunNpxRequestSchema, sD as RunNpxResponse, sE as RunNpxResponseSchema, sF as RunPackageScriptRequest, sG as RunPackageScriptRequestSchema, sH as RunPackageScriptResponse, sI as RunPackageScriptResponseSchema, sJ as RunScriptRequest, sK as RunScriptRequestSchema, sL as RunScriptResponse, sM as RunScriptResponseSchema, sN as RunTerminalCommandRequest, sO as RunTerminalCommandRequestSchema, sP as RunTerminalCommandResponse, sQ as RunTerminalCommandResponseSchema, sR as SamplingBlock, sS as SamplingBlockSchema, sT as SaveScriptSourceRequest, sU as SaveScriptSourceRequestSchema, sV as SaveScriptSourceResponse, sW as SaveScriptSourceResponseSchema, sX as ScanFindingsRequest, sY as ScanFindingsRequestSchema, sZ as ScanFindingsResponse, s_ as ScanFindingsResponseSchema, s$ as ScheduleApprovalIntent, t0 as ScheduleApprovalIntentSchema, t1 as ScheduleMaterialization, t2 as ScheduleMaterializationSchema, t3 as ScriptArrayOutputSchema, t4 as ScriptBooleanInputSchema, t5 as ScriptBooleanOutputSchema, t6 as ScriptCapability, t7 as ScriptCapabilitySchema, t8 as ScriptChoiceInputSchema, t9 as ScriptDiagnostic, ta as ScriptDiagnosticSchema, tb as ScriptInputError, tc as ScriptInputFieldSchema, td as ScriptInputs, te as ScriptInputsSchema, tf as ScriptJsonInputSchema, tg as ScriptJsonOutputSchema, th as ScriptMetaSchema, ti as ScriptNameSchema, tj as ScriptNumberInputSchema, tk as ScriptNumberOutputSchema, tl as ScriptObjectOutputSchema, tm as ScriptOutputFieldSchema, tn as ScriptOutputPredicate, to as ScriptOutputPredicateSchema, tp as ScriptOutputs, tq as ScriptOutputsSchema, tr as ScriptProvenance, ts as ScriptProvenanceSchema, tt as ScriptRef, tu as ScriptRefInputSchema, tv as ScriptRefList, tw as ScriptRefListSchema, tx as ScriptRefSchema, ty as ScriptRun, tz as ScriptRunCall, tA as ScriptRunCallSchema, tB as ScriptRunSchema, tC as ScriptRunStatus, tD as ScriptRunStatusSchema, tE as ScriptRunTrigger, tF as ScriptRunTriggerSchema, tG as ScriptScope, tH as ScriptScopeSchema, tI as ScriptStringInputSchema, tJ as ScriptStringOutputSchema, tK as ScriptTemplateId, tL as ScriptTemplateIdSchema, tM as SdkTypesResponse, tN as SdkTypesResponseSchema, tO as SearchCodeRequest, tP as SearchCodeRequestSchema, tQ as SearchCodeResponse, tR as SearchCodeResponseSchema, tS as SearchDocsRequest, tT as SearchDocsRequestSchema, tU as SearchDocsResponse, tV as SearchDocsResponseSchema, tW as SearchDocumentsRequest, tX as SearchDocumentsRequestSchema, tY as SearchDocumentsResponse, tZ as SearchDocumentsResponseSchema, t_ as SearchFilesContextLine, t$ as SearchFilesContextLineSchema, u0 as SearchFilesMatch, u1 as SearchFilesMatchSchema, u2 as SearchFilesRequest, u3 as SearchFilesRequestSchema, u4 as SearchFilesResponse, u5 as SearchFilesResponseSchema, u6 as SearchImagesRequest, u7 as SearchImagesRequestSchema, u8 as SearchImagesResponse, u9 as SearchImagesResponseSchema, ua as SearchResult, ub as SearchResultSchema, uc as SearchSessionsRequest, ud as SearchSessionsRequestSchema, ue as SearchSessionsResponse, uf as SearchSessionsResponseSchema, ug as SecurityDependency, uh as SecurityDependencySchema, ui as SecurityFindingSchema, uj as SecurityFindingStatus, uk as SecurityFindingStatusSchema, ul as SecurityFindingWire, um as SecurityOverviewResponse, un as SecurityOverviewResponseSchema, uo as SecurityPolicySchema, up as SecurityScanRequest, uq as SecurityScanRequestSchema, ur as SecurityScanResponse, us as SecurityScanResponseSchema, ut as SecuritySeveritySchema, uu as SecuritySeverityWire, uv as SecuritySourceSchema, uw as SendChannelMessageRequest, ux as SendChannelMessageRequestSchema, uy as SendChannelMessageResponse, uz as SendChannelMessageResponseSchema, uA as SendChatRequest, uB as SendChatRequestSchema, uC as SendChatResponse, uD as SendChatResponseSchema, uE as SendToSessionRequest, uF as SendToSessionRequestSchema, uG as SendToSessionResponse, uH as SendToSessionResponseSchema, uI as ServiceRole, uJ as ServiceRoleSchema, uK as SessionDebugSnapshot, uL as SessionDebugSnapshotSchema, uM as SessionGpuTask, uN as SessionGpuTaskSchema, uO as SessionSearchResult, uP as SessionSearchResultSchema, uQ as SessionTelemetry, uR as SessionTelemetryListResponse, uS as SessionTelemetryListResponseSchema, uT as SessionTelemetrySchema, uU as SessionTurnTelemetry, uV as SessionTurnTelemetrySchema, uW as SetTaskStatusRequest, uX as SetTaskStatusRequestSchema, uY as Settlement, uZ as SettlementSchema, u_ as SharedModelMigrationCandidate, u$ as SharedModelMigrationCandidateSchema, v0 as SharedModelMigrationCandidatesResponse, v1 as SharedModelMigrationCandidatesResponseSchema, v2 as SharedModelMigrationRequest, v3 as SharedModelMigrationRequestSchema, v4 as SharedModelMigrationResult, v5 as SharedModelMigrationResultSchema, v6 as SharedModelMigrationSource, v7 as SharedModelMigrationSourceSchema, v8 as SpawnTaskInstancesRequest, v9 as SpawnTaskInstancesRequestSchema, va as StartCodeReviewRequest, vb as StartCodeReviewRequestSchema, vc as StartCodeReviewResponse, vd as StartCodeReviewResponseSchema, ve as StepDeliverableSchema, vf as StepGateSchema, vg as StepGateUnion, vh as StepGateUnionSchema, vi as StepPatch, vj as StepPosition, vk as StepPositionSchema, vl as StepSniff, vm as StepSniffSchema, vn as StructuredOutput, vo as StructuredOutputSchema, vp as SuggestCraftbooksResponse, vq as SuggestCraftbooksResponseSchema, vr as SuggestedCraftbook, vs as SuggestedCraftbookSchema, vt as SuggestedWorkItem, vu as SuggestedWorkItemSchema, vv as SuggestedWorkResponse, vw as SuggestedWorkResponseSchema, vx as SuggestedWorkSource, vy as SuggestedWorkSourceSchema, vz as SuggestedWorkState, vA as SuggestedWorkStateSchema, vB as SvgLayer, vC as SvgLayerSchema, vD as SymbolContext, vE as SymbolContextSchema, vF as SystemBootstrapStatus, vG as SystemBootstrapStatusSchema, vH as SystemDiagnostics, vI as SystemDiagnosticsSchema, vJ as SystemHomeInfo, vK as SystemHomeInfoSchema, vL as SystemToolsetInstallEvent, vM as SystemToolsetInstallEventSchema, vN as SystemToolsetInstallPhase, vO as SystemToolsetInstallSnapshot, vP as SystemToolsetInstallSnapshotSchema, vQ as TOOL_CALL_DIFF_MAX_BYTES, vR as TaskAssignee, vS as TaskAssigneeSchema, vT as TaskCraftbook, vU as TaskCraftbookSchema, vV as TaskCraftbookSource, vW as TaskCraftbookSourceSchema, vX as TaskCraftbookStep, vY as TaskCraftbookStepSchema, vZ as TaskCron, v_ as TaskCronOverlap, v$ as TaskCronOverlapSchema, w0 as TaskCronSchema, w1 as TaskFanout, w2 as TaskFanoutSchema, w3 as TaskNightShift, w4 as TaskNightShiftSchema, w5 as TaskNote, w6 as TaskNoteAuthor, w7 as TaskNoteAuthorSchema, w8 as TaskNoteSchema, w9 as TaskPausedIntent, wa as TaskPausedIntentSchema, wb as TaskPausedReason, wc as TaskPausedReasonSchema, wd as TaskRefSchema, we as TaskResponse, wf as TaskResponseSchema, wg as TaskSchema, wh as TaskStatus, wi as TaskStatusSchema, wj as TaskVariation, wk as TaskVariationSchema, wl as TerminalEventEnvelope, wm as TerminalEventEnvelopeSchema, wn as TerminalFileReference, wo as TerminalFileReferenceSchema, wp as TerminalInputRequestedEvent, wq as TerminalInputRequestedEventSchema, wr as TerminalMessage, ws as TerminalMessageEvent, wt as TerminalMessageEventSchema, wu as TerminalMessageSchema, wv as TerminalOpenFileEvent, ww as TerminalOpenFileEventSchema, wx as TerminalOutputChunkEvent, wy as TerminalOutputChunkEventSchema, wz as TerminalRunStartedEvent, wA as TerminalRunStartedEventSchema, wB as TerminalThread, wC as TerminalThreadSchema, wD as TerminalThreadSummary, wE as TerminalThreadSummarySchema, wF as TerminalTimelineEntry, wG as TerminalTimelineEntrySchema, wH as TerminalWorkingDirChangedEvent, wI as TerminalWorkingDirChangedEventSchema, wJ as TextLayer, wK as TextLayerSchema, wL as TimelineMessage, wM as TimelineMessageSchema, wN as ToolCallFormat, wO as ToolCallFormatSchema, wP as ToolPermissionIntent, wQ as ToolPermissionIntentSchema, wR as ToolsetCategory, wS as ToolsetCategorySchema, wT as ToolsetConfig, wU as ToolsetConfigField, wV as ToolsetConfigFieldSchema, wW as ToolsetConfigSchema, wX as ToolsetIdentity, wY as ToolsetIdentitySchema, wZ as ToolsetInstallApprovalIntent, w_ as ToolsetInstallApprovalIntentSchema, w$ as ToolsetManifest, x0 as ToolsetManifestSchema, x1 as ToolsetPlatform, x2 as ToolsetPlatformSchema, x3 as ToolsetRuntimeSchema, x4 as ToolsetVersionManifest, x5 as ToolsetVersionManifestSchema, x6 as ToolsetsScope, x7 as ToolsetsScopeSchema, x8 as TraceTaintRequest, x9 as TraceTaintRequestSchema, xa as TraceTaintResponse, xb as TraceTaintResponseSchema, xc as TraitProposal, xd as TraitProposalSchema, xe as TransformStreamEvent, xf as TransformStreamEventSchema, xg as TransformTextMode, xh as TransformTextModeSchema, xi as TransformTextRequest, xj as TransformTextRequestSchema, xk as TuningAction, xl as TuningActionSchema, xm as TuningProfileId, xn as TuningProfileIdSchema, xo as TuningProposal, xp as TuningProposalSchema, xq as UNIFIED_SEARCH_RESULT_KINDS, xr as UnifiedSearchRequest, xs as UnifiedSearchRequestSchema, xt as UnifiedSearchResponse, xu as UnifiedSearchResponseSchema, xv as UnifiedSearchResult, xw as UnifiedSearchResultKind, xx as UnifiedSearchResultKindSchema, xy as UnifiedSearchResultSchema, xz as UpdateConfigRequest, xA as UpdateConfigRequestSchema, xB as UpdateCraftbookRequest, xC as UpdateCraftbookRequestSchema, xD as UpdateGezelAboutRequest, xE as UpdateGezelAboutRequestSchema, xF as UpdateGezelFixedFunctionDefaultsRequest, xG as UpdateGezelFixedFunctionDefaultsRequestSchema, xH as UpdateGezelIconRequest, xI as UpdateGezelIconRequestSchema, xJ as UpdateGezelMarkdownRequest, xK as UpdateGezelMarkdownRequestSchema, xL as UpdateGezelPoppetjeRequest, xM as UpdateGezelPoppetjeRequestSchema, xN as UpdateGezelSettingsRequest, xO as UpdateGezelSettingsRequestSchema, xP as UpdateProjectRequest, xQ as UpdateProjectRequestSchema, xR as UpdateQueuedMessageRequest, xS as UpdateQueuedMessageRequestSchema, xT as UpdateQueuedMessageResponse, xU as UpdateQueuedMessageResponseSchema, xV as UpdateTaskCraftbookRequest, xW as UpdateTaskCraftbookRequestSchema, xX as UpdateTaskNoteRequest, xY as UpdateTaskNoteRequestSchema, xZ as UpdateTaskNoteResponse, x_ as UpdateTaskNoteResponseSchema, x$ as UpdateTaskRequest, y0 as UpdateTaskRequestSchema, y1 as UpdateTaskStepRequest, y2 as UpdateTaskStepRequestSchema, y3 as UpdateTaskStepResponse, y4 as UpdateTaskStepResponseSchema, y5 as VILLAGE_FILE_ABOUT, y6 as VILLAGE_FILE_SCHEMA_VERSION, y7 as VideoAccelerator, y8 as VideoAcceleratorSchema, y9 as VideoEngineStatusResponse, ya as VideoEngineStatusResponseSchema, yb as VideoGenerationApprovalIntent, yc as VideoGenerationApprovalIntentSchema, yd as VideoGenerationMeta, ye as VideoGenerationMetaSchema, yf as VideoGenerationRequest, yg as VideoGenerationRequestSchema, yh as VideoGenerationResponse, yi as VideoGenerationResponseSchema, yj as VideoInputSource, yk as VideoInputSourceSchema, yl as VideoModelFamily, ym as VideoModelFamilySchema, yn as VideoModelIdentity, yo as VideoModelIdentitySchema, yp as VideoModelLoad, yq as VideoModelLoadSchema, yr as VideoModelManifest, ys as VideoModelManifestSchema, yt as VideoModelPullEvent, yu as VideoModelPullEventSchema, yv as VideoModelSource, yw as VideoModelSourceSchema, yx as VideoModelVersionManifest, yy as VideoModelVersionManifestSchema, yz as VillageAnchorSchema, yA as VillageDomainState, yB as VillageDomainStateSchema, yC as VillageDowntown, yD as VillageDowntownSchema, yE as VillageFile, yF as VillageFileSchema, yG as VillageJournalNode, yH as VillageJournalNodeSchema, yI as VillageOverrideSchema, yJ as WORKSPACE_READ_DEADLINE_MS, yK as WORKSPACE_READ_MAX_BATCH_LINES, yL as WORKSPACE_READ_MAX_BATCH_RESULT_BYTES, yM as WORKSPACE_READ_MAX_BATCH_SCAN_BYTES, yN as WORKSPACE_READ_MAX_FILES, yO as WORKSPACE_READ_MAX_RANGE_LINES, yP as WORKSPACE_READ_MAX_RESULT_BYTES, yQ as WORKSPACE_READ_MAX_SCAN_BYTES, yR as WebSearchRequest, yS as WebSearchRequestSchema, yT as WebSearchResponse, yU as WebSearchResponseSchema, yV as WebhookChannelConfig, yW as WebhookChannelConfigSchema, yX as WikipediaSearchRequest, yY as WikipediaSearchRequestSchema, yZ as WorkspaceCommandIndex, y_ as WorkspaceCommandIndexSchema, y$ as WorkspaceCommandShapes, z0 as WorkspaceCommandShapesSchema, z1 as WorkspaceEditResponse, z2 as WorkspaceEditResponseSchema, z3 as WorkspaceIndexMeta, z4 as WorkspaceIndexMetaSchema, z5 as WorkspaceIndexStatus, z6 as WorkspaceIndexStatusSchema, z7 as WorkspaceInstructionIndex, z8 as WorkspaceInstructionIndexSchema, z9 as WorkspaceReadFileError, za as WorkspaceReadFileErrorSchema, zb as WorkspaceReadFileRequest, zc as WorkspaceReadFileRequestSchema, zd as WorkspaceReadFileResult, ze as WorkspaceReadFileResultSchema, zf as WorkspaceReadFileSuccess, zg as WorkspaceReadFileSuccessSchema, zh as WorkspaceSkillIndex, zi as WorkspaceSkillIndexSchema, zj as WriteDocumentRequest, zk as WriteDocumentRequestSchema, zl as XtcSamplerConfig, zm as XtcSamplerSchema, zn as applyStepPatch, zo as assertCraftbookGraph, zp as compareSemver, zq as craftbookRequirementsMet, zr as credentialCapabilityName, zs as gateEdgeTargets, zt as isCredentialCapability, zu as isDraftTask, zv as isKnownProfileId, zw as isLegacyGateSpec, zx as isNightShiftTask, zy as isPendingNightShiftTask, zz as isScheduleHost, zA as isSemver, zB as levelForXp, zC as modelFitnessKey, zD as normalizeCodexPermissionMode, zE as normalizeScriptRefs, zF as normalizeStepGate, zG as parseCraftbookTestSpec, zH as parseTaskRef, zI as profileKind, zJ as projectAllowsAmbientWork, zK as removeStepAndCleanEdges, zL as reorderStepsArray, zM as resolveProfileChain, zN as resolveProjectTypeId, zO as resolveSteps, zP as slugifyStepId, zQ as spawnsChildren, zR as stepInsertionIndex, zS as taskRef, zT as tierAtLeast, zU as tierRank, zV as uniqueStepId, zW as unmetConnectors, zX as unmetCraftbookRequirements, zY as unmetToolsets, zZ as validateCraftbookGraph, z_ as validateCraftbookScriptRefs, z$ as validateScriptInput, A0 as xpForLevel } from './index-D_dch9Qh.js';
+import { G as GezelGender, C as CraftbookDocError, a as CraftbookDoc, b as CraftbookDocFormat } from './report-action-DzdQHzGG.js';
+export { A as ApplyEditsAction, c as ApplyEditsActionSchema, d as ChatEvent, e as ChatEventEnvelope, f as ChatEventEnvelopeSchema, g as ChatEventSchema, h as ChatMessage, i as ChatMessageSchema, j as ChatMessageToolCall, k as ChatMessageToolCallSchema, l as ChatTurnErrorDetail, m as ChatTurnErrorDetailSchema, n as CraftbookDocSchema, o as CreateTaskAction, p as CreateTaskActionSchema, D as DismissReportActionRequest, q as DismissReportActionRequestSchema, F as FireCraftbookAction, r as FireCraftbookActionSchema, s as FireReportActionRequest, t as FireReportActionRequestSchema, u as FireReportActionResponse, v as FireReportActionResponseSchema, w as FixedFunctionConfig, x as FixedFunctionConfigSchema, y as GezelDetail, z as GezelDetailSchema, B as GezelFrontmatter, E as GezelFrontmatterSchema, H as GezelGenderSchema, I as GezelSection, J as GezelSectionSchema, K as GezelSummary, L as GezelSummarySchema, M as GezelTrait, N as GezelTraitSchema, O as LOCAL_PROVIDER_NAMES, P as ParsedGezel, Q as ParsedGezelSchema, R as ParsedReportAction, S as ProviderName, T as ProviderNameSchema, U as ReportAction, V as ReportActionKind, W as ReportActionKindSchema, X as ReportActionParseIssue, Y as ReportActionParseIssueSchema, Z as ReportActionRecord, _ as ReportActionRecordSchema, $ as ReportActionSchema, a0 as ReportActionState, a1 as ReportActionStateSchema, a2 as ReportActionView, a3 as ReportActionViewSchema, a4 as ReportActionsResponse, a5 as ReportActionsResponseSchema, a6 as ToolCallAudio, a7 as ToolCallAudioSchema, a8 as ToolCallImage, a9 as ToolCallImageSchema, aa as ToolCallVideo, ab as ToolCallVideoSchema, ac as craftbookDocFormatFromEnv, ad as editDistance, ae as formatCraftbookDocErrors, af as isLocalProvider, ag as nearestMatch, ah as sniffCraftbookDocFormat, ai as zodIssuesToDocErrors } from './report-action-DzdQHzGG.js';
+import { MdSection } from './markdown/index.js';
+export { CraftbookMarkdownParse, FENCE, ParsedReportActions, REPORT_ACTION_AUTHORING_GUIDE, REPORT_ACTION_FENCE_LANG, defaultStepIdForName, extractAllFences, extractFirstFence, findFirstH1, hasReportActionFence, isFenceClose, parseCraftbookMarkdown, parseGezelMarkdown, parseReportActionBlock, parseReportActions, parseYamlBlock, pickFence, promoteBareChannelNames, reportActionContentHash, serializeCraftbookMarkdown, serializeGezelMarkdown, splitSections, stringifyYamlBlock } from './markdown/index.js';
+import { z } from 'zod';
+export { D as DEVICE_HARD_TEMPERATURE_C } from './device-safety-DezzpNyR.js';
+
+/**
+ * Pure-layout I/O for the city-map engine. The engine knows nothing about files,
+ * imports, or rendering — only weighted hierarchical nodes (paths), affinity
+ * edges between them, and their prior persisted coordinates. That is what lets
+ * the same engine lay out code, docs, and data folder trees unchanged.
+ */
+/** One live node to place: a file path, its weight (LoC) and content hash. */
+interface LayoutFileInput {
+    path: string;
+    weight: number;
+    contentHash: string | null;
+    /** Import-graph centrality [0,1] — widens yards (roomier hub lots). */
+    importance?: number;
+    /** Skyline landmark — the seed reserves an adjacent plaza. */
+    landmark?: boolean;
+}
+/** An affinity edge between two file paths (higher = pull closer / seed near). */
+interface AffinityEdge {
+    a: string;
+    b: string;
+    weight: number;
+}
+/** A previously-persisted coordinate (district/block/street/plate/plaza),
+ *  incl. tombstones. */
+interface PriorNode {
+    nodeKind: 'district' | 'block' | 'street' | 'plate' | 'plaza';
+    nodeId: string;
+    /** For streets this is the interior folder ('' persisted as null). */
+    parentId?: string | null;
+    rect: Rect;
+    contentHash: string | null;
+    /** For streets the tier rides in this column. */
+    weight: number;
+    placedAt: string | null;
+    removedAt: string | null;
+}
+interface LayoutOptions {
+    /** World extent the first build seeds into (default 1000×1000). */
+    width?: number;
+    height?: number;
+    /** Timestamp stamped onto newly-placed / tombstoned nodes (engine is pure). */
+    nowIso: string;
+    /** Tombstones removed strictly before this ISO time are pruned (gentle GC). */
+    tombstoneCutoffIso?: string;
+    /** Macro placement memory: seeds honor these compass regions for top-level
+     *  display districts (recorded to the city file at first seed). */
+    anchors?: VillageAnchor[];
+    /** User pins from the city file (region/rect for top-level folders). */
+    overrides?: VillageOverride[];
+    /** @deprecated pre-street block gap; kept for placeGhostBlocks callers. */
+    gap?: number;
+}
+/** Where a block ended up, and how it should read on the map. */
+interface BlockPlacement {
+    /** The parcel: persistence + collision unit, frozen across builds. */
+    lot: Rect;
+    /** The building: derived from current LoC each build, clamped inside the lot. */
+    footprint: Rect;
+    state: 'live' | 'new' | 'tombstoned';
+    placedAt: string | null;
+}
+/** A row to persist back into `map_layout` (mirrors the store's LayoutRow). */
+interface PersistNode {
+    nodeKind: 'district' | 'block' | 'street' | 'plate' | 'plaza';
+    nodeId: string;
+    parentId: string | null;
+    contentHash: string | null;
+    /** Blocks persist their LOT (not the footprint); streets their pavement rect. */
+    rect: Rect;
+    /** Blocks: LoC. Streets: tier (documented reuse of the column). */
+    weight: number;
+    placedAt: string | null;
+    removedAt: string | null;
+}
+interface LayoutResult {
+    /** path → placement, including tombstoned (gone) blocks kept as rubble. */
+    blocks: Map<string, BlockPlacement>;
+    /** one per folder prefix that contains ≥1 block (live or tombstoned). */
+    districts: MapDistrict[];
+    /** paved streets between folders/rows, stable across builds. */
+    streets: MapStreet[];
+    /** plazas (fronting landmarks) + greens (leftover packing space). */
+    plazas: MapPlaza[];
+    /** compass anchors recorded by a seed build ([] on incremental builds —
+     *  the service keeps the city file's existing anchors then). */
+    anchors: VillageAnchor[];
+    /** the authoritative layout to write back to the store. */
+    persist: PersistNode[];
+}
+
+/** Block side length from line count: √-scaled so area tracks LoC, then clamped. */
+declare function blockSize(loc: number): number;
+/** Deterministic value in [0, 1) from a path + salt (FNV-1a core). */
+declare function hash01(s: string, salt: number): number;
+interface LotSpec {
+    lotW: number;
+    lotH: number;
+    /** Footprint rect relative to the lot origin. */
+    foot: Rect;
+}
+/**
+ * Deterministic parcel spec for a file: footprint area follows the same
+ * area-∝-LoC law as `blockSize`, with per-path aspect + yard jitter.
+ * `importance` (import-graph centrality, 0..1) widens the yards — hubs get
+ * roomier, greener lots. The bonus room lands ONLY on the right/bottom yards:
+ * the footprint's left/top anchor must be re-derivable without knowing the
+ * importance at seed time (`footprintWithin` regrows footprints inside frozen
+ * lots on every later build), so the anchor yards stay unscaled.
+ */
+declare function lotSpec(path: string, weight: number, importance?: number): LotSpec;
+/**
+ * The footprint for a file inside its (frozen) lot: anchored at its original
+ * yard offsets (so x,y never move), growing right/down with the file's LoC and
+ * clamped so a minimum yard always survives. A file that outgrows its lot
+ * saturates visually; the weight still travels on the wire.
+ */
+declare function footprintWithin(path: string, weight: number, lot: Rect): Rect;
+interface AppendResult {
+    lot: Rect;
+    /** A fresh tier-3 lane opened under the strip, when a new row was started. */
+    newLane: Rect | null;
+}
+/**
+ * Grow a folder's strip the way a city grows: extend the bottom parcel row
+ * rightward, or open a new row below behind a fresh lane. Works purely from
+ * the persisted sibling geometry — no reflow, no moved neighbours. Returns
+ * null when neither spot is clear (caller falls back to the spiral).
+ */
+declare function appendLotInFolder(spec: LotSpec, siblingLots: Rect[], occupied: Rect[]): AppendResult | null;
+interface StripLot {
+    path: string;
+    lot: Rect;
+    foot: Rect;
+}
+interface StripPlaza {
+    /** The landmark file this plaza fronts. */
+    path: string;
+    rect: Rect;
+}
+interface StripResult {
+    w: number;
+    h: number;
+    lots: StripLot[];
+    /** One lane rect below each row except the last (the folder street serves it). */
+    lanes: Rect[];
+    /** Open squares fronting landmark files (empty without landmarks). */
+    plazas: StripPlaza[];
+}
+interface StripOptions {
+    /** Row-wrap width; defaults to the ~square heuristic. The town packer sets
+     *  this to the column width so parcel rows fill wall-to-wall. */
+    targetW?: number;
+}
+/**
+ * Pack one folder's direct files as parcel rows: path order (not size order —
+ * that's what killed the "sorted carpet" look), left→right with sidewalk gaps,
+ * bottom-aligned so buildings face the lane below their row. Landmark files
+ * (`LayoutFileInput.landmark`) get an adjacent plaza slot in their row.
+ */
+declare function packLeafStrip(files: LayoutFileInput[], options?: StripOptions): StripResult;
+
+/**
+ * Streets — the gaps the packer leaves between sibling boxes, materialized as
+ * first-class rects so the renderer can pave them and incremental placement
+ * can avoid building on them. Widths are hierarchical (CodeCity-style): wide
+ * avenues between top-level packages, narrowing to alleys deep in the tree.
+ */
+/** tier 0..3: avenue, street, lane, alley. */
+declare const STREET_WIDTHS: readonly [16, 10, 6, 4];
+type StreetTier = 0 | 1 | 2 | 3;
+declare function streetTier(depth: number): StreetTier;
+declare function streetWidth(depth: number): number;
+/** Interior perimeter padding of a folder box (half the next tier's street). */
+declare function folderPad(depth: number): number;
+/** A street segment in some container's local coordinates. */
+interface StreetSeg {
+    rect: Rect;
+    tier: StreetTier;
+    /** Folder whose interior this street runs through ('' = the map root). */
+    folder: string;
+}
+/**
+ * Merge collinear strips (same row/column, touching or overlapping ranges) so
+ * streets read as continuous runs instead of per-box stubs. Best-effort: an
+ * unmerged pair just paints the same pavement twice.
+ */
+declare function mergeStreets(segs: StreetSeg[]): StreetSeg[];
+/** Stable, geometry-derived street id (streets have no natural name). */
+declare function streetId(seg: StreetSeg): string;
+
+interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Find the nearest position to `seed` where a `w`×`h` rect doesn't collide
+ * with any occupied rect — a coarse outward spiral. Falls back to the seed
+ * itself (allowing overlap) after a bounded search.
+ */
+declare function nearestFreeRect(seed: Point, w: number, h: number, occupied: Rect[], gap: number): Rect;
+/**
+ * Place transient "ghost" blocks (e.g. PR-added files not yet in the index)
+ * into the free space of an already-laid-out map without overlapping existing
+ * blocks or each other. Each ghost is seeded near a point (its district) and
+ * collision-avoided. Pure + deterministic (placed in id order). Not persisted —
+ * this is an overlay-time helper, so it doesn't disturb the stable layout.
+ */
+declare function placeGhostBlocks(occupied: Rect[], ghosts: Array<{
+    id: string;
+    size: number;
+    seedX: number;
+    seedY: number;
+}>, gap?: number): Map<string, Rect>;
+declare function layoutFileMap(files: LayoutFileInput[], edges: AffinityEdge[], prior: PriorNode[], options: LayoutOptions): LayoutResult;
+/**
+ * Lay symbols out as a small grid of buildings inside a block, in source order
+ * (top-to-bottom = file order). Height and footprint follow the symbol's line
+ * span on the absolute `symbolSizeT` scale, bounded on both ends: a floor so
+ * every building stays visible, a cap so one giant can't flatten the rest.
+ * When a block can't host every symbol at `MIN_CELL`, the largest symbols win
+ * the ground (still placed in source order); `MapBlock.buildingCount` keeps
+ * reporting the true total.
+ */
+declare function layoutBuildingsInBlock(blockId: string, blockRect: Rect, symbols: Array<{
+    name: string;
+    kind: string;
+    lineStart: number;
+    lineEnd: number;
+}>): MapBuilding[];
+
+/**
+ * Display districts and their label plates. The v2 map labeled every folder
+ * prefix at its rect corner, so pass-through chains (`packages/x/src` where
+ * each level has one child and no files) painted three near-coincident labels
+ * — the single worst legibility bug on the old map. Here the chain collapses
+ * structurally into ONE display district labeled once (`x/src`), and every
+ * display district reserves a real plate rect the renderer draws into.
+ */
+/** Reserved label headroom inside a folder box (world units). Must stay under
+ *  the street router's BRIDGE distance (20) minus the deepest folder pad, so
+ *  district interiors remain routable: max folderPad (5) + PLATE_H < 20. */
+declare const PLATE_H = 11;
+/** A folder tree with pass-through chains folded into single display nodes. */
+interface CollapsedNode {
+    /** Full folder path ('' at the root, which is never itself collapsed). */
+    path: string;
+    /** Label relative to the parent display node (e.g. 'x/src'). '' at root. */
+    label: string;
+    children: CollapsedNode[];
+    files: LayoutFileInput[];
+    weight: number;
+}
+/** Collapse a file set into a display tree. The root stays the root. */
+declare function collapseFiles(files: LayoutFileInput[]): CollapsedNode;
+/** folder path → display label, for every display district in the live tree.
+ *  Folders absent from this map (interior links of a collapsed chain, and the
+ *  root) must not be labeled at all. */
+declare function displayLabels(files: LayoutFileInput[]): Map<string, string>;
+/** The plate rect for a label at a district's interior top-left. */
+declare function plateRectFor(label: string, x: number, y: number, availW: number): Rect;
+
+/** Region containing a normalized centroid. */
+declare function regionOf(cx: number, cy: number): CompassRegion;
+declare function regionCell(region: CompassRegion): {
+    row: number;
+    col: number;
+};
+/**
+ * Derive anchors from a PRIOR layout's block rects — the v4→v5 migration
+ * path: before a version bump discards the old geometry, remember which
+ * compass region each top-level folder's centroid occupied so the re-seed
+ * preserves the user's mental map.
+ */
+declare function deriveAnchorsFromPrior(priorBlocks: readonly PriorNode[]): VillageAnchor[];
+/**
+ * Assign a compass region to each top-level item. Priority per item:
+ * override.region (exact-path match) → anchor.region → deterministic
+ * capacity balancing (largest first into the least-loaded region, ties in
+ * NW→SE order).
+ */
+declare function assignRegions(items: ReadonlyArray<{
+    path: string;
+    area: number;
+}>, anchors: readonly VillageAnchor[], overrides: readonly VillageOverride[]): Map<string, CompassRegion>;
+
+/**
+ * The v5 "planned town" seed packer, replacing the potpack bin-packer whose
+ * 95%-fill height-sorted output read as a defrag visualization. Three ideas:
+ *
+ * - COLUMN ("ladder") PACKING per folder: sibling boxes stand in height-
+ *   balanced columns; the vertical streets between columns run the full
+ *   container height and every cross-street terminates on them, so the street
+ *   network is connected by construction (the UI's Dijkstra router needs no
+ *   changes). Deliberate jittered slack (~0.75 fill vs 0.95) lets districts
+ *   breathe and their silhouettes vary.
+ *
+ * - COMPASS MACRO at the root: top-level display districts land in a sparse
+ *   3×3 grid steered by village-file anchors/overrides, with tier-0 boulevards
+ *   spanning the whole map between occupied grid rows/columns. Re-seeds keep
+ *   `packages/` where the user remembers it.
+ *
+ * - RESERVED GEOMETRY for labels and open space: every display district's
+ *   plate (PLATE_H headroom) and every landmark plaza / leftover green is a
+ *   first-class rect the incremental engine treats as occupied.
+ */
+interface TownPlate {
+    folder: string;
+    rect: Rect;
+}
+interface TownPlaza {
+    id: string;
+    folder: string;
+    rect: Rect;
+    kind: 'plaza' | 'green';
+    blockId?: string;
+}
+interface TownResult {
+    w: number;
+    h: number;
+    lots: Map<string, {
+        lot: Rect;
+        foot: Rect;
+    }>;
+    streets: StreetSeg[];
+    plates: TownPlate[];
+    plazas: TownPlaza[];
+}
+interface TownRootResult extends TownResult {
+    anchors: VillageAnchor[];
+}
+/** Pack one collapsed folder (children + direct files) at `depth`. */
+declare function packTownNode(node: CollapsedNode, depth: number): TownResult;
+/** Pack a wholly-new subtree (incremental folder arrival) at `folderDepth`. */
+declare function packTownSubtree(files: LayoutFileInput[], folderDepth: number): TownResult;
+interface TownRootOptions {
+    anchors?: VillageAnchor[];
+    overrides?: VillageOverride[];
+    nowIso: string;
+}
+/**
+ * Seed the whole city: top-level display districts into the sparse compass
+ * grid, boulevards between occupied grid rows/columns, anchors recorded.
+ */
+declare function packTownRoot(files: LayoutFileInput[], options: TownRootOptions): TownRootResult;
+
+/**
+ * Pure facts→markdown composer for the per-symbol context sections shown in
+ * file viewers. Consumed by two hosts — the Map tab's embedded squisq editor
+ * (Monaco view zones) and the vscode extension (CodeLens/Hover) — so it emits
+ * host-neutral markdown plus a plain-text strip variant, and links use the
+ * gezel href grammar below, which each host translates to its own navigation.
+ *
+ * Link grammar (the single source of truth both hosts parse):
+ *   - cross-file: `gezel-nav:` + encodeURIComponent(workspaceRelativePath)
+ *     + optional `#L<line>`
+ *   - in-file:    bare fragment `#L<line>`
+ */
+type GezelHref = {
+    kind: 'file';
+    path: string;
+    line?: number;
+} | {
+    kind: 'line';
+    line: number;
+};
+/** One composed section, structurally spreadable into squisq's CodeContextSection. */
+interface ComposedSection {
+    id: string;
+    /** 1-based line the section renders above (the symbol's lineStart). */
+    line: number;
+    /** One-line markdown strip (no links). */
+    summaryMarkdown: string;
+    /** The strip as plain text — CodeLens titles can't render markdown. */
+    summaryText: string;
+    /** Expanded body markdown. */
+    markdown: string;
+    defaultExpanded?: boolean;
+}
+interface ComposedCodeContext {
+    fileTop?: {
+        id: string;
+        summaryMarkdown: string;
+        summaryText: string;
+        markdown: string;
+    };
+    sections: ComposedSection[];
+}
+declare function gezelNavHref(path: string, line?: number): string;
+declare function gezelLineHref(line: number): string;
+/** Parse a gezel href; null for anything outside the grammar (http:, #foo, …). */
+declare function parseGezelHref(href: string): GezelHref | null;
+/**
+ * Rewrite every gezel-grammar link destination in composed markdown via `fn`
+ * (e.g. to vscode `command:` URIs). Non-gezel links are left untouched. Only
+ * safe on markdown THIS module composed — it never emits the `](...)` pattern
+ * inside code fences.
+ */
+declare function rewriteGezelHrefs(markdown: string, fn: (href: GezelHref) => string): string;
+/** Escape text destined for markdown prose (names, titles, summaries). */
+declare function escapeMd(text: string): string;
+declare function composeFileContext(res: FileContextResponse): ComposedCodeContext;
+
+/**
+ * Split a gezel script's source into three editable lenses — the
+ * imports/comments **preamble**, the `export const meta = defineScript({...})`
+ * **statement**, and the script **body** — and put them back together. This
+ * powers the three-tab script editor (Raw / Properties / Script) in the UI.
+ *
+ * The UI cannot reuse the service's TypeScript-AST parser
+ * (`packages/service/src/scripts/meta.ts`): that pulls in the `typescript`
+ * compiler, which is far too heavy for the browser bundle. Instead this module
+ * locates the meta statement with a small string/comment/template-literal-aware
+ * scanner and parses the meta object literal with a tiny recursive-descent
+ * parser. Both deliberately mirror the semantics of `meta.ts`:
+ *   - the FIRST exported `meta` const wins;
+ *   - `defineScript(...)` and a trailing `as const` / `satisfies` are unwrapped;
+ *   - only literal shapes are accepted (no spreads, computed keys, or calls).
+ *
+ * The canonical schema (`ScriptMetaSchema`) is the final arbiter — every parse
+ * path validates through it, so the form never sees a shape the runtime would
+ * reject.
+ */
+
+interface SplitScriptSource {
+    /** Everything before the meta statement: imports + any standalone comments. */
+    preamble: string;
+    /** Comment block (JSDoc or `//` lines) attached directly above the meta statement, or ''. */
+    metaLeadingComment: string;
+    /** The `export const meta = ...;` statement text, WITHOUT its leading comment. */
+    metaText: string;
+    /** Everything after the meta statement — the `const input = ...` body onward. */
+    body: string;
+    /** False when no meta statement could be located (Properties/Script tabs disable). */
+    found: boolean;
+}
+/**
+ * Locate the `export const meta = ...;` statement and split the source around
+ * it. Never throws — returns `{ found: false }` with the whole source in
+ * `preamble` when no meta statement is present.
+ */
+declare function splitScriptSource(source: string): SplitScriptSource;
+/**
+ * Reassemble a full source from its three regions, normalizing the spacing
+ * between them to a single blank line. The result always ends in one newline,
+ * matching the scaffold output.
+ */
+declare function stitchScriptSource(parts: {
+    preamble: string;
+    /** The full meta region (leading comment + statement), or just the statement. */
+    metaText: string;
+    body: string;
+}): string;
+/** Join a split's leading comment and statement back into one meta region. */
+declare function joinMetaRegion(split: Pick<SplitScriptSource, 'metaLeadingComment' | 'metaText'>): string;
+/**
+ * Count the leading lines a full source devotes to "setup" — the preamble
+ * (imports + standalone comments) plus the `export const meta = ...;`
+ * statement, i.e. everything before the body begins.
+ *
+ * The Script tab feeds Monaco the WHOLE file (so `gezel`, `meta`, and
+ * `InferredInput<typeof meta>` all resolve and type-check) but hides these
+ * lines from view, so the user edits only the body. Returns 0 when there's no
+ * meta statement — nothing to hide, and the Script tab is disabled anyway.
+ */
+declare function setupLineSpan(source: string): number;
+/**
+ * Parse a meta statement's object literal into a validated `ScriptMeta`. This
+ * is the one place the UI reads meta back out of text (after a Raw-tab edit);
+ * `initialMeta` from the server covers the initial load.
+ */
+declare function parseMetaObject(metaText: string): {
+    ok: true;
+    meta: ScriptMeta;
+} | {
+    ok: false;
+    error: string;
+};
+/** Escape a value for interpolation inside a single-quoted TS string. */
+declare function quoteSingle(value: string): string;
+/**
+ * Serialize a `ScriptMeta` into a canonical `export const meta =
+ * defineScript({...});` block matching the scaffold's formatting (2-space
+ * indent, single quotes, trailing commas, descriptors inline).
+ *
+ * Note: this regenerates the block from data — any hand-written comments or
+ * formatting INSIDE `defineScript({...})` are dropped. Callers re-serialize
+ * only when the Properties form was actually edited.
+ */
+declare function serializeScriptMeta(meta: ScriptMeta): string;
+/**
+ * The Properties form models `inputs`/`outputs` as ARRAYS of descriptors with a
+ * synthetic `name` field — because squisq's `JsonEditor` edits one value object,
+ * not a name-keyed record. `metaToFormValue` / `formValueToMeta` bridge the two.
+ * JSON-valued fields (`default`/`schema` on json/object types) are carried as
+ * pretty-printed JSON strings so they survive a round-trip through the form.
+ */
+interface MetaInputFormItem {
+    name: string;
+    type: ScriptInputField['type'];
+    description: string;
+    required?: boolean;
+    default?: string | number | boolean;
+    pattern?: string;
+    multiline?: boolean;
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    options?: Array<{
+        value: string;
+        label?: string;
+    }>;
+    kind?: 'gezel' | 'task' | 'artifact' | 'document';
+    defaultJson?: string;
+    schemaJson?: string;
+}
+interface MetaOutputFormItem {
+    name: string;
+    type: ScriptOutputField['type'];
+    description: string;
+    nullable?: boolean;
+    itemType?: 'string' | 'number' | 'boolean' | 'object';
+    schemaJson?: string;
+}
+interface MetaFormValue {
+    name: string;
+    description: string;
+    kind?: 'action' | 'gate';
+    inputs: MetaInputFormItem[];
+    outputs: MetaOutputFormItem[];
+    requires: string[];
+}
+declare function metaToFormValue(meta: ScriptMeta): MetaFormValue;
+/**
+ * Rebuild a validated `ScriptMeta` from the form value. Rejects empty/duplicate
+ * input or output names, strips keys irrelevant to the chosen `type` (left over
+ * after a type switch), then validates through `ScriptMetaSchema`.
+ */
+declare function formValueToMeta(v: MetaFormValue): {
+    ok: true;
+    meta: ScriptMeta;
+} | {
+    ok: false;
+    issues: string[];
+};
+
+/**
+ * Map pre-quantized catalog ids from older installs/eval caches to the
+ * current chat-model catalog ids. The installed model manifest may keep
+ * an old id (`qwen3.5-9b`) while the catalog entry now encodes size and
+ * quantization (`qwen3.5-9b-q4`). Catalog-driven tuning, model profiles,
+ * eval hints, and reasoning budgets all need the current id.
+ */
+declare function normalizeChatModelCatalogId(modelId: string | undefined): string | undefined;
+
+/**
+ * ─ Project-local gezel id codec ─────────────────────────────────────
+ *
+ * Project-local gezels live in a project's workspace `.gezel/` folder but
+ * still flow through the *global* gezel id space — sessions, memories,
+ * mentions, `voormanGezelId`, and `getGezel(id)` all key off a single
+ * opaque string. To route those calls to the project-local store without
+ * a parallel call graph, we give every project-local gezel an *encoded*
+ * id that:
+ *
+ *   1. is a routing prefix (`tryGetGezel` checks it and delegates), and
+ *   2. is a legal filesystem directory name AND a legal URL path segment,
+ *      so all the existing app-data plumbing (poppetje.json, sessions/,
+ *      memories/ under `~/.gezel/gezels/<id>/`) works UNCHANGED.
+ *
+ * Form: `proj__<projectId>__<localId>`.
+ *
+ * Both `projectId` and `localId` are `slugify()` output — `[a-z0-9-]`
+ * only, never `_` — so `__` is an unambiguous delimiter and the first
+ * `__` after the `proj__` prefix always separates the project from the
+ * local id. A raw `:` / `/` scheme was rejected: `:` is illegal in
+ * Windows paths and `/` would nest directories under the gezels root.
+ */
+/** Reserved local id for the canonical `@project` gezel (derived from AGENTS.md/CLAUDE.md). */
+declare const PROJECT_GEZEL_LOCAL_ID = "project";
+/** Prefix that marks an encoded project-local gezel id. */
+declare const PROJECT_GEZEL_ID_PREFIX = "proj__";
+/** Encode a project + local id into the global gezel id space. */
+declare function encodeProjectGezelId(projectId: string, localId: string): string;
+/** Convenience: the encoded id of a project's canonical `@project` gezel. */
+declare function projectGezelId(projectId: string): string;
+/**
+ * Decode an encoded project-local gezel id. Returns null for any id that
+ * isn't project-local (i.e. a normal global gezel id) so callers can use
+ * it as a routing test: `const dec = decodeProjectGezelId(id); if (dec) …`.
+ */
+declare function decodeProjectGezelId(id: string): {
+    projectId: string;
+    localId: string;
+} | null;
+/** True when `id` belongs to the project-local namespace. */
+declare function isProjectGezelId(id: string): boolean;
+/** True when `id` is the canonical `@project` gezel for some project. */
+declare function isCanonicalProjectGezelId(id: string): boolean;
+
+/**
+ * Per-gezel chat-bubble fonts. Each entry is one of the self-hosted WOFF2
+ * families declared in packages/ui/src/assets/fonts/fonts.css. Gezels store
+ * the `id` (kebab-case) on their frontmatter; the UI resolves it back to a
+ * CSS font-family via `resolveGezelFontFamily`. An unset or unknown id
+ * falls through to the chat-bubble default (PT Serif — `.msg-body` rule
+ * in styles.css).
+ *
+ * `scale` is an optional per-font size-adjustment factor (default 1):
+ * different typefaces render at noticeably different visual sizes at the
+ * same point size, so a font that looks oversized gets nudged down to sit
+ * proportional to the rest. The UI multiplies the base chat font-size by
+ * this factor (see `resolveGezelFontScale`).
+ */
+declare const GEZEL_CHAT_FONTS: readonly [{
+    readonly id: "pt-serif";
+    readonly label: "PT Serif (default)";
+    readonly family: "'PT Serif'";
+}, {
+    readonly id: "hanken-grotesk";
+    readonly label: "Hanken Grotesk";
+    readonly family: "'Hanken Grotesk'";
+}, {
+    readonly id: "cormorant-garamond";
+    readonly label: "Cormorant Garamond";
+    readonly family: "'Cormorant Garamond'";
+}, {
+    readonly id: "crimson-text";
+    readonly label: "Crimson Text";
+    readonly family: "'Crimson Text'";
+}, {
+    readonly id: "dm-sans";
+    readonly label: "DM Sans";
+    readonly family: "'DM Sans'";
+}, {
+    readonly id: "dm-serif-display";
+    readonly label: "DM Serif Display";
+    readonly family: "'DM Serif Display'";
+}, {
+    readonly id: "ibm-plex-sans";
+    readonly label: "IBM Plex Sans";
+    readonly family: "'IBM Plex Sans'";
+}, {
+    readonly id: "inter";
+    readonly label: "Inter";
+    readonly family: "'Inter'";
+}, {
+    readonly id: "jetbrains-mono";
+    readonly label: "JetBrains Mono";
+    readonly family: "'JetBrains Mono'";
+    readonly scale: 0.9;
+}, {
+    readonly id: "lora";
+    readonly label: "Lora";
+    readonly family: "'Lora'";
+}, {
+    readonly id: "merriweather";
+    readonly label: "Merriweather";
+    readonly family: "'Merriweather'";
+}, {
+    readonly id: "oswald";
+    readonly label: "Oswald";
+    readonly family: "'Oswald'";
+}, {
+    readonly id: "playfair-display";
+    readonly label: "Playfair Display";
+    readonly family: "'Playfair Display'";
+}, {
+    readonly id: "roboto";
+    readonly label: "Roboto";
+    readonly family: "'Roboto'";
+}, {
+    readonly id: "source-serif-4";
+    readonly label: "Source Serif";
+    readonly family: "'Source Serif 4'";
+}];
+type GezelFont = (typeof GEZEL_CHAT_FONTS)[number];
+type GezelFontId = GezelFont['id'];
+declare function resolveGezelFontFamily(id: string | undefined | null): string | undefined;
+/**
+ * Per-font size-adjustment factor. Returns 1 for an unset / unknown id or
+ * any font that doesn't declare a `scale`, so callers can multiply
+ * unconditionally.
+ */
+declare function resolveGezelFontScale(id: string | undefined | null): number;
+
+type AIEngagementMode = 'proactive' | 'scheduled' | 'reactive' | 'off';
+declare function getEngagementMode(cfg: Pick<GezelConfig, 'aiEngagementMode'>): AIEngagementMode;
+declare function isProactiveAllowed(cfg: Pick<GezelConfig, 'aiEngagementMode'>): boolean;
+/** Whether autonomous work on active tasks may start or advance. */
+declare function isTaskWorkAllowed(cfg: Pick<GezelConfig, 'aiEngagementMode'>): boolean;
+declare function isSchedulingAllowed(cfg: Pick<GezelConfig, 'aiEngagementMode'>): boolean;
+declare function isEngagementAllowed(cfg: Pick<GezelConfig, 'aiEngagementMode'>): boolean;
+type WorkshopTempo = 'gezellig' | 'bedrijvig' | 'druk' | 'dolle-boel';
+declare function getWorkshopTempo(cfg: Pick<GezelConfig, 'workshopTempo'>): WorkshopTempo;
+interface WorkshopTempoDefaults {
+    rapidIntervalMs: number;
+    slowIntervalMs: number;
+    recentActivityWindowMs: number;
+    rapidAttemptsBeforeBackoff: number;
+    /**
+     * Grace period applied to the very first nudge a project ever
+     * receives, measured from `project.createdAt`. Once the project
+     * has been nudged at least once this guard no longer applies and
+     * the rapid/slow cadence takes over.
+     *
+     * Without this, a freshly-kicked-off project gets pinged at the
+     * 5-minute mark exactly when the voorman is most likely deep in
+     * the first task and least likely to benefit from a "checking in"
+     * interruption. Tempo-specific so the laid-back `gezellig` mode
+     * gives lots of warm-up room while `dolle-boel` barely waits.
+     */
+    firstNudgeGraceMs: number;
+}
+declare function workshopTempoDefaults(tempo: WorkshopTempo): WorkshopTempoDefaults;
+
+/**
+ * Pure time helpers for Night Shift mode, shared by the service-side
+ * `NightShiftManager` (window/latch decisions) and `TaskManager` (stamping
+ * `nightShift.lastRunDay` on a once-a-day task's completion). Keeping the
+ * window-key math in one place is what makes the once-per-day guard
+ * survive the midnight boundary: a single overnight window (e.g. 22:00 →
+ * 06:00) maps to ONE stable key — the local date the window *started* — so
+ * a task that ran at 23:00 is still "ran today" at 02:00 the next morning.
+ */
+interface NightShiftWindow {
+    /** Local hour the window opens (0–23). */
+    startHour: number;
+    /** Local hour the window closes (0–23). May be ≤ startHour to wrap midnight. */
+    endHour: number;
+}
+/** Classic overnight default when nothing is configured. */
+declare const DEFAULT_NIGHT_SHIFT_WINDOW: NightShiftWindow;
+/** Local 'YYYY-MM-DD' for a date. */
+declare function localDateKey(d: Date): string;
+/** Whether `now` falls inside the (possibly midnight-wrapping) window. */
+declare function isInNightShiftWindow(now: Date, window: NightShiftWindow): boolean;
+/**
+ * Stable key for the window instance covering `now`: the local date on
+ * which the current window *started*, or null when `now` is outside the
+ * window. For a wrapping window, the early-morning tail (before `endHour`)
+ * belongs to the previous calendar day's window.
+ */
+declare function nightShiftWindowKey(now: Date, window: NightShiftWindow): string | null;
+/**
+ * Day key used to stamp/compare a once-a-day night-shift run: the
+ * window-start date when inside a window, else the plain local date.
+ */
+declare function nightShiftDayKey(now: Date, window: NightShiftWindow): string;
+/**
+ * The night window the morning review talks about: the current window
+ * when `now` is inside one, else the most recently COMPLETED window.
+ * `key` matches `nightShiftWindowKey` for instants inside that window
+ * (and therefore `Task.nightShift.lastRunDay` stamps from it). For an
+ * always-on window (equal bounds) the "window" is the last 24h and the
+ * key is the local date.
+ */
+declare function lastNightShiftWindow(now: Date, window: NightShiftWindow): {
+    key: string;
+    start: Date;
+    end: Date;
+};
+/**
+ * The next local datetime the window opens, strictly after `now`. Used to
+ * pre-schedule an OS wake (`wakeOnStart`) so a sleeping machine comes up
+ * for the upcoming shift — the service can't detect the window if it's
+ * asleep, so the wake must be armed in advance.
+ */
+declare function nextNightShiftStart(now: Date, window: NightShiftWindow): Date;
+
+/**
+ * Well-known project properties — shared per-project configuration values
+ * stored in `project.properties` (see `ProjectSchema`). A property is a
+ * plain string keyed by a dotted id. Craftbook params bridge to them via
+ * a `projectProperty: '<id>'` annotation on a `paramSchema` property: the
+ * enable form prefills the param from the project property and writes the
+ * submitted value back, so the next book (or the same book next night)
+ * shares it.
+ *
+ * The registry below improves display (labels, suggestions) — it does NOT
+ * gate: unknown ids are legal and render with the raw id as the label.
+ * Add entries here when a second consumer appears for a value; a
+ * craftbook-private knob should stay a plain param.
+ */
+type ProjectPropertyKind = 'string' | 'enum';
+interface ProjectPropertyDefinition {
+    /** Dotted id, e.g. `content.language`. Stable — persisted in project.json. */
+    id: string;
+    label: string;
+    description: string;
+    kind: ProjectPropertyKind;
+    /** For `enum`: the allowed values. For `string`: optional quick-pick suggestions. */
+    options?: string[];
+}
+declare const PROJECT_PROPERTY_DEFINITIONS: ProjectPropertyDefinition[];
+declare function projectPropertyDefinition(id: string): ProjectPropertyDefinition | undefined;
+/**
+ * The `paramSchema` property annotation linking a craftbook param to a
+ * project property. Sits beside `type`/`description`/`squisq` inside a
+ * JSON-Schema property object:
+ *
+ *   "language": { "type": "string", "projectProperty": "content.language" }
+ */
+declare const PARAM_PROJECT_PROPERTY_KEY = "projectProperty";
+/** Read the annotation off one paramSchema property object, if present. */
+declare function paramProjectProperty(paramSchemaProperty: unknown): string | undefined;
+
+/**
+ * Growth cosmetic unlock catalog — the single source of truth shared by
+ * the service (validating cosmetic proposals) and the UI (labels +
+ * accessory-dialog gating). Entries reference REAL poppetje slots only;
+ * the level badge is an HTML chip rendered automatically at level ≥2,
+ * not an unlock.
+ *
+ * Gating is UI-enforced and only blocks NEWLY selecting a locked option —
+ * a gezel already wearing one keeps it (grandfathering).
+ */
+interface GrowthCosmetic {
+    /** Stable id stored in growth.json's unlockedCosmetics. */
+    id: string;
+    slot: 'hat' | 'dress' | 'accessory';
+    /** The poppetje option value this unlocks. */
+    option: string;
+    label: string;
+    /** Level at which this becomes selectable. */
+    level: number;
+}
+declare const GROWTH_COSMETICS: readonly GrowthCosmetic[];
+declare function growthCosmeticById(id: string): GrowthCosmetic | undefined;
+/** The next cosmetic at or below `level` that isn't in `unlockedIds`, if any. */
+declare function nextLockedCosmetic(level: number, unlockedIds: ReadonlySet<string>): GrowthCosmetic | undefined;
+
+/**
+ * Centralized security & compliance resolution.
+ *
+ * One config object (`config.securityPolicy`) is the single source of
+ * truth; every enforcement seam in the app resolves it through
+ * {@link resolveSecurityPolicy} and reads the effective capability set —
+ * never the raw level. The `level` is purely a UI label.
+ *
+ * The capability axis that actually matters is **agency**: these flags
+ * gate what the *model* may do autonomously. User-initiated actions (a
+ * human pulling a GitHub repo, downloading a HuggingFace model, the app
+ * running its own npm/node/CLI/MCP processes) are deliberately exempt.
+ */
+type SecurityLevel = SecurityPolicy['level'];
+/** A preset level (everything except the synthetic `custom`). */
+type SecurityPresetLevel = Exclude<SecurityLevel, 'custom'>;
+/** The five authoritative capability booleans (no `level`). */
+type SecurityCapabilities = Omit<SecurityPolicy, 'level'>;
+/**
+ * Copilot's SDK-native tools run outside Gezel's scoped MCP bridge. Keep
+ * those built-ins denied unless the user explicitly opts out, so an absent
+ * setting cannot bypass project scope, security-policy sinks, or auditing.
+ */
+declare const DEFAULT_SANDBOX_COPILOT = true;
+/**
+ * Resolve the install-level Copilot sandbox setting plus an optional
+ * per-gezel override. Explicit `false` remains the deliberate escape hatch;
+ * missing values fail closed to the sandboxed MCP surface.
+ */
+declare function resolveSandboxCopilot(installSetting: boolean | undefined, gezelOverride?: boolean): boolean;
+/**
+ * The resolved posture: the five stored capabilities plus the derived
+ * predicates the enforcement points consume directly.
+ */
+interface ResolvedSecurityPolicy extends SecurityCapabilities {
+    /** Echoed for UI/telemetry; never read by enforcement. */
+    level: SecurityLevel;
+    /**
+     * Whether non-builtin (third-party) MCP toolsets may load. They bypass
+     * the builtin tool allowlist and can't be confined yet, so a declared
+     * "local-only" scope isn't trustworthy — allowed at `free` only.
+     */
+    allowNonBuiltinToolsets: boolean;
+    /**
+     * Whether the model's git/github tools (`run_git`, `github_*`) surface.
+     * Rides on file edits: git push / PR creation are mutations, and the
+     * `lockdown` preset (which enables edits) is exactly where GitHub R/W is
+     * intended to work, while `super-lockdown` (edits off) keeps the model
+     * out of git entirely. User-initiated GitHub R/O is unaffected — that
+     * path never goes through these tools.
+     */
+    allowModelGit: boolean;
+    /**
+     * Whether email sync + send may run. Both reach an external mail provider
+     * over the network, so they ride on `allowExternalServices` — present only
+     * at `free` among the presets. Under `lockdown`/`super-lockdown` the mail
+     * subsystem stays dormant: no background sync, and the send tool is not even
+     * exposed to the model (the strongest form of injection containment — the
+     * capability simply isn't there). User-initiated linking of a mailbox is a
+     * separate, deliberate action and is not gated here.
+     */
+    allowMail: boolean;
+}
+/**
+ * Preset → capability mapping. Keep in lockstep with the table in the
+ * Security & Compliance plan / panel copy.
+ *
+ * - `super-lockdown`: nothing leaves the machine. Local models only, no
+ *   services, no scripts, no auto-update, no model git, and no
+ *   shared-document writes from scripts. Read/review/index and the builtin
+ *   artifact/document tools still work.
+ *   Workspace file writes are NOT globally gated by this level — they are
+ *   governed per project by {@link projectWorkspaceWritable}: internal
+ *   workspaces (our own folder, nothing precious) stay writable, external
+ *   working directories stay deny-until-opted-in.
+ * - `lockdown`: coding posture. Edits, scripts, cloud chat, GitHub R/W,
+ *   auto-update — but no open-web research (services off).
+ * - `free`: everything.
+ */
+declare const SECURITY_PRESETS: Record<SecurityPresetLevel, SecurityCapabilities>;
+/**
+ * Fail-safe posture for a config with no stored policy. First-run migration
+ * explicitly writes `free` for legacy installs, preserving compatibility
+ * without making absence permanently mean "unrestricted".
+ */
+declare const DEFAULT_SECURITY_LEVEL: SecurityPresetLevel;
+/**
+ * Build a full {@link SecurityPolicy} object for a preset level — used by
+ * the slider (and the first-run step) to write the five booleans in
+ * lockstep with the chosen level.
+ */
+declare function securityPolicyForLevel(level: SecurityPresetLevel): SecurityPolicy;
+/**
+ * Given a set of capability booleans, return the preset level they match,
+ * or `'custom'` if they don't match any preset. Lets the UI re-label the
+ * slider to "Custom" the moment a toggle is flipped off-preset.
+ */
+declare function classifySecurityLevel(caps: SecurityCapabilities): SecurityLevel;
+/**
+ * Effective per-project workspace writability for gezel-initiated work —
+ * THE single gate for workspace file writes (tool surface, script
+ * `workspace.write` capability, Store mutations, ambient scheduler work).
+ *
+ * Semantics of `project.allowGezelWrites` (an optional boolean, so
+ * effectively a tri-state):
+ *
+ *   - explicit `true`  → writable, including external working dirs the
+ *     user has consented to (the confirmation-dialog path);
+ *   - explicit `false` → read-only for gezels, including internal
+ *     workspaces (the per-project "edits off" switch);
+ *   - unset            → internal workspaces are writable (our folder
+ *     under `~/.gezel/projects/<id>/workspace/`, no precious files),
+ *     external `workingDir`s are not (the user's real folder — writes
+ *     require the explicit opt-in above).
+ *
+ * The global security policy's `allowFileEdits` deliberately does NOT
+ * factor in: a fresh internal project (a checkers board, a scratch
+ * notebook) stays functional under super-lockdown, while folder-backed
+ * projects keep their deny-by-default consent gate at every security
+ * level. `undefined`/`null` project means the implicit default bucket —
+ * internal, writable.
+ */
+declare function projectWorkspaceWritable(project?: Pick<Project, 'workingDir' | 'allowGezelWrites'> | null): boolean;
+/**
+ * Resolve the effective security posture from config. The five stored
+ * booleans are always authoritative (the `level` is just a label); when
+ * the policy is absent we fall back to {@link DEFAULT_SECURITY_LEVEL}.
+ */
+declare function resolveSecurityPolicy(config: Pick<GezelConfig, 'securityPolicy'>): ResolvedSecurityPolicy;
+
+/**
+ * Single chokepoint for choosing between a gezel's friendly `name`
+ * ("Mira") and their kebab-case `roleBasedName` ("visual-designer").
+ *
+ * `roleBasedNameOnlyMode` is the global config flag: when on, every UI
+ * surface and every prompt substitution renders the role-based name.
+ * Imported from `@bendyline/gezel` by both UI and service.
+ */
+interface DisplayableGezel {
+    name: string;
+    roleBasedName?: string;
+}
+declare function displayName(g: DisplayableGezel, roleBasedNameOnlyMode: boolean): string;
+
+/**
+ * Process-wide structured logger. One namespaced instance per subsystem
+ * (`createLogger('chat')`, `createLogger('mcp-bridge')`, …) so output
+ * stays greppable and levels can be tuned without rewiring callers.
+ *
+ * The level gate is read from `GEZEL_LOG_LEVEL` at module load. Tests
+ * may override at runtime via `setLogLevel`. A null `GEZEL_LOG_LEVEL`
+ * defaults to `info` — debug noise stays off in packaged builds and CI
+ * unless a developer explicitly opts in.
+ *
+ * Per-namespace debug is available via `GEZEL_LOG_DEBUG` as a
+ * comma-separated allow-list (`GEZEL_LOG_DEBUG=chat,mcp-bridge`). A
+ * single `*` enables debug everywhere.
+ *
+ * Output goes to `stderr` for `warn`/`error`, `stdout` for `info`/`debug`,
+ * matching Node's defaults so log aggregators that split streams keep
+ * working.
+ */
+type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+interface Logger {
+    readonly name: string;
+    debug(message: string, ...rest: unknown[]): void;
+    info(message: string, ...rest: unknown[]): void;
+    warn(message: string, ...rest: unknown[]): void;
+    error(message: string, ...rest: unknown[]): void;
+    child(suffix: string): Logger;
+}
+declare function getLogLevel(): LogLevel;
+declare function setLogLevel(level: LogLevel): void;
+/**
+ * Override the per-namespace debug allow-list. Pass `null` to clear.
+ * Mainly used by tests; production callers set `GEZEL_LOG_DEBUG`.
+ */
+declare function setDebugNamespaces(spec: string | null): void;
+declare function createLogger(name: string): Logger;
+
+/**
+ * Text scrubbers for anything that leaves the machine or lands in a durable
+ * file: engine logs, persisted turn errors, and the body of a GitHub issue
+ * the user is about to file.
+ *
+ * Two tiers, deliberately separate:
+ *
+ *   - `redactCredentials` — credential shapes only. Cheap enough to run on
+ *     every log line, and safe to run on text the user will still read on
+ *     their own machine.
+ *   - `redactSensitive` — the publishing scrub. Adds home paths, temp dirs,
+ *     query-string tokens, and email addresses on top. Only for text that
+ *     is leaving the user's machine.
+ *
+ * Why the split: an `ENOENT … open '/Users/mike/proj/src/x.ts'` message is
+ * genuinely useful to the user *on their own machine*. Collapsing that path
+ * before they ever see it makes the app worse at the one thing errors are
+ * for. The user's own disk is not a threat surface for the user's own paths
+ * — a public issue tracker is.
+ *
+ * Why pattern-based (not a real secret-store diff):
+ *   - `SecretStore.listAll()` doesn't exist (and shouldn't — keyring
+ *     backends deliberately prevent bulk enumeration). So we'd have to copy
+ *     every known secret into plaintext memory just to build a substring
+ *     replacer. That's worse than scanning for the canonical shapes we know
+ *     carry credentials.
+ *   - False positives (redacting text that *looks* like a token but isn't)
+ *     cost nothing.
+ *   - False negatives would leak credentials. Be conservative.
+ *
+ * Browser-safe: regex only, no `node:` imports. The UI imports this.
+ */
+declare const REDACTED = "[REDACTED]";
+declare const REDACTED_EMAIL = "[EMAIL]";
+/**
+ * Replace any credential-shaped substrings with `[REDACTED]`. Pure function.
+ * Returns the input unchanged when no pattern matches.
+ */
+declare function redactCredentials(text: string): string;
+interface RedactSensitiveOptions {
+    /** Collapse user home prefixes to `~` / `$GEZEL_HOME`. Default true. */
+    homePaths?: boolean;
+    /** Replace email addresses with `[EMAIL]`. Default true. */
+    emails?: boolean;
+}
+/**
+ * Full scrub for text the user is about to PUBLISH. Credentials always; home
+ * paths and email addresses by default.
+ *
+ * Emails run before the credential table so the deliberately-broad JWT-ish
+ * pattern can never eat half of a dotted local-part.
+ */
+declare function redactSensitive(text: string, opts?: RedactSensitiveOptions): string;
+
+/**
+ * Shared knowledge about Ollama model families so the service and UI
+ * stay aligned on which models behave like "reasoning" models. Ollama
+ * doesn't expose a per-model capability flag we can trust today — this
+ * is a curated prefix list. Keep it narrow: include families that
+ * reliably consume their output budget on silent chain-of-thought
+ * before producing a visible reply, nothing else.
+ *
+ * Add a family here when:
+ *   1. Users report empty bubbles with the model selected.
+ *   2. The model's Ollama page documents a reasoning / thinking mode.
+ *
+ * If Ollama later adds `capabilities: ["thinking"]` to `/api/show`
+ * consistently, replace the prefix match with a runtime probe and
+ * drop the list.
+ */
+declare const OLLAMA_REASONING_MODEL_PREFIXES: string[];
+/**
+ * True when the given Ollama model id looks like a reasoning model.
+ * Matches both a leading prefix (`deepseek-r1:latest`) and an embedded
+ * substring (`hf.co/bartowski/qwen3-thinking-gguf:Q4_K_M`) so tag
+ * variants don't slip through. Case-insensitive.
+ */
+declare function isOllamaReasoningModel(modelId: string): boolean;
+/**
+ * Model families that leak unstructured chain-of-thought into the
+ * visible reply unless explicitly instructed to wrap it. Broader than
+ * `OLLAMA_REASONING_MODEL_PREFIXES` because the leakage problem isn't
+ * confined to thinking-mode-on models — Qwen 3 base, Qwen 2.5, and a
+ * handful of distillates pontificate freely as plain text and burn
+ * their output token budget before reaching the actual tool call.
+ *
+ * Substrings, not prefixes — modelId may be an Ollama tag
+ * (`qwen2.5:7b`), an MLX repo (`Qwen/Qwen3-30B-A3B-Instruct`), a
+ * llama.cpp filesystem path (`/models/qwen3-coder-30b.gguf`), or a
+ * bare HF id. Match case-insensitively against any substring.
+ *
+ * Add a family here when:
+ *   1. Users report responses where reasoning prose dominates and
+ *      tool calls truncate or fail to materialize.
+ *   2. The model's docs or runtime expose a native reasoning /
+ *      thinking mode.
+ */
+declare const MODEL_FAMILIES_LEAKING_REASONING: string[];
+/**
+ * True when the given model id (Ollama tag, MLX repo, llama.cpp path,
+ * or bare HF id) belongs to a family known to leak chain-of-thought
+ * into visible content unless told otherwise. Used by the system-
+ * prompt builder to add local-model guidance, and by the Ollama
+ * provider to bump the default `num_predict` cap so the leak doesn't
+ * truncate the actual tool call mid-stream.
+ */
+declare function leaksUntaggedReasoning(modelId: string | undefined): boolean;
+
+/**
+ * "Will this model run well on this machine?" — a hardware-fit tier for
+ * a chat model, used to badge/rank models in the install browser and the
+ * installed list.
+ *
+ * The key improvement over a naive `size > budget` check is **MoE
+ * awareness**. A big Mixture-of-Experts model (e.g. a 35B-A3B at ~20 GB)
+ * won't fit a 12 GB discrete GPU by raw size, but its sparse expert
+ * weights can stream from system RAM (`--cpu-moe`) while attention runs
+ * on the GPU — so it runs fine on a 12 GB card + 64 GB RAM. A naive
+ * check labels it "may not fit"; this one labels it "runs (expert
+ * offload)", which is exactly the "prefer MoE that fits" guidance.
+ *
+ * Pure and deterministic → unit-tested. The caller supplies the model's
+ * estimated footprint and the machine's memory profile (both already
+ * available from the catalog manifest + `/api/system/memory`).
+ */
+type ModelFitTier = 'fits' | 'fits-offload' | 'tight' | 'too-big';
+interface ModelFitInput {
+    /** Estimated GPU/host working set: on-disk size × overhead (KV, activations). */
+    residentBytes: number;
+    /** Mixture-of-Experts model — its experts can stream from system RAM. */
+    isMoE: boolean;
+    /** The fast memory budget: VRAM on a discrete GPU, a RAM fraction on unified/CPU. */
+    usableBytes: number;
+    /** Total system RAM in bytes. */
+    totalRamBytes: number;
+    /** Discrete GPU VRAM in bytes, or null on unified-memory / CPU-only machines. */
+    gpuVramBytes: number | null;
+    /**
+     * What the capacity broker will actually admit on this machine
+     * (`/api/system/memory` → `budgetBytes`). Anything above it is refused at
+     * load time, so it — not a raw fraction of RAM — is where `too-big` starts.
+     *
+     * Optional for callers that predate the field; they keep the old
+     * {@link RAM_OFFLOAD_FRACTION} ceiling, which on a discrete-GPU host
+     * over-promised: it offered a 42 GB MoE against 80% of system RAM while
+     * the broker's budget stopped at 60%, so the download succeeded and the
+     * load did not.
+     */
+    admissibleBytes?: number;
+    /**
+     * Bytes `--cpu-moe` leaves GPU-resident (attention, dense/shared layers,
+     * embeddings) — from the installed GGUF's tensor table, when scanned.
+     * Absent (browse-time, pre-download) the check falls back to
+     * {@link MOE_NON_EXPERT_FRACTION_ESTIMATE} of `residentBytes`.
+     */
+    nonExpertBytes?: number;
+}
+interface ModelFitResult {
+    tier: ModelFitTier;
+    /** Short pill label. */
+    label: string;
+    /** Longer tooltip explanation. */
+    detail: string;
+    /** True when the model can run at all (tier !== 'too-big'). */
+    runnable: boolean;
+}
+/**
+ * Browse-time estimate of the non-expert share of a MoE's footprint —
+ * what `--cpu-moe` keeps on the GPU. Measured GGUFs run 5–10% for
+ * DeepSeek-class giants and ~10–20% for consumer-size MoEs; 15% sits at
+ * the honest end without gating out the machines full offload does serve
+ * (a 4 GB card still clears a 26B-A4B). The exact per-tensor figure
+ * replaces this whenever the caller has scanned the installed GGUF.
+ */
+declare const MOE_NON_EXPERT_FRACTION_ESTIMATE = 0.15;
+/**
+ * The working window Gezel guarantees a local chat model on a host with room
+ * to spare. Tool loops, a project brief, and a few file reads spend most of a
+ * 32K window before the user's second question, so this is the floor admission
+ * defends by shedding engine slots rather than shortening context.
+ */
+declare const LOCAL_CONTEXT_FLOOR_TOKENS = 65536;
+/**
+ * The same floor on a memory-constrained host ({@link isMemoryConstrainedMachine}).
+ * Half a working window still runs agentic loops — sessions just compact
+ * sooner — while insisting on 64K there denies the launch outright: the KV at
+ * 64K is what pushes a small machine past its budget, and a denial gives the
+ * user nothing at all.
+ */
+declare const CONSTRAINED_LOCAL_CONTEXT_FLOOR_TOKENS = 32768;
+/**
+ * System RAM at or below which a unified-memory or CPU-only host counts as
+ * memory-constrained. On those hosts the KV cache competes with the OS, the
+ * Electron shell, and the weights for the same pool.
+ */
+declare const CONSTRAINED_HOST_RAM_BYTES: number;
+/**
+ * Usable VRAM at or below which a discrete card counts as memory-constrained.
+ * Compared against the USABLE figure (~95% of the card), so an 8 GB card lands
+ * under the line and a 10 GB one does not.
+ */
+declare const CONSTRAINED_HOST_VRAM_BYTES: number;
+/** The memory shape of a host, as much of it as the context floor depends on. */
+interface MachineMemoryShape {
+    totalRamBytes: number;
+    /** Usable VRAM on a discrete card; null on unified / integrated / CPU-only hosts. */
+    gpuVramBytes: number | null;
+}
+/**
+ * Whether this host has to trade context for memory. A discrete card is judged
+ * on VRAM alone — that is where its KV lives, so a 24 GB card next to 16 GB of
+ * system RAM is not context-constrained. Everything else (Apple Silicon,
+ * integrated GPUs, CPU-only) is judged on system RAM, the one pool it has.
+ */
+declare function isMemoryConstrainedMachine(machine: MachineMemoryShape): boolean;
+/**
+ * The context floor to hold this host to. The single derivation both the
+ * daemon's admission ladder and the install browser's fit badges read, so a
+ * model is never badged against a window admission would not have asked for.
+ */
+declare function localContextFloorTokens(machine?: MachineMemoryShape | null): number;
+/**
+ * The working window fit badges price KV at when the caller knows nothing
+ * about the host. Prefer {@link localContextFloorTokens} with the machine's
+ * memory profile — a constrained host launches at half this.
+ */
+declare const FIT_KV_CONTEXT_TOKENS = 65536;
+/**
+ * KV bytes a model would carry at the fit window, from the catalog's
+ * authored f16 geometry (`kvBytesPerTokenF16` / `kvFixedBytesF16`).
+ * Returns 0 when the manifest predates the fields — the fit check then
+ * degrades to the historical weights-only estimate rather than blocking.
+ * `cacheScale` converts the f16 baseline to the engine's cache dtype
+ * (llama.cpp defaults to q8_0 ≈ 0.55; MLX runs f16 = 1).
+ */
+declare function estimateManifestKvBytes(manifest: {
+    kvBytesPerTokenF16?: number;
+    kvFixedBytesF16?: number;
+}, opts?: {
+    ctxTokens?: number;
+    cacheScale?: number;
+}): number;
+/**
+ * Classify a model's fit against a machine's memory. See the module
+ * doc for the MoE-offload rationale.
+ */
+declare function computeModelFit(input: ModelFitInput): ModelFitResult;
+/**
+ * Best-effort Mixture-of-Experts detection from a model's catalog tags,
+ * for browse-time (pre-install, no GGUF on disk). The catalog tags MoE
+ * models inconsistently — `moe`, `mix of experts`, `mixture of experts`
+ * — so we normalize all of them. Once installed, the GGUF's
+ * `expert_count` is the ground truth (see the offload planner).
+ */
+declare function isMoEFromTags(tags: readonly string[] | undefined): boolean;
+
+/**
+ * Compose the static RAM-axis fit (`computeModelFit`) with a persisted
+ * fitness record (the proeve result) into one display badge. Pure and
+ * unit-tested; shared by the UI pills and any service consumer.
+ *
+ * Warnings never gate: the badge informs, selection stays possible
+ * everywhere.
+ */
+
+type FitnessBadgeTier = 'ok' | 'warn' | 'probing' | 'unknown';
+interface FitnessBadge {
+    tier: FitnessBadgeTier;
+    /** Short pill label. */
+    label: string;
+    /** Longer tooltip explanation. */
+    detail: string;
+}
+interface FitnessBadgeInput {
+    /** Static RAM-axis fit, when known (browse and installed surfaces). */
+    ramFit?: ModelFitResult;
+    /** Persisted proeve result plus its read-time freshness flags. */
+    fitness?: {
+        record: ModelFitnessRecord;
+        stale: boolean;
+        hardwareChanged: boolean;
+    };
+    /** A probe for this model is currently queued or running. */
+    probing?: boolean;
+}
+declare function composeFitnessBadge(input: FitnessBadgeInput): FitnessBadge;
+
+/**
+ * The fields the recommendation gate reads — the structural subset every
+ * model manifest satisfies, so the same predicate covers chat, image, video
+ * and audio entries.
+ */
+interface RecoGateInput {
+    /** Hand-curated recommendation weight; absent → never recommended. */
+    recoScore?: number;
+    /** Only `'open'` models are ever recommended. */
+    licenseClass?: string;
+    /** Chat models declare this; media manifests have no such field. */
+    supportsTools?: boolean;
+}
+/**
+ * The single "would we recommend this model?" gate. The first-run picker
+ * below, the ★ Recommended badge, the CLI bootstrap and the media pickers all
+ * call this so they can never drift apart.
+ *
+ * Three conditions:
+ *   1. a hand-curated positive `recoScore` — absent means no one nominated it;
+ *   2. a fully-open license, so a stray score on a restricted model is ignored;
+ *   3. tool support. Gezels do their work THROUGH the MCP toolset, so a model
+ *      that cannot call tools is never a sane default no matter how good its
+ *      prose is — it stays installable, but choosing it has to be the user's
+ *      deliberate act, not ours.
+ *
+ * Media manifests carry no `supportsTools` field, hence `!== false` rather
+ * than `=== true`: undefined passes, only an explicit refusal disqualifies.
+ */
+declare function isRecommendedModel(m: RecoGateInput): boolean;
+/**
+ * A discrete GPU with more than this much VRAM runs a dense model fully
+ * resident, so MoE expert-offload is a downgrade — skip MoE candidates.
+ */
+declare const DENSE_ONLY_VRAM_THRESHOLD: number;
+interface RecoModelInput extends RecoGateInput {
+    id: string;
+    /** Catalog tags — MoE-ness is read from these via `isMoEFromTags`. */
+    tags?: readonly string[];
+    /** Provider-appropriate working set (manifest `residentBytes`, or on-disk × overhead). */
+    residentBytes: number;
+    /** Exact GPU-resident residue under `--cpu-moe`, when the GGUF has been scanned. */
+    nonExpertBytes?: number;
+}
+interface RecoDevice {
+    platform: string;
+    /** GPU-addressable memory in bytes, or null when no accelerator was detected. */
+    gpuVramBytes: number | null;
+    /**
+     * How that GPU memory relates to system RAM. Optional for compatibility
+     * with older daemons/callers; absent values are inferred from
+     * `gpuVramBytes` as far as possible.
+     *
+     * `integrated` is the consumer iGPU/UMA case where a Vulkan adapter may
+     * advertise part of system RAM as device memory. `unified` is reserved for
+     * high-throughput unified accelerators such as Apple Silicon and NVIDIA
+     * GB10/DGX Spark, which must not be collapsed onto the CPU-only path.
+     */
+    gpuMemoryKind?: 'discrete' | 'integrated' | 'unified' | 'none' | 'unknown';
+    totalRamBytes: number;
+    /** The fast memory budget (VRAM on a discrete card, a RAM fraction otherwise). */
+    usableBytes: number;
+    /**
+     * What the capacity broker will admit across every pool — `budgetBytes`
+     * from `/api/system/memory`. Optional so older callers keep working; when
+     * present it becomes the runnable ceiling, so we never recommend a model
+     * the daemon then refuses to load.
+     */
+    budgetBytes?: number;
+}
+interface RecoPick {
+    id: string;
+    recoScore: number;
+    /** One-line human-readable rationale (logged + surfaced to the user). */
+    reason: string;
+}
+/**
+ * Below 8 GiB, a discrete card cannot keep even a useful medium local model
+ * resident. Expert offload may make a much larger MoE technically load, but
+ * decode is then paced by system RAM/CPU and is not a functional first-run
+ * recommendation.
+ */
+declare const SMALL_MODEL_VRAM_THRESHOLD: number;
+/**
+ * Non-Mac hosts that should receive the smallest safe recommended model:
+ * CPU-only, consumer integrated/UMA graphics, or a discrete card below 8 GiB.
+ * High-performance unified accelerators (notably GB10/DGX Spark) stay on the
+ * normal large-model path.
+ */
+declare function needsSmallModelRecommendation(device: RecoDevice): boolean;
+/** MoE offload is a Mac / small-GPU win; a big discrete GPU prefers dense. */
+declare function prefersMoE(device: RecoDevice): boolean;
+/** Big discrete GPU (> 24 GB VRAM, non-Mac) → run dense; drop MoE candidates. */
+declare function excludesMoE(device: RecoDevice): boolean;
+/**
+ * Unified-memory host: Apple Silicon, or a non-Mac where the reported
+ * "VRAM" is really the shared pool (GB10 / DGX Spark: nvidia-smi reports
+ * no VRAM, so llama-server's device probe returns ~all of system RAM).
+ *
+ * Known gap this predicate exists to route around: `excludesMoE` above
+ * reads `gpuVramBytes > 24 GB, non-Mac` as "big discrete GPU" and so
+ * misfires TRUE on unified non-Mac hosts — exactly the bandwidth-bound
+ * machines where MoE is the right call. Fixing `excludesMoE` changes
+ * the first-run auto-pick and is deferred to a deliberate review (see
+ * docs/model-fitness.md); the browse hint uses these predicates instead.
+ */
+declare function isUnifiedMemoryDevice(device: RecoDevice): boolean;
+/**
+ * Memory-bandwidth-bound host — unified memory, or a small discrete GPU
+ * that must stream weights from system RAM. On these machines a sparse
+ * MoE model (few experts active per token) responds faster than a dense
+ * model of the same size.
+ */
+declare function isBandwidthBoundHost(device: RecoDevice): boolean;
+interface HardwareHint {
+    kind: 'moe-good-match' | 'large-dense-caution' | 'low-acceleration-caution';
+    /** Short pill label. */
+    label: string;
+    /** Longer tooltip explanation. */
+    detail: string;
+}
+/**
+ * Browse-time, hint-only guidance for one model on this machine.
+ * Advisory copy beside the fit pill — it never filters, ranks, or
+ * changes the first-run pick (`prefersMoE`/`excludesMoE` above stay
+ * byte-identical for that path).
+ */
+declare function hardwareHint(device: RecoDevice, model: {
+    isMoE: boolean;
+    fitTier: string;
+    residentBytes?: number;
+}): HardwareHint | null;
+/**
+ * Pick the recommended model to install on `device`, or null when the catalog
+ * carries no eligible (scored + open) candidate at all.
+ */
+declare function pickRecommendedModel(models: readonly RecoModelInput[], device: RecoDevice): RecoPick | null;
+declare function videoMemoryBudgetBytes(device: RecoDevice): number;
+/**
+ * Simple fit check for a MEDIA model (image / video). Image generation leans
+ * on system RAM (sd-cpp runs partly on CPU), so it gates on `minRamGB`; video
+ * generation needs real GPU VRAM (or Apple unified memory), so it gates on
+ * `minVramGB` against the video-specific budget above. A field left undefined
+ * isn't checked. Audio models carry neither floor, so callers treat them as
+ * always fitting. Deliberately coarser than the chat picker — there's one
+ * recommended model per media modality, so this only answers "can this device
+ * run it at all?".
+ */
+declare function mediaModelFits(device: RecoDevice, req: {
+    minRamGB?: number;
+    minVramGB?: number;
+}): boolean;
+
+/**
+ * Friendly-display utilities for the tool names that flow through the
+ * chat event stream.
+ *
+ * Background: Claude CLI references MCP tools as `mcp__<server>__<tool>`
+ * (e.g. `mcp__gezel__read_task_notes`, `mcp__playwright_mcp__browser_navigate`).
+ * The raw form leaks our wire-protocol naming into UI surfaces — both
+ * tool-call rows and intent breadcrumbs. Stripping the prefix and
+ * humanizing the underscores gives the user a name they can actually
+ * read ("read task notes" / "browser navigate") without us having to
+ * thread the rich per-tool display map (lives in the UI layer) through
+ * every code path.
+ *
+ * Shared between service and UI so service-emitted intent labels
+ * ("using <tool>", "approved: <tool>", "awaiting your approval to use
+ * <tool>") and UI-side tool-row rendering use the same conventions.
+ */
+/**
+ * Strip Claude CLI's `mcp__<server>__` prefix from a tool name. The
+ * format is two-underscore-delimited (`__`) so server names that
+ * themselves contain a single underscore (e.g. `playwright_mcp`) split
+ * cleanly. Tools without the prefix (Claude built-ins like `Bash`,
+ * `Read`; or gezel-mcp tools referenced bare like `save_memory` from
+ * inside our own bridge) pass through unchanged.
+ */
+declare function stripMcpPrefix(name: string): string;
+/**
+ * Lightweight humanizer for tool names. Strips the MCP prefix and
+ * replaces underscores with spaces. Returns lowercase — callers that
+ * want title-case render via CSS (`text-transform: capitalize`) or
+ * apply their own casing.
+ *
+ * Doesn't carry a rich per-tool display map — the UI's
+ * `toolDisplayName` does that on top of `stripMcpPrefix`. This helper
+ * is for service-side intent labels where the rich map isn't worth
+ * threading through and a humanized fallback is enough.
+ */
+declare function prettifyToolName(name: string): string;
+/**
+ * Short, transient status text for a tool that is currently running.
+ * Concrete tools keep their humanized name so the user sees useful
+ * progress ("advance task step"), while provider-level implementation
+ * buckets get a natural-language activity instead of protocol jargon.
+ */
+declare function toolActivityLabel(name: string): string;
+
+declare const maleNames: string[];
+declare const femaleNames: string[];
+declare function pickRandomName(): string;
+/**
+ * Pronoun string for a gezel's gender — `he/him`, `she/her`, `they/them`.
+ * Used in system-prompt headers and when one gezel references another.
+ */
+declare function pronounsForGender(gender: GezelGender): string;
+/**
+ * Grammatical forms for referring to a gezel in prose.
+ *
+ * `gender` is optional because legacy gezels predate the persisted field.
+ * Unknown assignments fall back to neutral they/them rather than guessing
+ * from the gezel's name.
+ */
+interface GezelPronounForms {
+    subject: 'he' | 'she' | 'they';
+    object: 'him' | 'her' | 'them';
+    possessiveAdjective: 'his' | 'her' | 'their';
+    possessive: 'his' | 'hers' | 'theirs';
+    reflexive: 'himself' | 'herself' | 'themselves';
+    presentBe: 'is' | 'are';
+    presentHave: 'has' | 'have';
+}
+declare function pronounFormsForGender(gender?: GezelGender): GezelPronounForms;
+/**
+ * Pick a random first name AND the gender that goes with it. Names are
+ * drawn 50/50 from the gendered pools; then a flat NON_BINARY_RATE share
+ * of generated gezels has their gender flipped to non-binary (the name
+ * is kept). Callers that want gender derived from a pre-chosen name
+ * should use {@link inferGenderForName} instead.
+ */
+declare function pickRandomNameWithGender(): {
+    name: string;
+    gender: GezelGender;
+};
+/**
+ * Infer a gender for an arbitrary first name. Used by `Store.createGezel`
+ * when the caller hands in an explicit name (Meester pool, MCP-supplied,
+ * user-typed) without a paired gender. NB conversion is applied first
+ * (so even pool names occasionally land non-binary); otherwise the name
+ * is looked up in the gendered pools, falling back to a coin flip for
+ * names not in either list.
+ */
+declare function inferGenderForName(name: string): GezelGender;
+
+interface KokoroVoiceInfo {
+    id: string;
+    name: string;
+    language: 'en-US' | 'en-GB';
+    gender: 'male' | 'female';
+    /** Upstream's overall quality grade — used to weight the random picker. */
+    grade: 'A' | 'A-' | 'B+' | 'B' | 'B-' | 'C+' | 'C' | 'C-' | 'D+' | 'D' | 'D-' | 'F+';
+}
+/**
+ * Full Kokoro voice catalog. Source: the `VOICES` dict in
+ * `kokoro-js@1.2.1/dist/kokoro.js` (model card on the HF repo
+ * `onnx-community/Kokoro-82M-v1.0-ONNX`). Grades reflect upstream's
+ * subjective overall ranking; the picker prefers higher grades so the
+ * average gezel sounds decent.
+ */
+declare const KOKORO_VOICES: readonly KokoroVoiceInfo[];
+declare function findKokoroVoice(id: string): KokoroVoiceInfo | undefined;
+declare function isValidKokoroVoice(id: string): boolean;
+/**
+ * Pick a Kokoro voice id appropriate for a gezel's gender. `male` →
+ * `am_*`/`bm_*` voices; `female` → `af_*`/`bf_*`. `non-binary` draws
+ * uniformly from the full catalog so the assignment doesn't lean on
+ * the catalog's male/female split. Quality grade biases the weighting
+ * within the eligible pool.
+ *
+ * Deterministic when a `seed` is supplied — used by tests and by the
+ * createGezel path so the same id always picks the same voice on a
+ * re-roll. Without a seed, `Math.random` drives the draw.
+ */
+declare function pickKokoroVoiceForGender(gender: GezelGender | undefined, opts?: {
+    seed?: number;
+}): string;
+
+/**
+ * Poppetje catalogs — every option the figure renderer knows how to draw.
+ *
+ * Single source of truth shared by the service (persists resolved structs),
+ * the seed generator (picks from these arrays), and the UI renderer (looks
+ * up archetype dimensions). Originally ported from the renderer handoff; see
+ * `docs/poppetje-rendering.md` for the maintained visual contract.
+ */
+
+/** Width control points (5) for each body silhouette, in the 80-wide viewBox. */
+interface BodyArchetype {
+    baseW: number;
+    hipW: number;
+    waistW: number;
+    chestW: number;
+    shoulderW: number;
+    label: string;
+    note: string;
+}
+/**
+ * Width control points (5) per body archetype, in the 80-wide viewBox.
+ * Earlier versions clustered all six within ~10 units of each other, so
+ * `broad` / `athletic` / `stout` were nearly indistinguishable silhouettes.
+ * Spread them out — and in particular, give `broad` and `athletic` actual
+ * shoulder width (the original `broad: shoulderW=42` pinched at the top,
+ * which directly contradicted its "broad through the shoulders" brief).
+ */
+declare const BODY_ARCHETYPES: Record<string, BodyArchetype>;
+declare const BODY_SHAPE_KEYS: BodyShape[];
+type BodyShape = 'broad' | 'tapered' | 'curvy' | 'athletic' | 'slender' | 'stout';
+interface FigureScaleDef {
+    bodyScale: number;
+    headScale: number;
+    label: string;
+    note: string;
+}
+declare const FIGURE_SCALES: Record<string, FigureScaleDef>;
+declare const FIGURE_SCALE_KEYS: FigureScale[];
+type FigureScale = 'adult' | 'shorter' | 'child' | 'toddler';
+/** Wood-grain filter presets. Tune displacement, alpha, and streak frequency together. */
+interface GrainPreset {
+    skip?: boolean;
+    dispScale?: number;
+    /** Strength of the translucent grain tint after fiber contrast. */
+    opacity?: number;
+    /** Small blur applied after displacement so fibers read through paint. */
+    soften?: number;
+    streakFreq?: string;
+}
+/**
+ * Wood-grain finish presets. The stable key adds a separate material
+ * character (fine, flowing, cathedral, or knotty) inside each finish.
+ * Texture should remain below facial features, but must still be visible at
+ * the full-figure sizes used in detail views and galleries.
+ */
+declare const GRAIN_PRESETS: Record<string, GrainPreset>;
+type GrainStyle = 'none' | 'straight' | 'wavy' | 'pronounced' | 'character';
+declare const HAT_OPTIONS: readonly ["cap", "beanie", "kerchief", "straw", "newsboy", "hood"];
+type HatOption = (typeof HAT_OPTIONS)[number];
+declare const DRESS_OPTIONS: readonly ["scarf", "apron", "collar", "turtleneck"];
+type DressOption = (typeof DRESS_OPTIONS)[number];
+declare const HAIR_SHAPES: readonly ["halo", "short", "long", "bun", "braids", "shaved", "bald"];
+type HairShape = (typeof HAIR_SHAPES)[number];
+/**
+ * Wearable accessories — things a gezel can put on or take off, so
+ * they're user-toggleable from the appearance dialog. Physical facial
+ * features (facial hair, freckles, moles) deliberately live in their own
+ * slots below and only ever change on a reroll.
+ *
+ * Earring sides are named from the VIEWER's perspective (what you see in
+ * the preview), not the wearer's; `earrings` is the both-ears default.
+ * Legacy `accessory: 'earring'` files migrate to `earrings` on read.
+ * Hair-zone accessories (flower, hairclip, headband, feather, pencil, ribbon)
+ * hide while a hat is worn — same rule as hair itself.
+ */
+declare const ACCESSORY_OPTIONS: readonly ["glasses", "sunglasses", "cateye", "readers", "monocle", "eyepatch", "earrings", "earring-left", "earring-right", "flower", "hairclip", "headband", "bowtie", "necklace", "brooch", "facemask", "goggles", "safety-glasses", "pince-nez", "headphones", "hearing-aid", "nose-ring", "hoop-earrings", "drop-earrings", "pearl-earrings", "bandage", "feather", "pencil", "ribbon", "necktie", "cravat", "bolo-tie", "lanyard", "medal", "pocket-square", "tool-pendant"];
+type AccessoryOption = (typeof ACCESSORY_OPTIONS)[number];
+/**
+ * Rarity tiers for *random* accessory assignment. The appearance dialog
+ * still offers every option freely; these weights only bias the seed
+ * generator so distinctive pieces (eyepatch, a single asymmetric earring)
+ * stay rare instead of landing as often as plain glasses.
+ */
+type AccessoryRarity = 'common' | 'uncommon' | 'rare' | 'veryRare';
+/** Relative draw weights per tier. Higher = more likely. */
+declare const ACCESSORY_RARITY_WEIGHT: Record<AccessoryRarity, number>;
+interface AccessoryRarityEntry {
+    rarity: AccessoryRarity;
+    /** Per-gender overrides; falls back to `rarity` for any gender not listed. */
+    byGender?: Partial<Record<GezelGender, AccessoryRarity>>;
+}
+/**
+ * Per-accessory rarity. Everyday items (glasses, both-ear earrings, necklace)
+ * stay common; novelty pieces are rare-to-very-rare. A single left- or
+ * right-only earring is `rare` in general but `veryRare` on female gezels.
+ */
+declare const ACCESSORY_RARITY: Record<AccessoryOption, AccessoryRarityEntry>;
+/**
+ * Per-dress rarity, reusing the shared {@link AccessoryRarity} tiers and
+ * {@link ACCESSORY_RARITY_WEIGHT}. Everyday garments (scarf, collar,
+ * turtleneck) stay common; the workshop apron is a `veryRare` novelty so it
+ * seldom lands on a randomly seeded gezel. As with accessories, this only
+ * biases the seed generator — the appearance dialog still offers every dress
+ * freely. Dresses carry no per-gender overrides, so a flat tier map suffices.
+ */
+declare const DRESS_RARITY: Record<DressOption, AccessoryRarity>;
+/**
+ * Facial hair — a physical feature, never user-toggleable. Split out of the
+ * accessory slot so a gezel can wear glasses AND have a beard, and so the
+ * appearance dialog can edit wearables without ever clobbering facial hair.
+ * Gender-gated during seed generation (female gezels never auto-roll it).
+ */
+declare const FACIAL_HAIR_OPTIONS: readonly ["beard", "mustache"];
+type FacialHairOption = (typeof FACIAL_HAIR_OPTIONS)[number];
+declare const MARK_OPTIONS: readonly ["freckles", "mole"];
+type MarkOption = (typeof MARK_OPTIONS)[number];
+/**
+ * Painted garment patterns — flat paint over the body silhouette, applied
+ * under the wood grain so they read as decoration painted onto the carved
+ * figure (not stickers floating above it). `plain` is the bare shirt.
+ */
+declare const SHIRT_PATTERN_OPTIONS: readonly ["plain", "buttons", "stripes", "sash", "yoke", "twotone"];
+type ShirtPattern = (typeof SHIRT_PATTERN_OPTIONS)[number];
+/**
+ * Felt palette for cloth hats (cap, beanie, kerchief, newsboy). Hats used
+ * to render in the shirt's accent color, which camouflaged them into the
+ * body — a hat should read as its own object, like the straw hat always
+ * has. The felt is picked deterministically from the poppetje `key` (plus
+ * the hat name), so a gezel's cap is the same red forever, but its beanie
+ * — if a reroll ever lands one — gets an independent color.
+ * `hood` deliberately stays in the shirt accent: it's part of the garment.
+ */
+declare const HAT_FELTS: readonly [{
+    readonly felt: "#a8554a";
+    readonly band: "#7c3a32";
+}, {
+    readonly felt: "#c9973f";
+    readonly band: "#96702c";
+}, {
+    readonly felt: "#5d7257";
+    readonly band: "#42523e";
+}, {
+    readonly felt: "#4e6586";
+    readonly band: "#374a64";
+}, {
+    readonly felt: "#43474e";
+    readonly band: "#2e3138";
+}, {
+    readonly felt: "#8a5a78";
+    readonly band: "#64405a";
+}];
+declare const EXPRESSION_OPTIONS: readonly ["smile", "wider", "neutral", "wink", "sleepy"];
+type Expression = (typeof EXPRESSION_OPTIONS)[number];
+/** Workshop palette — skin/skin2 pairs, hair colors, shirt/accent pairs. */
+declare const PALETTE: {
+    readonly skins: readonly [{
+        readonly skin: "#ecd5b8";
+        readonly skin2: "#b8a080";
+    }, {
+        readonly skin: "#dbb898";
+        readonly skin2: "#a98870";
+    }, {
+        readonly skin: "#e6c7a8";
+        readonly skin2: "#b89478";
+    }, {
+        readonly skin: "#d4b896";
+        readonly skin2: "#a48c6c";
+    }, {
+        readonly skin: "#c79775";
+        readonly skin2: "#9d7050";
+    }, {
+        readonly skin: "#9c6b48";
+        readonly skin2: "#7a5236";
+    }, {
+        readonly skin: "#a87852";
+        readonly skin2: "#7d5436";
+    }, {
+        readonly skin: "#5d3a24";
+        readonly skin2: "#3d2418";
+    }];
+    readonly hairs: readonly ["#1a1410", "#2a1d12", "#3a2418", "#5a3a1c", "#7a5230", "#a87042", "#cc7744", "#d4a060", "#9a948a", "#dcd5c8", "#1f1812"];
+    /**
+     * Shirt mid-tone + accent pairs. The wood-grain filter multiplies a warm
+     * brown over the body, which costs every color a step of saturation and
+     * value — the earlier palette was so muted that indigo, slate, plum, and
+     * moss all converged to "gray robe" after the multiply. Mid-tones here
+     * are kept a step brighter than the target on-screen color, and the hues
+     * cover the full warm/cool wheel so a crew of poppetjes reads as a crowd
+     * of different outfits at a glance.
+     */
+    readonly shirts: readonly [{
+        readonly shirt: "#94a87c";
+        readonly accent: "#5c6a4a";
+    }, {
+        readonly shirt: "#6d7d54";
+        readonly accent: "#46543a";
+    }, {
+        readonly shirt: "#d07c56";
+        readonly accent: "#9a4e30";
+    }, {
+        readonly shirt: "#b65843";
+        readonly accent: "#7e382a";
+    }, {
+        readonly shirt: "#d2a350";
+        readonly accent: "#9a6c28";
+    }, {
+        readonly shirt: "#dcc06e";
+        readonly accent: "#a8863a";
+    }, {
+        readonly shirt: "#5b7cab";
+        readonly accent: "#2a4670";
+    }, {
+        readonly shirt: "#549191";
+        readonly accent: "#2f5f5f";
+    }, {
+        readonly shirt: "#7d8794";
+        readonly accent: "#4a5360";
+    }, {
+        readonly shirt: "#9d6890";
+        readonly accent: "#5a3850";
+    }, {
+        readonly shirt: "#c28b8b";
+        readonly accent: "#8f5454";
+    }, {
+        readonly shirt: "#7a9a62";
+        readonly accent: "#4a6a3a";
+    }];
+};
+/** Slot odds tuned for balanced diversity in seed-based generation. */
+declare const SLOT_ODDS: {
+    readonly hat: 0.3;
+    readonly dress: 0.22;
+    readonly accessory: 0.5;
+    readonly facialHair: 0.18;
+    readonly mark: 0.2;
+    /** Odds a figure gets any painted garment pattern (vs `plain`). */
+    readonly shirtPattern: 0.66;
+};
+/**
+ * Cumulative odds for the figure-scale roll. Height is the single
+ * strongest silhouette differentiator the renderer has, and the seed
+ * generator used to hardcode `adult` — every gezel stood exactly the
+ * same height. Most figures are still adults; shorter and small figures
+ * appear often enough that a crew lineup gets a varied skyline.
+ */
+declare const FIGURE_SCALE_ODDS: ReadonlyArray<{
+    scale: FigureScale;
+    upTo: number;
+}>;
+
+/**
+ * A resolved poppetje — the carved-figure character data for a gezel.
+ * Stored explicitly on disk so adding new catalog entries or tuning slot
+ * odds later never drifts existing characters. The renderer reads from
+ * this struct; the seed generator produces it.
+ */
+declare const PoppetjeSchema: z.ZodPreprocess<z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    bodyShape: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+    figureScale: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+    skin: z.ZodString;
+    skin2: z.ZodString;
+    hair: z.ZodString;
+    hairShape: z.ZodEnum<{
+        halo: "halo";
+        short: "short";
+        long: "long";
+        bun: "bun";
+        braids: "braids";
+        shaved: "shaved";
+        bald: "bald";
+    }>;
+    hat: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        cap: "cap";
+        beanie: "beanie";
+        kerchief: "kerchief";
+        straw: "straw";
+        newsboy: "newsboy";
+        hood: "hood";
+    }>>>>;
+    dress: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        scarf: "scarf";
+        apron: "apron";
+        collar: "collar";
+        turtleneck: "turtleneck";
+    }>>>>;
+    accessory: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        glasses: "glasses";
+        sunglasses: "sunglasses";
+        cateye: "cateye";
+        readers: "readers";
+        monocle: "monocle";
+        eyepatch: "eyepatch";
+        earrings: "earrings";
+        "earring-left": "earring-left";
+        "earring-right": "earring-right";
+        flower: "flower";
+        hairclip: "hairclip";
+        headband: "headband";
+        bowtie: "bowtie";
+        necklace: "necklace";
+        brooch: "brooch";
+        facemask: "facemask";
+        goggles: "goggles";
+        "safety-glasses": "safety-glasses";
+        "pince-nez": "pince-nez";
+        headphones: "headphones";
+        "hearing-aid": "hearing-aid";
+        "nose-ring": "nose-ring";
+        "hoop-earrings": "hoop-earrings";
+        "drop-earrings": "drop-earrings";
+        "pearl-earrings": "pearl-earrings";
+        bandage: "bandage";
+        feather: "feather";
+        pencil: "pencil";
+        ribbon: "ribbon";
+        necktie: "necktie";
+        cravat: "cravat";
+        "bolo-tie": "bolo-tie";
+        lanyard: "lanyard";
+        medal: "medal";
+        "pocket-square": "pocket-square";
+        "tool-pendant": "tool-pendant";
+    }>>>>;
+    facialHair: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        beard: "beard";
+        mustache: "mustache";
+    }>>>>;
+    mark: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        freckles: "freckles";
+        mole: "mole";
+    }>>>>;
+    expression: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        smile: "smile";
+        wider: "wider";
+        neutral: "neutral";
+        wink: "wink";
+        sleepy: "sleepy";
+    }>>>;
+    shirt: z.ZodString;
+    shirtAccent: z.ZodString;
+    shirtPattern: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        plain: "plain";
+        buttons: "buttons";
+        stripes: "stripes";
+        sash: "sash";
+        yoke: "yoke";
+        twotone: "twotone";
+    }>>>;
+}, z.core.$strip>>;
+type Poppetje = z.infer<typeof PoppetjeSchema>;
+
+/** Catalog options the generator may roll — growth cosmetics filtered out. */
+declare const ROLLABLE_HATS: ("cap" | "beanie" | "kerchief" | "straw" | "newsboy" | "hood")[];
+declare const ROLLABLE_DRESSES: ("scarf" | "apron" | "collar" | "turtleneck")[];
+declare const ROLLABLE_ACCESSORIES: ("glasses" | "sunglasses" | "cateye" | "readers" | "monocle" | "eyepatch" | "earrings" | "earring-left" | "earring-right" | "flower" | "hairclip" | "headband" | "bowtie" | "necklace" | "brooch" | "facemask" | "goggles" | "safety-glasses" | "pince-nez" | "headphones" | "hearing-aid" | "nose-ring" | "hoop-earrings" | "drop-earrings" | "pearl-earrings" | "bandage" | "feather" | "pencil" | "ribbon" | "necktie" | "cravat" | "bolo-tie" | "lanyard" | "medal" | "pocket-square" | "tool-pendant")[];
+/**
+ * djb2 hash → [0, 100). Used as the SVG turbulence `seed` attribute so
+ * every gezel with the same `key` gets the same wood-grain pattern,
+ * forever, across every render and every viewBox crop.
+ */
+declare function seedFromKey(key: string): number;
+interface PoppetjeSeedOptions {
+    /** When provided, becomes the resulting `Poppetje.key` (stable wood-grain seed). */
+    key?: string;
+    /** When provided, becomes the resulting `Poppetje.name`. */
+    name?: string;
+    /**
+     * When `'female'`, the generator omits `beard` and `mustache` from the
+     * accessory pool. Other genders (`'male'`, `'non-binary'`, `undefined`)
+     * keep the full pool. The brief is explicit that body shape, skin,
+     * hair, hat, dress, and expression are **never** tied to gender —
+     * only facial hair gets this anatomical gate.
+     */
+    gender?: GezelGender;
+}
+/**
+ * Produce a deterministic, complete `Poppetje` from a single integer seed.
+ *
+ * Same `n` always returns the same struct. Slot odds (hat 30%, dress 22%,
+ * accessory 50%, mark 20%) are applied via independent rolls so each slot
+ * is empty-or-filled independent of the others.
+ *
+ * `options.key` and `options.name` let you decouple the wood-grain seed
+ * (the `key` field — locked to the gezel id) from the catalog seed `n`
+ * (the random integer that picks slots). Without an explicit key, the
+ * generator falls back to `seed-${n}`.
+ */
+declare function poppetjeFromSeed(n: number, options?: PoppetjeSeedOptions): Poppetje;
+/**
+ * First-time poppetje for a gezel — deterministic from the gezel id alone.
+ *
+ * Hashes the gezel id to a catalog seed `n`, then runs `poppetjeFromSeed`
+ * with `key` pinned to the id. Reproducible across tests, restarts, and
+ * migrations. After this initial state, the user can reroll to draw a
+ * fresh `n` — but the `key` (and so the wood-grain pattern) stays pinned.
+ */
+declare function initialPoppetjeForGezel(gezelId: string, name: string, gender?: GezelGender): Poppetje;
+
+/**
+ * Project-type taxonomy — a broad, deliberately expandable catalog of the
+ * *kinds of thing a project produces* (a browser game, a data analysis, a
+ * REST service, …). It exists so the craftbook rail can suggest a small,
+ * relevant subset of the ~200-book catalog instead of dumping all of them on
+ * an obvious HTML-game project.
+ *
+ * Two halves to each entry:
+ *   - `detect`  — cheap, deterministic signals scored against a project's
+ *                 indexed file mix (extensions, modalities) and its
+ *                 `about.md`/mission text (keywords). Drives auto-detection.
+ *   - `craftbookTags` — the curated craftbook tags that make a book
+ *                 "suggested" for this type. Relevance = tag intersection
+ *                 with `CraftbookTemplateManifest.tags`. Keep these aligned
+ *                 to tags that actually exist in the catalog (the near-
+ *                 universal `gallery` tag is intentionally never used here —
+ *                 it would match every book).
+ *   - `gezelRoles` — gezel-template affinity in two tiers. `default` is the
+ *                 core crew this kind of project normally starts with;
+ *                 `suggested` is the useful specialist bench beyond that.
+ *                 Detection only surfaces these choices and never creates a
+ *                 gezel as a side effect.
+ *
+ * This is shared core data: the service imports it for detection + craftbook
+ * partitioning, and the UI imports it for the settings override dropdown, so
+ * there is no list endpoint to keep in sync.
+ */
+declare const ProjectTypeDetectSchema: z.ZodObject<{
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modalities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ProjectTypeDetect = z.infer<typeof ProjectTypeDetectSchema>;
+declare const ProjectTypeGezelRoleSchema: z.ZodObject<{
+    templateId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+type ProjectTypeGezelRole = z.infer<typeof ProjectTypeGezelRoleSchema>;
+declare const ProjectTypeGezelAffinitySchema: z.ZodObject<{
+    default: z.ZodArray<z.ZodObject<{
+        templateId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    suggested: z.ZodArray<z.ZodObject<{
+        templateId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ProjectTypeGezelAffinity = z.infer<typeof ProjectTypeGezelAffinitySchema>;
+declare const ProjectTypeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodString;
+    detect: z.ZodObject<{
+        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        modalities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    craftbookTags: z.ZodArray<z.ZodString>;
+    gezelRoles: z.ZodObject<{
+        default: z.ZodArray<z.ZodObject<{
+            templateId: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+        suggested: z.ZodArray<z.ZodObject<{
+            templateId: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type ProjectType = z.infer<typeof ProjectTypeSchema>;
+/**
+ * The bundled seed taxonomy. Grows over time; the detector and partitioner
+ * treat it purely as data, so adding an entry needs no code change.
+ */
+declare const PROJECT_TYPES: ProjectType[];
+/** Look up a project type by id. */
+declare function getProjectType(id: string | undefined | null): ProjectType | undefined;
+/** The full taxonomy, for UI listing (override dropdown). */
+declare function listProjectTypes(): ProjectType[];
+
+/**
+ * ─ Roles as capability contracts ─────────────────────────────────────
+ *
+ * A role is not a persona — it is a declared bundle of what the system
+ * does with it. Historically those facets were scattered: the toolset kit
+ * lived in `chat/role-tool-filter`, the tuning profile in each gilde
+ * template manifest, the about text in the catalog, and the "gate
+ * vocabulary" only existed implicitly. This module makes the bundle
+ * explicit and is the single source of truth for:
+ *
+ *   - `toolsetGroups`          — the MCP kit (was ROLE_TOOLSET_GROUPS)
+ *   - `suggestedTuningProfile` — sampling preset (was template-only)
+ *   - `gateAffinity`           — NEW: the checks a role's deliverables
+ *                                default to (a Researcher cites + grounds
+ *                                the way a Developer parses + tests)
+ *   - `defaultBooks`           — NEW: craftbook templates the role runs well
+ *   - `capabilityFloor`        — NEW: min model tier for unsupervised steps
+ *
+ * The about template stays in the catalog (it's prose, versioned with the
+ * gallery); everything mechanical lives here. `chat/role-tool-filter` and
+ * the tuning resolver read from this registry rather than re-declaring.
+ *
+ * IMPORTANT — behavior parity: the canonical role ids below are exactly
+ * the 10 toolset-kit keys that `role-tool-filter` shipped, and
+ * {@link resolveRoleId} reproduces the old `canonicalRoleKey` exactly
+ * (exact-match a canonical id, else substring-match the alias table, else
+ * null → DEFAULT_TOOLSET_GROUPS). Adding a brand-new canonical id would
+ * change tool filtering AND the delegation/implementer classification that
+ * keys off the canonical string, so keep this set stable; template-only
+ * roles (builder → developer, boekwachter → default) continue to resolve
+ * via the alias/fallback paths.
+ */
+type RoleId = 'meester' | 'voorman' | 'reviewer' | 'researcher' | 'copywriter' | 'designer' | 'image-generator' | 'video-generator' | 'developer' | 'web-developer' | 'planner';
+interface RoleDefinition {
+    /** Canonical role id — also the toolset-kit key. */
+    id: RoleId;
+    /** Human label. */
+    label: string;
+    /** One-line capability summary. */
+    summary: string;
+    /**
+     * MCP toolset groups (ids into BUILTIN_TOOLSETS) the role's gezels get
+     * by default. Group lists are conservative: a missing-but-needed group
+     * is worse than a couple extras; user toolsets add/remove from here.
+     */
+    toolsetGroups: readonly string[];
+    /**
+     * Soft tuning-profile default (a `KNOWN_PROFILE_IDS` value). The
+     * per-gezel pick and install default always win; this is the role's
+     * sensible baseline. Omitted where the role has no opinion.
+     */
+    suggestedTuningProfile?: string;
+    /**
+     * The gate vocabulary this role is expected to clear — standard-scope
+     * check scripts that fit the role's typical deliverable. Inputs are
+     * usually omitted here (bound to the concrete deliverable at the point
+     * of use); this is the menu, not a turnkey gate. Empty for coordinators
+     * (no deliverable) and for developer-family roles whose gates are
+     * task-specific build/test checks supplied by the craftbook.
+     */
+    gateAffinity: readonly GateScriptRef[];
+    /** Craftbook template ids (catalog folder names) this role runs well. */
+    defaultBooks: readonly string[];
+    /** Minimum model tier to run this role's steps unsupervised. */
+    capabilityFloor: ModelTier;
+}
+declare const ROLES: Record<RoleId, RoleDefinition>;
+/**
+ * Fallback group set when a gezel's role matches no canonical id and no
+ * alias. Mirrors a competent builder kit; `code-execution` is deliberately
+ * excluded (a more specific grant roles opt into). Was `DEFAULT_GROUPS` in
+ * role-tool-filter.
+ */
+declare const DEFAULT_TOOLSET_GROUPS: readonly string[];
+/**
+ * Coarse role-name aliases mapping the variations users/LLMs produce onto
+ * canonical role ids. ORDER MATTERS — checked top-to-bottom, first match
+ * wins (web-flavored dev titles must precede the generic `developer`
+ * matcher; image-generator must follow `design`). Consulted via substring
+ * on the normalized role string only when the exact-id lookup misses.
+ */
+declare const ROLE_ALIASES: ReadonlyArray<{
+    contains: string;
+    canonical: RoleId;
+}>;
+/**
+ * Resolve a free-form role/job-title to a canonical role id. Reproduces
+ * the old `canonicalRoleKey` exactly:
+ *   1. exact case-insensitive match against a canonical id, else
+ *   2. first substring match in {@link ROLE_ALIASES}, else
+ *   3. null (caller falls back to {@link DEFAULT_TOOLSET_GROUPS}).
+ */
+declare function resolveRoleId(role: string | undefined): RoleId | null;
+/** The full role definition for a free-form role, or null if unrecognized. */
+declare function roleDefinition(role: string | undefined): RoleDefinition | null;
+/**
+ * Toolset groups a role gets by default — resolves the role and falls back
+ * to {@link DEFAULT_TOOLSET_GROUPS}. This is the single implementation
+ * behind `role-tool-filter`'s `roleToolsetGroups`.
+ */
+declare function toolsetGroupsForRole(role: string | undefined): readonly string[];
+/** Suggested tuning profile id for a role, or undefined. */
+declare function roleSuggestedTuningProfile(role: string | undefined): string | undefined;
+/** The gate vocabulary a role's deliverables default to ([] if unknown). */
+declare function roleGateAffinity(role: string | undefined): readonly GateScriptRef[];
+/**
+ * A role's gateAffinity bound to a concrete deliverable `filePath` — each
+ * affinity script gets `{ file: filePath }` merged into its inputs (an
+ * explicit input on the ref still wins). This is the menu; the caller is
+ * responsible for dropping any entry whose remaining required inputs can't
+ * be satisfied (e.g. `checkValueGrounding` needs task-specific `facts`),
+ * since this module can't see the script metas.
+ */
+declare function roleDeliverableScripts(role: string | undefined, filePath: string): GateScriptRef[];
+/** Craftbook templates a role runs well ([] if unknown). */
+declare function roleDefaultBooks(role: string | undefined): readonly string[];
+/** Minimum model tier for a role's unsupervised steps, or null if unknown. */
+declare function roleCapabilityFloor(role: string | undefined): ModelTier | null;
+/**
+ * Whether a model of `tier` clears a role's capability floor. Unknown
+ * roles return true (don't block on a role we can't classify).
+ */
+declare function meetsCapabilityFloor(tier: ModelTier, role: string | undefined): boolean;
+
+/**
+ * ─ Deliverable gates ─────────────────────────────────────────────────
+ *
+ * Given the CLASS of artifact a step produces, build the right gate: a cheap
+ * declarative floor (`checks`) plus standard-library gate scripts that judge
+ * a completion attempt and loop the step back on a miss. This is the wisdom
+ * behind the gallery's per-phase gates (`archetypeToCraftbook`) AND the
+ * `set_step_deliverable` MCP tool / the plan craftbook — kept here in core
+ * (where the gate schema lives) so every consumer can share one source of
+ * truth without depending on the catalog package.
+ */
+/**
+ * The CLASS of artifact a step produces. Maps to class-appropriate static
+ * gate checks — authored to "what makes ANY deliverable of this class good",
+ * never to a specific eval's sniff signals. The enum itself lives in the
+ * schemas layer ({@link DeliverableKindSchema}) so the blueprint field and
+ * the MCP tools share it without an import cycle.
+ */
+type DeliverableKind = z.infer<typeof DeliverableKindSchema>;
+/**
+ * Infer the deliverable class from a file path when the author didn't say.
+ * Deliberately coarse — a `.html` is a page (never a game: that stricter
+ * bar must be asked for), code is a module unless the filename says tests.
+ */
+declare function inferDeliverableKind(path: string): DeliverableKind;
+/** Prose document extensions — Markdown-family reports, notes, plain text. */
+declare function isProseDocPath(path: string): boolean;
+/**
+ * Forgiving alias map for model-supplied kind strings — small models write
+ * "html", "md", "csv", "code" and should not eat a validation loop for it.
+ * Case- and separator-insensitive. Returns null when nothing plausible
+ * matches (the caller reports the legal values).
+ */
+declare function coerceDeliverableKind(raw: string): DeliverableKind | null;
+/**
+ * The completion gate for a step that produces a checkable artifact.
+ * `onReject: <the step itself>` re-activates the step with a fresh
+ * handoff session on every rejection — byte-for-byte the loop dynamics
+ * that carried small models through the old evaluator-step shape, with
+ * the judgment now made at completion time on the working step.
+ */
+declare function completionGate(produces: {
+    path: string;
+    kind: DeliverableKind;
+    minBytes?: number;
+    extraChecks?: GateCheck[];
+}, selfId: string, maxAttempts: number): StepGate;
+/** The structural sniff used by a step's `advanceWhen` to leave the step once its artifact lands. */
+declare function advanceSniffForKind(kind: DeliverableKind): AdvanceWhen['sniff'];
+/**
+ * Build the `{ advanceWhen, gate }` pair for a step that produces a single
+ * checkable file deliverable — byte-for-byte the shape `archetypeToCraftbook`
+ * puts on a gated build phase, exposed so callers outside the generator (the
+ * plan craftbook and the `set_step_deliverable` MCP tool) can attach a
+ * "concrete static outcome + enforced gate" to any step without hand-writing
+ * gate JSON.
+ *
+ * `advanceWhen` auto-advances the step the moment the artifact lands; the
+ * completion `gate` (cheap declarative floor + standard-library gate scripts)
+ * judges every completion attempt and re-activates the step (`onReject:
+ * selfId`) on a miss.
+ */
+declare function deliverableStep(opts: {
+    selfId: string;
+    path: string;
+    kind: DeliverableKind;
+    minBytes?: number;
+    extraChecks?: GateCheck[];
+    maxAttempts?: number;
+    /** Gate the artifacts drawer instead of the workspace. Artifact gates
+     * keep only the checks that can read the drawer (`artifact`-capable
+     * kinds) and drop workspace-reading gate scripts. */
+    artifact?: boolean;
+    /** The deliverable is an EDIT — hold the step until the file is written to this turn. */
+    requireChange?: boolean;
+    /**
+     * Code deliverables ONLY: additionally execute in the sandbox and
+     * require exit 0 (`nodeRuns`). Data deliverables ignore it — executing
+     * `node out/customers.json` is meaningless; their execution story is
+     * "produce the file BY running a script" (the `derive_file` tool), and
+     * their gate verifies the OUTPUT's shape via `columns`/`minRows` plus
+     * the data-table sniff floor.
+     */
+    execute?: boolean;
+    /** Data deliverables: required column/field names (csvShape for CSV, recordSchema for JSON). */
+    columns?: string[];
+    /** Data deliverables: minimum row count. */
+    minRows?: number;
+    /**
+     * The step is terminal — return the completion gate ONLY (legal and
+     * meaningful on a terminal step: its reject blocks task completion)
+     * and no `advanceWhen` (illegal there: nowhere to auto-advance to).
+     * Models put deliverables on their final "verify" step constantly —
+     * the eval A/B's #1 rejection was exactly this shape — so the sugar
+     * expands to what a terminal step CAN carry instead of bouncing.
+     */
+    terminal?: boolean;
+}): {
+    advanceWhen?: AdvanceWhen;
+    gate: StepGate;
+};
+/**
+ * Expand a blueprint's `deliverable` sugar into the class-appropriate
+ * `advanceWhen` + completion `gate` on the resolved step. An explicitly-
+ * authored `gate` / `advanceWhen` on the step WINS over the corresponding
+ * expanded field — the sugar fills gaps, it never overrides intent.
+ * `step.id` must be the FINAL minted id (post de-dup): the expanded gate
+ * loops back with `onReject: step.id`.
+ */
+declare function expandStepDeliverable(step: CraftbookStep, d: StepDeliverable): CraftbookStep;
+/**
+ * Resolve step blueprints (mint/de-dupe ids) and expand each `deliverable`
+ * against the FINAL ids. The one entry point every create path uses —
+ * routes, TaskManager inline steps, and the document-write pipeline — so
+ * a single `create_task` / `craftbook_write` call yields fully-gated steps.
+ */
+declare function expandStepDeliverables(blueprints: NewCraftbookStep[]): CraftbookStep[];
+/** The workspace path a step's deliverable machinery targets, or null. */
+declare function stepDeliverablePath(step: Pick<CraftbookStep, 'advanceWhen' | 'gate'>): string | null;
+/**
+ * Re-derive the deliverable CLASS from a persisted step. Null when the
+ * step targets no file at all (pure-routing / user steps) — callers
+ * treat that as "no kit".
+ */
+declare function deliverableKindForStep(step: Pick<CraftbookStep, 'advanceWhen' | 'gate'>): DeliverableKind | null;
+/**
+ * The one-line "first action" a small-model step prompt names for a
+ * deliverable class (tier-collapse prompts + the tiny-tier task
+ * anchor). The named tool is always present in the service-side step
+ * kit for the same kind — packages/service/src/chat/step-tool-kit.ts
+ * keeps the two in lockstep.
+ */
+declare function firstActionForKind(kind: DeliverableKind, path: string): string;
+
+/**
+ * What counts as a binary office/media deliverable, and how to tell whether
+ * a file actually IS one.
+ *
+ * This lived in three places that had already drifted apart: the MCP's
+ * document-routing extension set, the eval harness's handoff regex, and —
+ * by omission — core's deliverable gates, which knew nothing about it and
+ * therefore gated `.docx` and `.pptx` outputs with *text* checks. That
+ * omission is the bug this module exists to close:
+ *
+ *   - A `markdown-report` deliverable at `report.docx` was gated by
+ *     "contains a Markdown heading". A real DOCX is a ZIP, so the check
+ *     REJECTED correct output and ACCEPTED the Markdown source renamed to
+ *     `.docx` — inverted, not merely weak.
+ *   - A `slide-deck` at `deck.pptx` was gated by "contains slide|section|
+ *     ---". A real PPTX passes only incidentally (ZIP stores the
+ *     `ppt/slides/slide1.xml` entry name uncompressed), while a Markdown
+ *     deck passes outright.
+ *
+ * Binary deliverables are produced through DocBlocks (`convert_document` →
+ * `preview_document` → `save_artifact`), so the honest floor is "is this
+ * the container the extension claims", not "does the text look right".
+ */
+/** Container format a binary deliverable's bytes must actually be. */
+type BinaryDocumentContainer = 'zip' | 'pdf' | 'gif' | 'mp4';
+/** Every extension the product treats as a binary document deliverable. */
+declare const BINARY_DOCUMENT_EXTENSIONS: readonly string[];
+declare function binaryDocumentExtension(path: string | null | undefined): string | null;
+declare function isBinaryDocumentPath(path: string | null | undefined): boolean;
+declare function binaryDocumentContainer(path: string | null | undefined): BinaryDocumentContainer | null;
+interface BinaryDocumentVerdict {
+    ok: boolean;
+    /** Human-readable reason, suitable for a gate rejection message. */
+    detail: string;
+}
+/**
+ * Verify that `bytes` really are the container `path`'s extension claims.
+ *
+ * Deliberately a SIGNATURE check, not a parse: the point is to reject the
+ * substitutions models actually make — Markdown, prose, base64 text, or
+ * hand-built XML written straight to a `.pptx` path — without pulling a
+ * ZIP/PDF parser into core. Anything that clears this floor came out of a
+ * real converter.
+ */
+declare function verifyBinaryDocumentBytes(path: string, bytes: Uint8Array | null | undefined): BinaryDocumentVerdict;
+
+/**
+ * ─ Model scorecard ───────────────────────────────────────────────────
+ *
+ * The durable, shippable record of "how did each model do on the standard
+ * suites, on a real device". Written by `pnpm eval:scorecard`, read by the
+ * handboek `::handboek-model-scorecard` macro, and checked in so the
+ * shipped articles carry real measurements rather than claims.
+ *
+ * ## The one rule that makes this scientific
+ *
+ * **A comparison is only valid inside a single sweep.** Two models are
+ * comparable when they ran the same scenario set, on the same device,
+ * against the same harness commit and the same catalog pin. Change any of
+ * those and the numbers describe different experiments that happen to
+ * share a scale.
+ *
+ * That collides with the practical need to add a model later without
+ * re-running everything, so the format keeps BOTH: a `runs[]` list where
+ * each run is one internally-comparable sweep, and per-model results that
+ * name the run they came from. Rendering then has an honest job — present
+ * one run as the headline table, and mark anything measured elsewhere as
+ * what it is. Nothing merges silently.
+ *
+ * ## What counts against a model
+ *
+ * Only `failureClass: 'model'` trials. A capacity denial, a wedged engine,
+ * an operator interrupt, or a grader bug is not a capability signal, and
+ * folding those into a pass rate is the fastest way to publish a wrong
+ * number. Each cell therefore records the failure-class split, and the
+ * headline rate is computed over *attributable* trials.
+ *
+ * ## What we deliberately do not publish as comparable
+ *
+ * LLM-judge axis scores. They come from a frontier model that changes
+ * under us, so they are recorded WITH the judge model id and are only ever
+ * compared inside one run. The deterministic pass/fail is the longitudinal
+ * signal; the judge is colour.
+ */
+/** Schema version — bump only on a breaking shape change. */
+declare const SCORECARD_SCHEMA_VERSION = 1;
+/**
+ * Below this many trials a pass fraction is rendered as a raw count, never
+ * a percentage. Mirrors the eval harness's `MIN_TRIALS_FOR_RATE`: at n=1 a
+ * medium local model is close to a coin flip, and "100%" from one trial is
+ * a claim the sample cannot support.
+ */
+declare const MIN_TRIALS_FOR_RATE = 3;
+declare const ScorecardDeviceSchema: z.ZodObject<{
+    label: z.ZodString;
+    platform: z.ZodString;
+    arch: z.ZodString;
+    memoryGb: z.ZodOptional<z.ZodNumber>;
+    osRelease: z.ZodOptional<z.ZodString>;
+    cpuModel: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ScorecardDevice = z.infer<typeof ScorecardDeviceSchema>;
+/**
+ * Everything that has to match for two models to be comparable. Two runs
+ * with identical provenance may be merged; anything else may not.
+ */
+declare const ScorecardProvenanceSchema: z.ZodObject<{
+    startedAt: z.ZodString;
+    device: z.ZodObject<{
+        label: z.ZodString;
+        platform: z.ZodString;
+        arch: z.ZodString;
+        memoryGb: z.ZodOptional<z.ZodNumber>;
+        osRelease: z.ZodOptional<z.ZodString>;
+        cpuModel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    harnessCommit: z.ZodString;
+    gildeVersion: z.ZodString;
+    count: z.ZodNumber;
+    judgeModelId: z.ZodNullable<z.ZodString>;
+    engineBuilds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+type ScorecardProvenance = z.infer<typeof ScorecardProvenanceSchema>;
+declare const ScorecardRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    provenance: z.ZodObject<{
+        startedAt: z.ZodString;
+        device: z.ZodObject<{
+            label: z.ZodString;
+            platform: z.ZodString;
+            arch: z.ZodString;
+            memoryGb: z.ZodOptional<z.ZodNumber>;
+            osRelease: z.ZodOptional<z.ZodString>;
+            cpuModel: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        harnessCommit: z.ZodString;
+        gildeVersion: z.ZodString;
+        count: z.ZodNumber;
+        judgeModelId: z.ZodNullable<z.ZodString>;
+        engineBuilds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>;
+    suites: z.ZodArray<z.ZodString>;
+    scenariosBySuite: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ScorecardRun = z.infer<typeof ScorecardRunSchema>;
+/** One model × one scenario cell. */
+declare const ScorecardCellSchema: z.ZodObject<{
+    scenarioId: z.ZodString;
+    trials: z.ZodNumber;
+    successes: z.ZodNumber;
+    nonModelFailures: z.ZodNumber;
+    medianDurationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type ScorecardCell = z.infer<typeof ScorecardCellSchema>;
+declare const ScorecardModelResultSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    label: z.ZodString;
+    engine: z.ZodString;
+    tier: z.ZodString;
+    parameterSize: z.ZodOptional<z.ZodString>;
+    quantization: z.ZodOptional<z.ZodString>;
+    grantedContextTokens: z.ZodOptional<z.ZodNumber>;
+    runId: z.ZodString;
+    suiteId: z.ZodString;
+    cells: z.ZodArray<z.ZodObject<{
+        scenarioId: z.ZodString;
+        trials: z.ZodNumber;
+        successes: z.ZodNumber;
+        nonModelFailures: z.ZodNumber;
+        medianDurationMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type ScorecardModelResult = z.infer<typeof ScorecardModelResultSchema>;
+declare const ScorecardDatasetSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    runs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        provenance: z.ZodObject<{
+            startedAt: z.ZodString;
+            device: z.ZodObject<{
+                label: z.ZodString;
+                platform: z.ZodString;
+                arch: z.ZodString;
+                memoryGb: z.ZodOptional<z.ZodNumber>;
+                osRelease: z.ZodOptional<z.ZodString>;
+                cpuModel: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            harnessCommit: z.ZodString;
+            gildeVersion: z.ZodString;
+            count: z.ZodNumber;
+            judgeModelId: z.ZodNullable<z.ZodString>;
+            engineBuilds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>;
+        suites: z.ZodArray<z.ZodString>;
+        scenariosBySuite: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    results: z.ZodArray<z.ZodObject<{
+        modelId: z.ZodString;
+        label: z.ZodString;
+        engine: z.ZodString;
+        tier: z.ZodString;
+        parameterSize: z.ZodOptional<z.ZodString>;
+        quantization: z.ZodOptional<z.ZodString>;
+        grantedContextTokens: z.ZodOptional<z.ZodNumber>;
+        runId: z.ZodString;
+        suiteId: z.ZodString;
+        cells: z.ZodArray<z.ZodObject<{
+            scenarioId: z.ZodString;
+            trials: z.ZodNumber;
+            successes: z.ZodNumber;
+            nonModelFailures: z.ZodNumber;
+            medianDurationMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type ScorecardDataset = z.infer<typeof ScorecardDatasetSchema>;
+
+/**
+ * Turning a recorded sweep into the numbers an article may print.
+ *
+ * Every rule here exists to stop a true-looking number that the data does
+ * not support. They are enforced in one place so the handboek macro, the
+ * CLI report, and any future surface cannot disagree about what a score
+ * means.
+ */
+interface ModelScore {
+    result: ScorecardModelResult;
+    /** Scenarios where the model was actually on trial. */
+    attributableTrials: number;
+    successes: number;
+    /** Trials thrown out as infra/operator/grader failures. */
+    discardedTrials: number;
+    /** null when the sample is too small to quote as a rate. */
+    passRate: number | null;
+    /** Rendered claim, always safe to print verbatim. */
+    claim: string;
+    /** Scenarios with zero attributable trials — measured nothing. */
+    unmeasuredScenarios: string[];
+    /** Fewest trials any measured scenario received; gates rate-quoting. */
+    weakestCellTrials: number;
+    /** Scenarios that ran fewer than MIN_TRIALS_FOR_RATE times. */
+    underRepeatedScenarios: string[];
+}
+/**
+ * Attributable trials only: a cell's non-model failures are removed from
+ * BOTH numerator and denominator. A wedged engine is not evidence about a
+ * model, and letting it depress a pass rate publishes a claim about the
+ * wrong thing.
+ */
+declare function cellAttributableTrials(cell: ScorecardCell): number;
+/** Render a pass fraction, refusing to quote a rate the sample can't support. */
+declare function formatPassClaim(successes: number, trials: number): string;
+/**
+ * Score one model.
+ *
+ * Rate-quoting is gated on the WEAKEST cell, not on the run's requested
+ * count. Three different tasks run once each is three samples of one, and
+ * says nothing about whether any result reproduces.
+ *
+ * The requested count is not sufficient evidence that repeats happened:
+ * the matrix caps per-scenario trials at `suggestedTrials`, so a
+ * `--count 3` sweep silently runs ONE trial for every craftbook scenario.
+ * On the first real sweep that was six of thirteen productivity tasks —
+ * and reading the requested count would have published a confident
+ * percentage over a suite that was nearly half unrepeated. The recorded
+ * per-cell `trials` is the only honest source.
+ *
+ * `trialsPerScenario` remains an upper bound the caller may impose (the
+ * run's count); the effective gate is the minimum of it and every cell.
+ */
+declare function scoreModel(result: ScorecardModelResult, trialsPerScenario?: number): ModelScore;
+/**
+ * The run whose numbers a suite's headline table should show: the newest
+ * run that covered that suite. `runs` is newest-first by contract, but sort
+ * defensively — a hand-edited dataset should not silently reorder history.
+ */
+declare function headlineRunForSuite(dataset: ScorecardDataset, suiteId: string): ScorecardRun | null;
+interface SuiteScoreboard {
+    suiteId: string;
+    run: ScorecardRun;
+    /** Models measured in the headline run, best first. */
+    scores: ModelScore[];
+    /**
+     * Models present in the dataset for this suite but measured under
+     * DIFFERENT provenance. Never merged into `scores` — rendered separately
+     * so a reader can see they are not directly comparable.
+     */
+    otherRunScores: Array<ModelScore & {
+        run: ScorecardRun;
+    }>;
+    /** Scenario ids as run, for the "what was measured" list. */
+    scenarioIds: string[];
+}
+/**
+ * Build one suite's scoreboard.
+ *
+ * Sorting is by successes-per-attributable-trial with the raw success
+ * count as the tiebreak, so a model that ran fewer attributable trials
+ * cannot outrank one that ran the full set on the same ratio.
+ */
+declare function buildSuiteScoreboard(dataset: ScorecardDataset, suiteId: string): SuiteScoreboard | null;
+/**
+ * One-line provenance stamp. Every published table needs this next to it —
+ * a score without its device, date, and code version is not a measurement,
+ * it is a rumour.
+ */
+declare function describeProvenance(run: ScorecardRun, engines?: readonly string[]): string;
+/**
+ * Whether two runs measured the same thing. Used to explain, in the
+ * article, exactly why an off-run result is footnoted rather than merged.
+ */
+declare function provenanceDifferences(a: ScorecardRun, b: ScorecardRun): string[];
+
+/**
+ * The checked-in scorecard, parsed once.
+ *
+ * Deliberately NOT lazy and NOT forgiving: a malformed dataset is a build
+ * error, not a runtime surprise. The handboek renders these numbers to
+ * users, so a shape that no longer matches the schema must fail where an
+ * engineer sees it rather than quietly render an empty table.
+ */
+declare const SCORECARD: ScorecardDataset;
+/** True when no sweep has been recorded yet — articles degrade gracefully. */
+declare function scorecardIsEmpty(dataset?: ScorecardDataset): boolean;
+
+/**
+ * First-party local toolsets whose runtime enforces its own narrow authority.
+ *
+ * Keep this predicate in core so every launch surface (service routes, chat
+ * orchestration, and future clients) applies the same exact provenance check.
+ * A matching id alone is never enough: the bundled source, package, supported
+ * published entrypoint, argv, and pinned archive hash all have to match.
+ */
+declare function isTrustedConstrainedToolset(args: {
+    toolsetId: string;
+    sourceId: string;
+    runtime: ToolsetRuntime;
+}): boolean;
+
+/**
+ * Tier-collapse rendering (D3): render a task's embedded craftbook for
+ * a SMALL executor — merge to a ≤3-step linear chain, one artifact per
+ * group, gates verbatim (a merged group carries every merged step's
+ * completion checks + scripts), step prompts rewritten to single-action
+ * imperatives. "One task model, tier-rendered": structure density is a
+ * dial priced per executor tier, never a fork of the task model.
+ *
+ * Deliberately CONSERVATIVE in v1 — the pass collapses only books it
+ * can prove it understands, and fails OPEN (`changed: false`, book
+ * untouched) on anything else:
+ *
+ * - linear chains only: `next` edges must follow array order (or be
+ *   omitted), entry must be the first step, no `branches`, no
+ *   `advanceWhen.goto`, no gate routes other than `onReject: <self>`;
+ * - no activation-gated steps (merging would silently drop a guard);
+ * - the caller enforces single-assignee + tier gating and persists the
+ *   result (see TaskManager.collapseCraftbookForTier).
+ *
+ * The pass is generic over the step type so a task's lifecycle fields
+ * (createdAt, gateAttempts, gateAttemptHistory, …) ride through on the
+ * surviving anchor steps — group id = anchor id, which keeps step
+ * notes, telemetry, and gate bookkeeping keyed to a live id.
+ */
+
+interface CollapseCraftbookResult<S extends CraftbookStep> {
+    steps: S[];
+    entryStepId: string;
+    /** Original step id → surviving group id (identity for anchors). */
+    stepIdMap: Map<string, string>;
+    changed: boolean;
+    /** Why the pass declined, when it did (for the caller's log line). */
+    skippedReason?: string;
+}
+/**
+ * Collapse `book` for a small executor tier. Returns the input
+ * unchanged (`changed: false`) unless `tier === 'tiny'`, the book is
+ * longer than `maxSteps`, and every structural precondition holds.
+ */
+declare function collapseCraftbookForTier<S extends CraftbookStep>(book: {
+    steps: S[];
+    entryStepId: string;
+}, opts: {
+    tier: ModelTier;
+    maxSteps?: number;
+}): CollapseCraftbookResult<S>;
+
+/**
+ * ─ Craftbook document codecs ─────────────────────────────────────────
+ *
+ * Format-agnostic parse/serialize for the single-document craftbook
+ * authoring format, plus the doc ↔ runtime-Craftbook conversion. Both
+ * encodings (JSON / markdown) funnel through ONE schema validation and
+ * ONE repair-grade error pipeline, so `craftbook_write` behaves
+ * identically in the format A/B eval's two arms.
+ */
+type ParseCraftbookDocResult = {
+    ok: true;
+    doc: CraftbookDoc;
+} | {
+    ok: false;
+    errors: CraftbookDocError[];
+};
+declare function parseCraftbookDoc(text: string, format?: CraftbookDocFormat): ParseCraftbookDocResult;
+declare function serializeCraftbookDoc(doc: CraftbookDoc, format: CraftbookDocFormat): string;
+interface CraftbookFromDocOptions {
+    /** Forced id (update-in-place routes). Wins over `doc.id` / the minted slug. */
+    id?: string;
+    /** Timestamp for createdAt/updatedAt. Preserved `createdAt` may be supplied separately. */
+    now: string;
+    createdAt?: string;
+}
+type CraftbookFromDocResult = {
+    ok: true;
+    craftbook: Craftbook;
+} | {
+    ok: false;
+    errors: CraftbookDocError[];
+};
+/**
+ * Turn a schema-valid doc into the runtime `Craftbook`: expand each
+ * step's `deliverable` sugar into its enforced gate, default the entry
+ * step, and run the shared graph + script-ref validators. Errors come
+ * back repair-grade — this result's formatted text is what the model
+ * sees when `craftbook_write` refuses a save.
+ */
+declare function craftbookFromDoc(doc: CraftbookDoc, opts: CraftbookFromDocOptions): CraftbookFromDocResult;
+/**
+ * Down-map a runtime `Craftbook` to the round-trippable doc. Guaranteed
+ * by construction to be accepted back by `craftbookFromDoc` unchanged —
+ * that invariant is what makes `craftbook_read` → edit → `craftbook_write`
+ * a safe loop for a model.
+ */
+declare function docFromCraftbook(book: Craftbook): CraftbookDoc;
+
+interface StrippedSkillBody {
+    generated: boolean;
+    title?: string;
+    body: string;
+    whenToInvoke?: string;
+}
+declare function stripGeneratedPreamble(content: string): StrippedSkillBody;
+
+/**
+ * ─ Skill body segmentation ───────────────────────────────────────────
+ *
+ * Splits an authored skill body into H1 title, intro prose, and its H2
+ * sections, and decides whether the skill is a multi-step procedure.
+ *
+ * Step recognition is deliberately narrow: only `## Phase N`, `## Step
+ * N` (N = `1`, `2A`, `2.5`, `2.75`, optional `: title` / `— title`
+ * suffix, `(MANDATORY)`-style parentheticals staying in the title) and
+ * `## 1. <title>` numbered headings count. Multi-step mode requires at
+ * least TWO sections matching one family — a single "Phase 1" or an
+ * essay-shaped skill falls back to a single-step conversion, because a
+ * wrongly-split book is worse than an unsplit one.
+ */
+type StepFamily = 'phase' | 'step' | 'num';
+interface StepMatch {
+    family: StepFamily;
+    ordinal: string;
+    title: string;
+}
+interface SegmentedSkillBody {
+    /** H1 text when the body opens with one. */
+    title?: string;
+    /** Prose between the H1 (or start) and the first H2. */
+    intro: string;
+    /** Every H2 section, in document order. */
+    sections: MdSection[];
+    /** Indices into `sections` recognized as steps of the winning family. */
+    stepIndices: number[];
+    /** The winning family, or null when single-step mode applies. */
+    family: StepFamily | null;
+}
+declare function matchStepHeading(heading: string): StepMatch | null;
+declare function segmentSkillBody(body: string): SegmentedSkillBody;
+
+/**
+ * ─ SkillDoc — the parsed intermediate form of a SKILL.md ─────────────
+ *
+ * One skill file (Claude `.claude/skills` or gstack format: YAML
+ * frontmatter + markdown body) parsed into a plain struct. Parsing is
+ * pure and deterministic — no fs, no LLM, never throws: malformed
+ * frontmatter degrades to an empty frontmatter with the whole text as
+ * body, because arbitrary third-party skills must always produce *some*
+ * convertible document.
+ */
+type SkillFileKind = 'section' | 'reference' | 'template' | 'script' | 'bin' | 'other';
+/** A companion file discovered next to the SKILL.md (never read by core). */
+interface SkillFileRef {
+    relPath: string;
+    kind: SkillFileKind;
+    bytes: number;
+}
+/** A flattened `hooks:` frontmatter declaration (Claude hook shape). */
+interface SkillHookDecl {
+    phase: 'PreToolUse' | 'PostToolUse';
+    matcher: string;
+    command: string;
+    statusMessage?: string;
+}
+interface SkillDoc {
+    name: string;
+    version?: string;
+    description?: string;
+    /** `triggers` + `voice-triggers`, deduped case-insensitively, document order. */
+    triggers: string[];
+    allowedTools: string[];
+    interactive?: boolean;
+    sensitive?: boolean;
+    hooks: SkillHookDecl[];
+    /** Frontmatter keys we recognize but don't map (gbrain, preamble-tier, …). */
+    extraFrontmatter: Record<string, unknown>;
+    /** True when the AUTO-GENERATED template marker was present. */
+    generated: boolean;
+    /** First fence-aware H1 title of the authored body, when present. */
+    title?: string;
+    /** Authored body: preamble stripped when generated, telemetry fences dropped. */
+    body: string;
+    /** `## When to invoke this skill` harvested from a stripped preamble. */
+    whenToInvoke?: string;
+    /** The full body before any stripping — the provenance-hash basis. */
+    rawBody: string;
+    files: SkillFileRef[];
+}
+interface ParseSkillDocOptions {
+    /** Name to use when frontmatter has none (usually the skill's directory name). */
+    fallbackName: string;
+    files?: SkillFileRef[];
+}
+declare function parseSkillDoc(raw: string, opts: ParseSkillDocOptions): SkillDoc;
+
+interface SkillPersona {
+    role: string;
+    about: string;
+}
+interface ConvertedScript {
+    name: string;
+    body: string;
+    sourceBlock: string;
+    stepId: string;
+    origin: 'static';
+}
+interface UntranslatedBlock {
+    stepId: string;
+    code: string;
+}
+interface SkillConversionOptions {
+    /** Book-id prefix — `'proj-skill-'` for project-local books, `''` for catalog. */
+    idPrefix?: string;
+    /** Catalog lane only; runtime lanes must not stamp times into the doc. */
+    releasedAt?: string;
+    /** Workspace-relative SKILL.md path, for provenance + companion paths. */
+    sourcePath?: string;
+    /** Attempt static shell→TS conversion (default true). */
+    transpileShell?: boolean;
+    /**
+     * Drop the `> Converted from …` provenance/notes block from the
+     * description. The runtime lane keeps it (it cites the user's own repo
+     * path — useful); the catalog lane omits it so shipped books read as
+     * ordinary skills, not conversions.
+     */
+    omitProvenance?: boolean;
+}
+interface SkillConversionResult {
+    doc: CraftbookDoc;
+    scripts: ConvertedScript[];
+    untranslated: UntranslatedBlock[];
+    /** Dropped/unmapped source features, sorted — the honesty ledger. */
+    notes: string[];
+    persona?: SkillPersona;
+}
+declare function skillToCraftbookDoc(skill: SkillDoc, opts?: SkillConversionOptions): SkillConversionResult;
+
+/**
+ * ─ Static shell→gezel-script transpiler ──────────────────────────────
+ *
+ * Deterministically converts a *very small* shell subset into a
+ * sandboxed gezel-sdk script — no LLM anywhere. A block converts only
+ * when EVERY effectful line maps; one unmappable line rejects the whole
+ * block (the caller keeps it as prose). The output follows the exact
+ * skeleton the LLM translator is instructed to produce, so both
+ * producers pass the same `validateScriptBody` gate service-side.
+ *
+ * Supported line forms (everything else → null):
+ *   npm|pnpm|yarn run <script>     → gezel.mcp.call('run_package_script')
+ *   npm|pnpm|yarn test|start|build → same, bare lifecycle script
+ *   cat <relative-path>            → gezel.fs.read
+ *   ls [<relative-path>]           → gezel.fs.list
+ *   echo <text>                    → gezel.log
+ *   pwd | which <x> | # comment    → dropped (no-op in the sandbox)
+ *
+ * Deliberately unsupported: arguments after the script name (their
+ * semantics vary per runner), `npx`/`node` (arbitrary execution), git
+ * (no MCP tool in the translated-script contract), redirects/pipes/
+ * substitution (callers should pre-triage with `triageShellBlock`, but
+ * the transpiler independently rejects them).
+ */
+declare function transpileShellBlock(code: string, scriptName: string): {
+    body: string;
+} | null;
+
+/**
+ * Execution density — the single switch that scales how much orchestration
+ * scaffolding wraps a task, from the full crew + granular craftbook
+ * ("scaffold") down to a single generalist ambachtsman running a collapsed
+ * craftbook ("flat"). See `GezelConfig.executionDensity` and
+ * `docs/frontier-adaptive-execution.md`.
+ *
+ * Kept dependency-free (string in, union out) so both the runtime and the
+ * eval harness can resolve density the same way.
+ */
+type ExecutionDensity = 'flat' | 'scaffold';
+type ExecutionDensitySetting = 'auto' | ExecutionDensity;
+/**
+ * Providers that run their OWN internal agent loop (plan→act→observe)
+ * inside a single CLI/SDK invocation — they self-orchestrate, so gezel's
+ * outer crew + per-step loop is largely redundant overhead. A finer cut
+ * than "is this a cloud provider": `copilot` is cloud-backed but DOES
+ * self-orchestrate, whereas raw cloud APIs (`anthropic`, `openai`) and
+ * local engines (`llama-cpp`, `mlx`, `ds4`) do not — gezel drives their loop
+ * one turn per step.
+ *
+ * Mirrors `evals/src/providers.ts` `isSelfOrchestratingProvider`. Takes a
+ * bare string to avoid coupling to the provider-name union.
+ */
+declare function isSelfOrchestratingProvider(providerName: string | undefined): boolean;
+/**
+ * Resolve the effective execution density for a session.
+ *
+ *  - explicit `flat` / `scaffold` → that value (the config override / escape
+ *    hatch — set `scaffold` to force the full crew on a frontier provider).
+ *  - `auto` **and unset** → `flat` for self-orchestrating providers, else
+ * `scaffold`. `auto` is the default: validated by the A/B
+ *    (codex-cli, flat == scaffold pass rate at −36% to −61% tokens; the
+ *    quality gates stay the universal floor that makes flat safe). Local
+ *    MEDIUM-tier models also resolve to `flat` (paired N=3 core A/B, see the
+ *    function body); local small/tiny/large and raw-cloud stay `scaffold`.
+ */
+declare function resolveExecutionDensity(setting: ExecutionDensitySetting | undefined, providerName: string | undefined, tier?: string): ExecutionDensity;
+
+interface PlanStepSummary {
+    id: string;
+    name: string;
+    description?: string;
+    /** The concrete static deliverable this step produces, if any. */
+    deliverable?: string;
+    /** A short description of how the deliverable is enforced. */
+    enforcement?: string;
+    /** True when the step has a gate (checks/scripts) or an advanceWhen file. */
+    gated: boolean;
+    terminal: boolean;
+    /** True when this is the terminal step that verifies outcomes. */
+    isVerification: boolean;
+    /** Resolved gezel or suggested role label. */
+    assignee?: string;
+}
+interface PlanSummary {
+    title: string;
+    about: string;
+    outcomes: Outcome[];
+    steps: PlanStepSummary[];
+    buildStepCount: number;
+    gatedBuildStepCount: number;
+    hasVerification: boolean;
+}
+/** Curate a draft task's craftbook + outcomes into a structured summary. */
+declare function summarizePlanDocument(task: Task): PlanSummary;
+/**
+ * Readiness warnings for a plan, in human-readable form. Empty means the
+ * plan is well-formed. Surfaced in the UI (with an "Approve anyway"
+ * override) and enforced by `TaskManager.activate` (unless forced).
+ */
+declare function planGuardrails(summary: PlanSummary): string[];
+/** Render a draft task as a readable markdown "plan document". */
+declare function renderPlanDocument(task: Task): string;
+
+/**
+ * Shared parser for gezel @-mention markdown.
+ *
+ * The composer writes mentions as `@[Label](gezel:id)` and may append a
+ * `?project=<projectId>` routing suffix to the id. The service receives the
+ * raw id over the chat-session wire shape, so UI and service must agree on
+ * the split rules.
+ */
+interface GezelMentionToken {
+    /** Bare gezel id, without an optional `?project=...` suffix. */
+    id: string;
+    /** Display label as written in the markdown brackets. */
+    label: string;
+    /** Full id as it appears between `gezel:` and `)`. */
+    rawId: string;
+    /** Project routing override decoded from the suffix, if present. */
+    projectId?: string;
+}
+declare function extractGezelMentions(markdown: string): string[];
+declare function extractGezelMentionTokens(markdown: string): GezelMentionToken[];
+declare function parseGezelMentionId(rawId: string): {
+    gezelId: string;
+    projectId?: string;
+};
+declare function stripGezelMentions(text: string): string;
+
+/**
+ * Config override for every pnpm command that installs or operates inside
+ * a relocatable install tree (system toolsets, catalog npm toolsets).
+ *
+ * Those trees are `pnpm install`ed in a staging directory and renamed into
+ * place. pnpm's default isolated linker uses NTFS junctions on Windows,
+ * whose targets are stored as absolute paths — after the rename every link
+ * dangles and the first cross-package require fails. A hoisted tree
+ * contains no links and survives relocation on every platform.
+ *
+ * Later invocations against the same tree (`pnpm exec playwright …`) must
+ * repeat the flag: when the current config disagrees with the linker
+ * recorded in `node_modules/.modules.yaml`, pnpm silently rebuilds the
+ * tree with the default isolated linker before running the command.
+ */
+declare const PNPM_HOISTED_NODE_LINKER = "--config.node-linker=hoisted";
+interface PnpmInvocationOptions {
+    pnpmPath?: string;
+    nodePath?: string;
+    processExecPath: string;
+    platform: NodeJS.Platform;
+}
+interface PnpmInvocation {
+    command: string;
+    args: string[];
+    shell: boolean;
+    mode: 'node-script' | 'executable' | 'path-fallback';
+}
+/**
+ * Resolve a pnpm launch without assuming that `GEZEL_PNPM_PATH` is an
+ * executable. Packaged Gezel points it at pnpm's JavaScript entrypoint
+ * and launches that script with the separately bundled Node runtime.
+ * Development installs can still point at an executable or fall back to
+ * the `pnpm` shim on PATH.
+ */
+declare function resolvePnpmInvocation(args: string[], options: PnpmInvocationOptions): PnpmInvocation;
+
+/**
+ * Transient-network retry primitives, shared by every code path that pulls
+ * bytes off the internet.
+ *
+ * There are two shapes of network work in gezel and they need different
+ * treatment:
+ *
+ *   1. **Multi-GB resumable transfers** (model weights, engine archives).
+ *      Those go through the service's `downloadWithRetry` helper, which
+ *      layers HTTP Range resumption and a progress-aware attempt budget on
+ *      top of the primitives here.
+ *   2. **The small requests that surround a big transfer** — GitHub release
+ *      metadata, SHA256SUMS manifests, npm packuments, sub-100 MiB tarballs.
+ *      Historically these had *no* retry at all, so one dropped packet
+ *      during first-run setup failed the whole install with a raw
+ *      `fetch failed`. `retryTransient` is for those.
+ *
+ * Both share one backoff schedule and one notion of "is this error worth
+ * retrying", so a flaky link produces consistent behavior everywhere.
+ */
+/**
+ * Backoff schedule (ms), indexed by 0-based retry number. Jitter is applied
+ * on top so concurrent transfers don't retry in lockstep and re-collide.
+ */
+declare const DEFAULT_BACKOFF_SCHEDULE_MS: readonly number[];
+/** Default attempt count for the small-request helper. 3 attempts = 2 retries. */
+declare const DEFAULT_TRANSIENT_ATTEMPTS = 3;
+declare function backoffDelayMs(retryIndex: number, schedule?: readonly number[], random?: () => number): number;
+/** Resolves `true` when the wait was cut short by an abort. */
+declare function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<boolean>;
+/**
+ * A non-2xx response, thrown so `retryTransient` can decide retryability from
+ * the status code. Callers that want a friendlier message pass one in.
+ */
+declare class HttpStatusError extends Error {
+    readonly status: number;
+    constructor(status: number, message?: string);
+}
+/**
+ * 5xx, 408, and 429 are the server telling us to come back. Everything else in
+ * 4xx is a real client-side problem (missing asset, gated repo, bad auth) and
+ * retrying just delays an unavoidable error.
+ */
+declare function isTransientHttpStatus(status: number): boolean;
+/**
+ * Statuses that mean "the service is throttling or shedding load — back off
+ * and come back later", as opposed to a fault worth retrying inline.
+ */
+declare function isRateLimitStatus(status: number): boolean;
+/**
+ * Undici surfaces network faults as `TypeError: fetch failed` with the real
+ * errno on `.cause`, so match against the flattened chain rather than
+ * `err.code`. Aborts are deliberately NOT transient — a cancel means stop.
+ */
+declare function isTransientNetworkError(err: unknown): boolean;
+/** Error name + message + the whole `cause` chain, for pattern matching. */
+declare function flattenErrorMessage(err: unknown): string;
+interface RetryAttemptInfo {
+    /** Which attempt is about to start (1-based). */
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    /** Flattened message of the failure that triggered this retry. */
+    reason: string;
+}
+interface RetryTransientOptions {
+    /** Total attempts, not retries. Default 3. */
+    attempts?: number;
+    /** Short human label used in the give-up message, e.g. 'release metadata'. */
+    label?: string;
+    signal?: AbortSignal;
+    /** Override which errors are worth retrying. Default: `isTransientNetworkError`. */
+    isRetryable?: (err: unknown) => boolean;
+    /** Notified before each wait, for progress plumbing / logging. */
+    onRetry?: (info: RetryAttemptInfo) => void;
+    schedule?: readonly number[];
+}
+/**
+ * Run `fn`, retrying transient network failures with exponential backoff.
+ * Non-transient failures (4xx, programming errors, aborts) rethrow on the
+ * first try — retrying them would only add latency to a certain failure.
+ */
+declare function retryTransient<T>(fn: (attempt: number) => Promise<T>, opts?: RetryTransientOptions): Promise<T>;
+/**
+ * `retryTransient` around a single `fetch`, with non-retryable statuses
+ * rejected as `HttpStatusError` so callers get one uniform error type.
+ * The response body is left unread — the caller owns it.
+ */
+declare function fetchWithRetry(url: string, init?: RequestInit & {
+    fetchImpl?: typeof fetch;
+}, opts?: RetryTransientOptions): Promise<Response>;
+
+/**
+ * App-version compatibility checks for catalog content.
+ *
+ * Gilde items may declare `minGezelVersion` — the oldest gezel build that can
+ * meaningfully use them (e.g. a model needing a newer bundled engine). Gezel
+ * versions are date-based (`1.YYDDD.RUN`, see scripts/stamp-version.mjs), so
+ * floors are authored as `1.YYDDD` — major.minor only, because the run number
+ * is unknowable ahead of a release. Comparison is numeric per component with
+ * missing components treated as 0, which makes a two-component floor behave
+ * exactly like "any build of that day or later".
+ */
+/**
+ * Numeric component-wise comparison of dotted version strings. Missing
+ * components count as 0. Returns NaN when either side has a non-numeric
+ * component — callers decide how to treat malformed input.
+ */
+declare function compareGezelVersions(a: string, b: string): number;
+/**
+ * True when `current` satisfies a `minGezelVersion` floor.
+ *
+ * - No floor → satisfied.
+ * - `current === '0.0.0'` (unstamped dev checkout — dev daemons, evals,
+ *   tests) → satisfied; dev builds never filter content.
+ * - `GEZEL_IGNORE_MIN_GEZEL_VERSION=1` → satisfied (debug escape hatch for
+ *   stamped builds).
+ * - A malformed floor → satisfied. Malformed content must never make items
+ *   vanish from the catalog (same swallow-errors stance as the loader's
+ *   semver `safeCompare`).
+ */
+declare function satisfiesMinGezelVersion(floor: string | undefined, current: string): boolean;
+/**
+ * The stricter (higher) of two optional floors — used when composing an
+ * identity-level floor with a version-level one into the resolved manifest.
+ * Malformed floors lose to well-formed ones; two malformed floors return the
+ * first.
+ */
+declare function maxMinGezelVersion(a: string | undefined, b: string | undefined): string | undefined;
+
+/**
+ * True for managed companion/runtime paths that travel with an outside-in
+ * document but are not themselves user-visible library entries.
+ */
+declare function isOutsideInInternalPath(path: string): boolean;
+
+/**
+ * The package version is embedded into health responses and logs so clients
+ * can surface it in the UI.
+ */
+declare const GEZEL_VERSION = "0.1.0";
+/**
+ * Default ISO-timestamp helper so every package produces the same shape.
+ */
+declare function nowIso(): string;
+
+export { ACCESSORY_OPTIONS, ACCESSORY_RARITY, ACCESSORY_RARITY_WEIGHT, type AIEngagementMode, type AccessoryOption, type AccessoryRarity, type AccessoryRarityEntry, AdvanceWhen, type AffinityEdge, BINARY_DOCUMENT_EXTENSIONS, BODY_ARCHETYPES, BODY_SHAPE_KEYS, type BinaryDocumentContainer, type BinaryDocumentVerdict, type BlockPlacement, type BodyArchetype, type BodyShape, CONSTRAINED_HOST_RAM_BYTES, CONSTRAINED_HOST_VRAM_BYTES, CONSTRAINED_LOCAL_CONTEXT_FLOOR_TOKENS, type CollapseCraftbookResult, CompassRegion, type ComposedCodeContext, type ComposedSection, type ConvertedScript, Craftbook, CraftbookDoc, CraftbookDocError, CraftbookDocFormat, type CraftbookFromDocOptions, type CraftbookFromDocResult, CraftbookStep, DEFAULT_BACKOFF_SCHEDULE_MS, DEFAULT_NIGHT_SHIFT_WINDOW, DEFAULT_SANDBOX_COPILOT, DEFAULT_SECURITY_LEVEL, DEFAULT_TOOLSET_GROUPS, DEFAULT_TRANSIENT_ATTEMPTS, DENSE_ONLY_VRAM_THRESHOLD, DRESS_OPTIONS, DRESS_RARITY, type DeliverableKind, DeliverableKindSchema, type DisplayableGezel, type DressOption, EXPRESSION_OPTIONS, type ExecutionDensity, type ExecutionDensitySetting, type Expression, FACIAL_HAIR_OPTIONS, FIGURE_SCALES, FIGURE_SCALE_KEYS, FIGURE_SCALE_ODDS, FIT_KV_CONTEXT_TOKENS, type FacialHairOption, type FigureScale, type FigureScaleDef, FileContextResponse, type FitnessBadge, type FitnessBadgeInput, type FitnessBadgeTier, GEZEL_CHAT_FONTS, GEZEL_VERSION, GRAIN_PRESETS, GROWTH_COSMETICS, GateCheck, GateScriptRef, GezelConfig, type GezelFont, type GezelFontId, GezelGender, type GezelHref, type GezelMentionToken, type GezelPronounForms, type GrainPreset, type GrainStyle, type GrowthCosmetic, HAIR_SHAPES, HAT_FELTS, HAT_OPTIONS, type HairShape, type HardwareHint, type HatOption, HttpStatusError, KOKORO_VOICES, type KokoroVoiceInfo, LOCAL_CONTEXT_FLOOR_TOKENS, type LayoutFileInput, type LayoutOptions, type LayoutResult, type LogLevel, type Logger, MARK_OPTIONS, MIN_TRIALS_FOR_RATE, MODEL_FAMILIES_LEAKING_REASONING, MOE_NON_EXPERT_FRACTION_ESTIMATE, type MachineMemoryShape, MapBuilding, MapDistrict, MapPlaza, MapStreet, type MarkOption, MdSection, type MetaFormValue, type MetaInputFormItem, type MetaOutputFormItem, type ModelFitInput, type ModelFitResult, type ModelFitTier, ModelFitnessRecord, type ModelScore, ModelTier, NewCraftbookStep, type NightShiftWindow, OLLAMA_REASONING_MODEL_PREFIXES, Outcome, PALETTE, PARAM_PROJECT_PROPERTY_KEY, PLATE_H, PNPM_HOISTED_NODE_LINKER, PROJECT_GEZEL_ID_PREFIX, PROJECT_GEZEL_LOCAL_ID, PROJECT_PROPERTY_DEFINITIONS, PROJECT_TYPES, type ParseCraftbookDocResult, type ParseSkillDocOptions, type PersistNode, type PlanStepSummary, type PlanSummary, type PnpmInvocation, type PnpmInvocationOptions, type Poppetje, PoppetjeSchema, type PoppetjeSeedOptions, type PriorNode, Project, type ProjectPropertyDefinition, type ProjectPropertyKind, type ProjectType, type ProjectTypeDetect, ProjectTypeDetectSchema, type ProjectTypeGezelAffinity, ProjectTypeGezelAffinitySchema, type ProjectTypeGezelRole, ProjectTypeGezelRoleSchema, ProjectTypeSchema, REDACTED, REDACTED_EMAIL, ROLES, ROLE_ALIASES, ROLLABLE_ACCESSORIES, ROLLABLE_DRESSES, ROLLABLE_HATS, type RecoDevice, type RecoGateInput, type RecoModelInput, type RecoPick, Rect, type RedactSensitiveOptions, type ResolvedSecurityPolicy, type RetryAttemptInfo, type RetryTransientOptions, type RoleDefinition, type RoleId, SCORECARD, SCORECARD_SCHEMA_VERSION, SECURITY_PRESETS, SHIRT_PATTERN_OPTIONS, SLOT_ODDS, SMALL_MODEL_VRAM_THRESHOLD, STREET_WIDTHS, type ScorecardCell, ScorecardCellSchema, type ScorecardDataset, ScorecardDatasetSchema, type ScorecardDevice, ScorecardDeviceSchema, type ScorecardModelResult, ScorecardModelResultSchema, type ScorecardProvenance, ScorecardProvenanceSchema, type ScorecardRun, ScorecardRunSchema, ScriptInputField, ScriptMeta, ScriptOutputField, type SecurityCapabilities, type SecurityLevel, SecurityPolicy, type SecurityPresetLevel, type SegmentedSkillBody, type ShirtPattern, type SkillConversionOptions, type SkillConversionResult, type SkillDoc, type SkillFileKind, type SkillFileRef, type SkillHookDecl, type SkillPersona, type SplitScriptSource, StepDeliverable, type StepFamily, StepGate, type StepMatch, type StrippedSkillBody, type SuiteScoreboard, Task, ToolsetRuntime, type TownPlate, type TownPlaza, type TownResult, type TownRootResult, type UntranslatedBlock, VillageAnchor, VillageOverride, type WorkshopTempo, type WorkshopTempoDefaults, advanceSniffForKind, appendLotInFolder, assignRegions, backoffDelayMs, binaryDocumentContainer, binaryDocumentExtension, blockSize, buildSuiteScoreboard, cellAttributableTrials, classifySecurityLevel, coerceDeliverableKind, collapseCraftbookForTier, collapseFiles, compareGezelVersions, completionGate, composeFileContext, composeFitnessBadge, computeModelFit, craftbookFromDoc, createLogger, decodeProjectGezelId, deliverableKindForStep, deliverableStep, deriveAnchorsFromPrior, describeProvenance, displayLabels, displayName, docFromCraftbook, encodeProjectGezelId, escapeMd, estimateManifestKvBytes, excludesMoE, expandStepDeliverable, expandStepDeliverables, extractGezelMentionTokens, extractGezelMentions, femaleNames, fetchWithRetry, findKokoroVoice, firstActionForKind, flattenErrorMessage, folderPad, footprintWithin, formValueToMeta, formatPassClaim, getEngagementMode, getLogLevel, getProjectType, getWorkshopTempo, gezelLineHref, gezelNavHref, growthCosmeticById, hardwareHint, hash01, headlineRunForSuite, inferDeliverableKind, inferGenderForName, initialPoppetjeForGezel, isBandwidthBoundHost, isBinaryDocumentPath, isCanonicalProjectGezelId, isEngagementAllowed, isInNightShiftWindow, isMemoryConstrainedMachine, isMoEFromTags, isOllamaReasoningModel, isOutsideInInternalPath, isProactiveAllowed, isProjectGezelId, isProseDocPath, isRateLimitStatus, isRecommendedModel, isSchedulingAllowed, isSelfOrchestratingProvider, isTaskWorkAllowed, isTransientHttpStatus, isTransientNetworkError, isTrustedConstrainedToolset, isUnifiedMemoryDevice, isValidKokoroVoice, joinMetaRegion, lastNightShiftWindow, layoutBuildingsInBlock, layoutFileMap, leaksUntaggedReasoning, listProjectTypes, localContextFloorTokens, localDateKey, lotSpec, maleNames, matchStepHeading, maxMinGezelVersion, mediaModelFits, meetsCapabilityFloor, mergeStreets, metaToFormValue, nearestFreeRect, needsSmallModelRecommendation, nextLockedCosmetic, nextNightShiftStart, nightShiftDayKey, nightShiftWindowKey, normalizeChatModelCatalogId, nowIso, packLeafStrip, packTownNode, packTownRoot, packTownSubtree, paramProjectProperty, parseCraftbookDoc, parseGezelHref, parseGezelMentionId, parseMetaObject, parseSkillDoc, pickKokoroVoiceForGender, pickRandomName, pickRandomNameWithGender, pickRecommendedModel, placeGhostBlocks, planGuardrails, plateRectFor, poppetjeFromSeed, prefersMoE, prettifyToolName, projectGezelId, projectPropertyDefinition, projectWorkspaceWritable, pronounFormsForGender, pronounsForGender, provenanceDifferences, quoteSingle, redactCredentials, redactSensitive, regionCell, regionOf, renderPlanDocument, resolveExecutionDensity, resolveGezelFontFamily, resolveGezelFontScale, resolvePnpmInvocation, resolveRoleId, resolveSandboxCopilot, resolveSecurityPolicy, retryTransient, rewriteGezelHrefs, roleCapabilityFloor, roleDefaultBooks, roleDefinition, roleDeliverableScripts, roleGateAffinity, roleSuggestedTuningProfile, satisfiesMinGezelVersion, scoreModel, scorecardIsEmpty, securityPolicyForLevel, seedFromKey, segmentSkillBody, serializeCraftbookDoc, serializeScriptMeta, setDebugNamespaces, setLogLevel, setupLineSpan, skillToCraftbookDoc, sleepWithAbort, splitScriptSource, stepDeliverablePath, stitchScriptSource, streetId, streetTier, streetWidth, stripGeneratedPreamble, stripGezelMentions, stripMcpPrefix, summarizePlanDocument, toolActivityLabel, toolsetGroupsForRole, transpileShellBlock, verifyBinaryDocumentBytes, videoMemoryBudgetBytes, workshopTempoDefaults };