@otto-code/protocol 0.8.9 → 0.8.12

package/dist/context.js

@@ -0,0 +1,295 @@
+import { z } from "zod";
+/**
+ * Otto Context Management wire schemas: the context report, findings, prompt
+ * preview and edge-conversion RPCs (see docs/context-management.md).
+ *
+ * Context Management is a fork-only capability, so its schemas live in their own
+ * protocol module rather than inside messages.ts, matching kanban.ts, brain.ts
+ * and the other Otto domains. messages.ts re-exports them for back-compat.
+ */
+// Context Management - the daemon's accounting of everything a provider sends
+// before the user types (see docs/context-management.md).
+//
+// Two distinctions carry the whole feature and must not be collapsed on the
+// wire: an `import` edge is inlined into the request while a `reference` edge
+// costs only its link text, and `costClass` separates weight that rides every
+// request from weight that loads only when the agent touches an area.
+//
+// All numbers are estimates (chars/4) and `confidence` says how much to trust
+// the file set: `exact` when Otto composed the payload itself, `convention`
+// when resolved from a provider's documented layout, `unverified` for
+// subprocess-owned agents we cannot see into.
+// COMPAT(contextManagement): added in v0.6.5, drop the gate when daemon floor >= v0.6.5.
+export const ContextScopeSchema = z.enum([
+    "enterprise",
+    "global",
+    "project",
+    "local",
+    "subdirectory",
+    "runtime",
+]);
+export const ContextCategorySchema = z.enum([
+    "context_files",
+    "memory_index",
+    "skills_roster",
+    "mcp_tools",
+    "otto_injected",
+    "system_prompt",
+]);
+export const ContextCostClassSchema = z.enum(["fixed", "conditional", "referenced"]);
+export const ContextSeveritySchema = z.enum(["ok", "notice", "warn", "critical"]);
+export const ContextConfidenceSchema = z.enum(["exact", "convention", "unverified"]);
+// Per-category disclosure of how well the daemon can see a provider's payload.
+// `not_visible` is the reason this exists: a CLI-backed provider composes its
+// own preset and hands MCP servers to a subprocess, so those categories are
+// unmeasurable rather than empty, and the row has to be able to say which.
+export const ContextCategoryVisibilitySchema = z.enum([
+    "exact",
+    "convention",
+    "unverified",
+    "not_visible",
+]);
+export const ContextFindingKindSchema = z.enum([
+    "dead_import",
+    "dead_reference",
+    "duplicate_across_scope",
+    "duplicate_within_file",
+    "oversized_memory_entry",
+    "import_cycle",
+    "depth_capped",
+]);
+export const ContextRangeSchema = z.object({
+    start: z.number(),
+    end: z.number(),
+});
+export const ContextFindingSchema = z.object({
+    kind: ContextFindingKindSchema,
+    message: z.string(),
+    range: ContextRangeSchema.optional(),
+    relatedNodeIds: z.array(z.string()).optional(),
+    // The node this finding is about. Redundant while the finding sits on its
+    // node, load-bearing once the report flattens them all into one list - that
+    // list is the "Issues" tab, and without this a row cannot say where it came
+    // from or take you there.
+    nodeId: z.string().optional(),
+    // 1-based line of `range.start` in that node's file, so the fix list can jump
+    // the editor without the client re-reading bytes to count newlines.
+    line: z.number().optional(),
+    // Last line of the range, so the client can select the whole offending span
+    // rather than dropping a cursor at the top of it.
+    lineEnd: z.number().optional(),
+    // True for kinds a mechanical delete can resolve on its own (dead links, a
+    // duplicate block) - false/absent for kinds that need judgment (which side
+    // of an import cycle to cut, how to split an oversized entry). Computed
+    // server-side, once, in `locateFinding` - the only place that knows the kind
+    // vocabulary, so the fix-all button never has to guess.
+    fixable: z.boolean().optional(),
+    // The exact text at `range` when the file was scanned. `context.findings.fix`
+    // verifies this still matches before deleting, the same staleness guard
+    // `context.edge.convert` uses for `rawTarget`.
+    snippet: z.string().optional(),
+});
+export const ContextNodeSchema = z.object({
+    id: z.string(),
+    path: z.string(),
+    relPath: z.string(),
+    scope: ContextScopeSchema,
+    category: ContextCategorySchema,
+    costClass: ContextCostClassSchema,
+    bytes: z.number(),
+    estTokens: z.number(),
+    // Extra parents that also reach this node. The node is listed and counted
+    // exactly once; these render as a dimmed "also imported by" chip.
+    alsoImportedByNodeIds: z.array(z.string()),
+    findings: z.array(ContextFindingSchema),
+});
+export const ContextEdgeSchema = z.object({
+    fromNodeId: z.string(),
+    // Null when the target could not be resolved - pairs with a dead_* finding.
+    toNodeId: z.string().nullable(),
+    kind: z.enum(["import", "reference"]),
+    rawTarget: z.string(),
+    // Byte range of the whole reference token in the parent file, which is what
+    // makes "Always load" <-> "Link only" a single-span edit.
+    range: ContextRangeSchema,
+});
+export const ContextCategoryTotalSchema = z.object({
+    category: ContextCategorySchema,
+    estTokens: z.number(),
+    sharePercent: z.number(),
+    severity: ContextSeveritySchema,
+    // COMPAT(contextCategoryVisibility): added in v0.7.1, drop the optionality
+    // when the floor is >= v0.7.1. An older client ignores the field and still
+    // gets correct totals; a newer client seeing it absent renders no badge.
+    visibility: ContextCategoryVisibilitySchema.optional(),
+});
+export const ContextReportSchema = z.object({
+    workspaceId: z.string(),
+    provider: z.string(),
+    // The window the report was evaluated against - from the active model, or
+    // the client's what-if picker. Severity is meaningless without it.
+    windowTokens: z.number(),
+    scannedAt: z.string(),
+    confidence: ContextConfidenceSchema,
+    supported: z.boolean(),
+    supportsImports: z.boolean(),
+    nodes: z.array(ContextNodeSchema),
+    edges: z.array(ContextEdgeSchema),
+    categoryTotals: z.array(ContextCategoryTotalSchema),
+    fixedTotal: z.number(),
+    conditionalTotal: z.number(),
+    referencedTotal: z.number(),
+    workingRoom: z.number(),
+    aggregateSeverity: ContextSeveritySchema,
+    findings: z.array(ContextFindingSchema),
+    // Which personality this report was evaluated FOR. Context became
+    // personality-specific once personalities accrue memory, so a report is only
+    // interpretable alongside the identity it was measured against.
+    // COMPAT(personalityMemory): additive; absent = the pre-memory, personality-agnostic report.
+    personalityId: z.string().optional(),
+    // That personality's injected memory brief, in tokens. Folded into the
+    // `otto_injected` category total rather than a new category: ContextCategory
+    // is a z.enum travelling daemon->client, so a new member would make a new
+    // daemon's report unparseable by an older client.
+    personalityMemoryTokens: z.number().optional(),
+    // COMPAT(projectKnowledge): additive; repo-owned knowledge is folded into
+    // otto_injected, while this field keeps its recurring cost inspectable.
+    projectKnowledgeTokens: z.number().optional(),
+});
+// Pushed with the full current report whenever a watched context file changes.
+// Full-report reconciliation, same idiom as suggested_tasks_changed.
+export const ContextReportChangedSchema = z.object({
+    type: z.literal("context_report_changed"),
+    payload: z.object({
+        workspaceId: z.string(),
+        report: ContextReportSchema.nullable(),
+    }),
+});
+// `provider` and `windowTokens` are the what-if pickers: omitted means "the
+// active agent's provider and its model's real window".
+export const ContextReportGetRequestMessageSchema = z.object({
+    type: z.literal("context.report.get.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    provider: z.string().optional(),
+    windowTokens: z.number().optional(),
+    // "Evaluate as if this personality were running here": folds that
+    // personality's injected memory brief into the report's fixed weight. Omitted
+    // means the personality-agnostic report.
+    personalityId: z.string().optional(),
+});
+export const ContextReportGetResponseMessageSchema = z.object({
+    type: z.literal("context.report.get.response"),
+    payload: z.object({
+        requestId: z.string(),
+        report: ContextReportSchema.nullable(),
+    }),
+});
+// One readable block of the assembled prompt. `text` is absent exactly when
+// `visibility` is "not_visible" - the provider composes that part internally and
+// Otto has nothing to show, which the section states rather than hides.
+export const ContextPromptSectionSchema = z.object({
+    category: ContextCategorySchema,
+    label: z.string(),
+    visibility: ContextCategoryVisibilitySchema,
+    text: z.string().optional(),
+    estTokens: z.number(),
+});
+export const ContextPromptPreviewSchema = z.object({
+    sections: z.array(ContextPromptSectionSchema),
+    estTokens: z.number(),
+});
+// Read-only by design: there is no matching write RPC. Editing happens per file
+// through the existing file pane, against the real file rather than a
+// concatenation of several.
+export const ContextPromptPreviewGetRequestMessageSchema = z.object({
+    type: z.literal("context.prompt.preview.get.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    provider: z.string().optional(),
+    windowTokens: z.number().optional(),
+    personalityId: z.string().optional(),
+    // Assemble only this category. The tab reads one section at a time - the user
+    // clicked a row in the tree - and assembling the rest would re-read every
+    // context file on disk to build text nobody asked to see. Omitted means all,
+    // which is what an older client sends.
+    category: ContextCategorySchema.optional(),
+});
+export const ContextPromptPreviewGetResponseMessageSchema = z.object({
+    type: z.literal("context.prompt.preview.get.response"),
+    payload: z.object({
+        requestId: z.string(),
+        preview: ContextPromptPreviewSchema.nullable(),
+    }),
+});
+// Converts one edge between "always loaded" and "link only". Server-side
+// because the parent file may live outside the workspace root.
+export const ContextEdgeConvertRequestMessageSchema = z.object({
+    type: z.literal("context.edge.convert.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    // The parent file holding the reference - its `ContextNode.path`, not its
+    // id: ids are case-folded on Windows and are not safe to write through.
+    filePath: z.string(),
+    rawTarget: z.string(),
+    range: ContextRangeSchema,
+    target: z.enum(["import", "reference"]),
+});
+export const ContextEdgeConvertResponseMessageSchema = z.object({
+    type: z.literal("context.edge.convert.response"),
+    payload: z.object({
+        requestId: z.string(),
+        ok: z.boolean(),
+        error: z.string().optional(),
+    }),
+});
+// Deletes every mechanically-fixable finding's range in one pass - the
+// "Fix all" button in the Issues tab. Each item names the file, the range the
+// scan flagged, and the snippet expected there; a file that changed since the
+// scan is skipped rather than corrupted (charter §7.5).
+export const ContextFindingsFixRequestMessageSchema = z.object({
+    type: z.literal("context.findings.fix.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    findings: z.array(z.object({
+        filePath: z.string(),
+        range: ContextRangeSchema,
+        snippet: z.string(),
+    })),
+});
+export const ContextFindingsFixResponseMessageSchema = z.object({
+    type: z.literal("context.findings.fix.response"),
+    payload: z.object({
+        requestId: z.string(),
+        fixedCount: z.number(),
+        failedCount: z.number(),
+        errors: z.array(z.string()),
+    }),
+});
+export const AgentContextGetUsageRequestMessageSchema = z.object({
+    type: z.literal("agent.context.get_usage.request"),
+    agentId: z.string(),
+    requestId: z.string(),
+});
+export const AgentContextUsageCategorySchema = z.object({
+    /** Provider-supplied display label, e.g. "Messages", "System prompt". Not translated. */
+    name: z.string(),
+    tokens: z.number(),
+    /** Deferred content (e.g. on-demand tool schemas) is not counted in totalTokens. */
+    isDeferred: z.boolean().optional(),
+});
+export const AgentContextUsageSchema = z.object({
+    categories: z.array(AgentContextUsageCategorySchema),
+    totalTokens: z.number(),
+    maxTokens: z.number(),
+});
+export const AgentContextGetUsageResponseMessageSchema = z.object({
+    type: z.literal("agent.context.get_usage.response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        /** Null when the agent's provider cannot report a context breakdown. */
+        usage: AgentContextUsageSchema.nullable(),
+    }),
+});
+//# sourceMappingURL=context.js.map

package/dist/daemon-config.d.ts

@@ -0,0 +1,377 @@
+import { z } from "zod";
+/**
+ * Otto's mutable daemon-config fragments: the per-feature config sections Paseo's MutableDaemonConfigSchema composes. Each Otto feature registers one field there; the section schema lives here.
+ */
+export declare const MutableAgentBehaviorsConfigSchema: z.ZodObject<{
+    promptSuggestions: z.ZodDefault<z.ZodBoolean>;
+    agentProgressSummaries: z.ZodDefault<z.ZodBoolean>;
+    notifyOnFinishDefault: z.ZodDefault<z.ZodBoolean>;
+    todoNudge: z.ZodDefault<z.ZodBoolean>;
+    todoReconcileOnIdle: z.ZodDefault<z.ZodBoolean>;
+    stallGuardThreshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * Language-server code intelligence, host-scoped because the servers are processes
+ * on the daemon's machine - they follow the host, not the client.
+ *
+ * `enabled` defaults **on** and that is safe: nothing spawns until a
+ * code-intelligence action needs a language in a workspace, so an unused language
+ * costs nothing. What the switch guarantees is that off means off - no server
+ * spawns for any workspace, and the ctags index still serves the outline and the
+ * fuzzy finder.
+ *
+ * `languages` keys are registry row ids (`typescript`, `python`, `csharp`, …). An
+ * absent key means "use the row's own default", so a new row ships with its
+ * intended default rather than reading as disabled.
+ */
+export declare const MutableLspConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    languages: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    csharpProjectScope: z.ZodOptional<z.ZodEnum<{
+        solution: "solution";
+        allProjects: "allProjects";
+    }>>;
+    maxRunningServers: z.ZodDefault<z.ZodNumber>;
+    idleMinutes: z.ZodDefault<z.ZodNumber>;
+    backgroundIdleMinutes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * "Microsoft .NET Solution Management" - the Solution view's own switch.
+ *
+ * **A sibling of `lsp`, not a member of it.** Turning C# code intelligence off does not turn
+ * this off and vice versa: they are independent capabilities that happen to share a language,
+ * and nesting this inside the LSP settings object would imply exactly the coupling that
+ * decision rejects. (It would also be wrong on the facts - LSP has no project-structure
+ * request, so nothing here rides on a language server.)
+ *
+ * Defaults **off**: the feature spawns a process and evaluates MSBuild. Disabled is genuinely
+ * off, not merely hidden - no discovery walk, no `.sln` read, no `.csproj` parse, no sidecar,
+ * no cache, no watcher, and no view switcher. The daemon reads this before scheduling any work,
+ * so a disabled feature costs exactly one boolean check.
+ */
+export declare const MutableDotnetSolutionConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxRunningProbes: z.ZodDefault<z.ZodNumber>;
+    idleMinutes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const MutableGitHostingBitbucketCloudConfigSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    apiToken: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const MutableGitHostingAtlassianConfigSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    apiToken: z.ZodOptional<z.ZodString>;
+    jiraSiteUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const MutableGitHostingProvidersConfigSchema: z.ZodObject<{
+    bitbucketCloud: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        apiToken: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    atlassian: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        apiToken: z.ZodOptional<z.ZodString>;
+        jiraSiteUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const MutableGitHostingConfigSchema: z.ZodObject<{
+    providers: z.ZodOptional<z.ZodObject<{
+        bitbucketCloud: z.ZodOptional<z.ZodObject<{
+            email: z.ZodOptional<z.ZodString>;
+            apiToken: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        atlassian: z.ZodOptional<z.ZodObject<{
+            email: z.ZodOptional<z.ZodString>;
+            apiToken: z.ZodOptional<z.ZodString>;
+            jiraSiteUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type MutableGitHostingConfig = z.infer<typeof MutableGitHostingConfigSchema>;
+export declare const MutableKanbanConfigSchema: z.ZodObject<{
+    providers: z.ZodOptional<z.ZodObject<{
+        github: z.ZodObject<{
+            token: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        jira: z.ZodObject<{
+            token: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type MutableKanbanConfig = z.infer<typeof MutableKanbanConfigSchema>;
+export declare const MutableAgentPersonalitiesConfigSchema: z.ZodObject<{
+    personalities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        effortLevel: z.ZodOptional<z.ZodString>;
+        modeId: z.ZodOptional<z.ZodString>;
+        personalityPrompt: z.ZodOptional<z.ZodString>;
+        respectGlobalAppendPrompt: z.ZodOptional<z.ZodBoolean>;
+        roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        spinner: z.ZodOptional<z.ZodObject<{
+            glowA: z.ZodString;
+            glowB: z.ZodString;
+        }, z.core.$loose>>;
+        voice: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$loose>>;
+        voiceCues: z.ZodOptional<z.ZodObject<{
+            join: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            thinking: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            done: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+        memoryEnabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare const MutableAgentPersonalitiesConfigPatchSchema: z.ZodObject<{
+    personalities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        effortLevel: z.ZodOptional<z.ZodString>;
+        modeId: z.ZodOptional<z.ZodString>;
+        personalityPrompt: z.ZodOptional<z.ZodString>;
+        respectGlobalAppendPrompt: z.ZodOptional<z.ZodBoolean>;
+        roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        spinner: z.ZodOptional<z.ZodObject<{
+            glowA: z.ZodString;
+            glowB: z.ZodString;
+        }, z.core.$loose>>;
+        voice: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$loose>>;
+        voiceCues: z.ZodOptional<z.ZodObject<{
+            join: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            thinking: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            done: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+        memoryEnabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare const MutableAgentTeamsConfigSchema: z.ZodObject<{
+    teams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodOptional<z.ZodObject<{
+            color: z.ZodOptional<z.ZodString>;
+            imageId: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        teamPrompt: z.ZodOptional<z.ZodString>;
+        memberIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>>;
+    activeTeamId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const MutableAgentTeamsConfigPatchSchema: z.ZodObject<{
+    teams: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodOptional<z.ZodObject<{
+            color: z.ZodOptional<z.ZodString>;
+            imageId: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        teamPrompt: z.ZodOptional<z.ZodString>;
+        memberIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>>;
+    activeTeamId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const MutableBrainTlsConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        files: "files";
+        "self-signed": "self-signed";
+        tailscale: "tailscale";
+    }>>;
+    certFile: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    keyFile: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    hostname: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    certDir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    renewBeforeDays: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const MutableBrainRemoteConfigSchema: z.ZodObject<{
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    secure: z.ZodDefault<z.ZodBoolean>;
+    authToken: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    certFingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const MutableBrainConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    autoStart: z.ZodDefault<z.ZodBoolean>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        local: "local";
+        remote: "remote";
+    }>>;
+    remote: z.ZodDefault<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+        secure: z.ZodDefault<z.ZodBoolean>;
+        authToken: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        certFingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
+    listen: z.ZodDefault<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>>;
+    defaultModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    runtime: z.ZodDefault<z.ZodObject<{
+        source: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            managed: "managed";
+            lmstudio: "lmstudio";
+        }>>;
+        path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        logVerbosity: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    lockModel: z.ZodDefault<z.ZodBoolean>;
+    allowRemoteConfig: z.ZodDefault<z.ZodBoolean>;
+    allowInsecureBind: z.ZodDefault<z.ZodBoolean>;
+    authMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        token: "token";
+    }>>;
+    authToken: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    tls: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            files: "files";
+            "self-signed": "self-signed";
+            tailscale: "tailscale";
+        }>>;
+        certFile: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        keyFile: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        hostname: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        certDir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        renewBeforeDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type MutableBrainConfig = z.infer<typeof MutableBrainConfigSchema>;
+export declare const MutableBrainTlsPatchSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        files: "files";
+        "self-signed": "self-signed";
+        tailscale: "tailscale";
+    }>>;
+    certFile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keyFile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hostname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    certDir: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    renewBeforeDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const MutableBrainRemotePatchSchema: z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    secure: z.ZodOptional<z.ZodBoolean>;
+    authToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    certFingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const MutableBrainListenPatchSchema: z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const MutableBrainConfigPatchSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    autoStart: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        remote: "remote";
+    }>>;
+    remote: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        secure: z.ZodOptional<z.ZodBoolean>;
+        authToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        certFingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
+    listen: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    defaultModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            managed: "managed";
+            lmstudio: "lmstudio";
+        }>>;
+        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        logVerbosity: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    lockModel: z.ZodOptional<z.ZodBoolean>;
+    allowRemoteConfig: z.ZodOptional<z.ZodBoolean>;
+    allowInsecureBind: z.ZodOptional<z.ZodBoolean>;
+    authMode: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        token: "token";
+    }>>;
+    authToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tls: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            files: "files";
+            "self-signed": "self-signed";
+            tailscale: "tailscale";
+        }>>;
+        certFile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        keyFile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        hostname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        certDir: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        renewBeforeDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const DEFAULT_MUTABLE_BRAIN_CONFIG: {
+    enabled: boolean;
+    autoStart: boolean;
+    mode: "local";
+    remote: {
+        host: string;
+        port: number;
+        secure: boolean;
+        authToken: null;
+        certFingerprint: null;
+    };
+    listen: {
+        host: string;
+        port: number;
+    };
+    defaultModel: null;
+    runtime: {
+        source: "auto";
+        path: null;
+        logVerbosity: number;
+    };
+    lockModel: boolean;
+    allowRemoteConfig: boolean;
+    allowInsecureBind: boolean;
+    authMode: "none";
+    authToken: null;
+    tls: {
+        mode: "off";
+        certFile: null;
+        keyFile: null;
+        hostname: null;
+        certDir: null;
+        renewBeforeDays: number;
+    };
+};
+export declare const GIT_FETCH_INTERVAL_SECONDS: readonly [60, 180, 300, 600, 900, 1800, 3600];
+export declare const MutableGitFetchConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    intervalSeconds: z.ZodUnion<readonly [z.ZodLiteral<60>, z.ZodLiteral<180>, z.ZodLiteral<300>, z.ZodLiteral<600>, z.ZodLiteral<900>, z.ZodLiteral<1800>, z.ZodLiteral<3600>]>;
+}, z.core.$strip>;
+export declare const DEFAULT_MUTABLE_GIT_FETCH_CONFIG: {
+    enabled: boolean;
+    intervalSeconds: number;
+};
+export type MutableLspConfig = z.infer<typeof MutableLspConfigSchema>;
+export type MutableDotnetSolutionConfig = z.infer<typeof MutableDotnetSolutionConfigSchema>;
+//# sourceMappingURL=daemon-config.d.ts.map