@otto-code/protocol 0.8.9 → 0.8.12

package/dist/project-knowledge.js

@@ -0,0 +1,229 @@
+import { z } from "zod";
+/**
+ * Otto project-knowledge wire schemas: the project.knowledge.* RPCs and the delivery, reference and progress payloads they carry. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+// Repo-owned project knowledge is canonical Markdown under `.otto/knowledge`,
+// with daemon-owned writes so worktrees resolve to one store and every truth
+// change retains its timeline evidence.
+export const ProjectKnowledgeKindSchema = z.enum([
+    "decision",
+    "constraint",
+    "requirement",
+    "architecture",
+    "finding",
+    "project",
+    "reference",
+]);
+export const ProjectKnowledgeStatusSchema = z.enum(["proposed", "confirmed", "superseded"]);
+export const ProjectDeliveryStatusSchema = z.enum([
+    "charter",
+    "in_build",
+    "partial",
+    "blocked",
+    "complete",
+    "reference",
+    "deferred",
+    "cancelled",
+]);
+export const ProjectReferenceDispositionSchema = z.enum([
+    "unevaluated",
+    "read",
+    "adopted",
+    "rejected",
+    "dependency",
+]);
+export const ProjectProgressSchema = z.object({
+    completed: z.number().int().nonnegative(),
+    total: z.number().int().positive(),
+    unit: z.string().min(1).max(48),
+});
+export const ProjectKnowledgeRecordSchema = z.object({
+    id: z.string(),
+    kind: ProjectKnowledgeKindSchema,
+    title: z.string(),
+    statement: z.string(),
+    statementDigest: z.string().optional(),
+    evidence: z.string().optional(),
+    tags: z.array(z.string()),
+    status: ProjectKnowledgeStatusSchema,
+    deliveryStatus: ProjectDeliveryStatusSchema.optional(),
+    progress: ProjectProgressSchema.optional(),
+    referenceDisposition: ProjectReferenceDispositionSchema.optional(),
+    sourceUrl: z.string().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    provenance: z
+        .array(z.object({
+        text: z.string(),
+        recordedAt: z.string(),
+        source: z.string().optional(),
+        kind: z.string().optional(),
+        affects: z.array(z.string()).optional(),
+    }))
+        .optional(),
+    path: z.string().optional(),
+});
+/** Review health, not a persisted project-knowledge finding record. */
+export const ProjectKnowledgeHealthSchema = z.object({
+    kind: z.enum(["stale", "overlapping_tags", "overlapping_statement"]),
+    recordId: z.string(),
+    relatedRecordId: z.string().optional(),
+    tagOverlap: z.enum(["complete", "partial"]).optional(),
+    sharedTags: z.array(z.string()).optional(),
+    message: z.string(),
+});
+export const ProjectKnowledgeRootPageSchema = z.object({
+    slug: z.string(),
+    title: z.string(),
+    path: z.string(),
+    body: z.string(),
+});
+export const ProjectKnowledgeListRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.list.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+});
+export const ProjectKnowledgeListResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        records: z.array(ProjectKnowledgeRecordSchema),
+        rootPages: z.array(ProjectKnowledgeRootPageSchema).optional(),
+        findings: z.array(ProjectKnowledgeHealthSchema),
+        brief: z.string(),
+        briefTokens: z.number(),
+        includedIds: z.array(z.string()),
+        omittedCount: z.number(),
+    }),
+});
+export const ProjectKnowledgeGetRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.get.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    id: z.string(),
+});
+export const ProjectKnowledgeGetResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.get.response"),
+    payload: z.object({ requestId: z.string(), record: ProjectKnowledgeRecordSchema.nullable() }),
+});
+export const ProjectKnowledgeCreateRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.create.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    id: z.string().optional(),
+    kind: ProjectKnowledgeKindSchema,
+    title: z.string().max(160),
+    statement: z.string(),
+    evidence: z.string().optional(),
+    tags: z.array(z.string().max(48)).max(32).optional(),
+    affects: z.array(z.string()).optional(),
+    status: ProjectKnowledgeStatusSchema.optional(),
+    deliveryStatus: ProjectDeliveryStatusSchema.optional(),
+    progress: ProjectProgressSchema.optional(),
+    referenceDisposition: ProjectReferenceDispositionSchema.optional(),
+    sourceUrl: z.string().optional(),
+});
+export const ProjectKnowledgeCreateResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.create.response"),
+    payload: z.object({ requestId: z.string(), record: ProjectKnowledgeRecordSchema }),
+});
+export const ProjectKnowledgeApplyRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.apply.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    id: z.string(),
+    title: z.string().max(160).optional(),
+    statement: z.string().optional(),
+    evidence: z.string().optional(),
+    provenanceText: z.string().optional(),
+    provenanceSource: z.string().max(160).optional(),
+    provenanceAffects: z.array(z.string()).optional(),
+    expectedUpdatedAt: z.string().optional(),
+});
+export const ProjectKnowledgeApplyResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.apply.response"),
+    payload: z.object({
+        requestId: z.string(),
+        record: ProjectKnowledgeRecordSchema.nullable(),
+        error: z.string().optional(),
+    }),
+});
+export const ProjectKnowledgeStatusRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.status.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    id: z.string(),
+    status: ProjectKnowledgeStatusSchema,
+    reason: z.string().optional(),
+});
+export const ProjectKnowledgeStatusResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.status.response"),
+    payload: z.object({ requestId: z.string(), record: ProjectKnowledgeRecordSchema.nullable() }),
+});
+export const ProjectKnowledgeProjectApplyRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.project.apply.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    id: z.string(),
+    deliveryStatus: ProjectDeliveryStatusSchema.optional(),
+    progress: ProjectProgressSchema.nullable().optional(),
+    reason: z.string(),
+    expectedUpdatedAt: z.string().optional(),
+});
+export const ProjectKnowledgeProjectApplyResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.project.apply.response"),
+    payload: z.object({
+        requestId: z.string(),
+        record: ProjectKnowledgeRecordSchema.nullable(),
+        error: z.string().optional(),
+    }),
+});
+export const ProjectKnowledgeReferenceApplyRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.reference.apply.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    id: z.string(),
+    disposition: ProjectReferenceDispositionSchema.optional(),
+    sourceUrl: z.string().nullable().optional(),
+    reason: z.string(),
+    expectedUpdatedAt: z.string().optional(),
+});
+export const ProjectKnowledgeReferenceApplyResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.reference.apply.response"),
+    payload: z.object({
+        requestId: z.string(),
+        record: ProjectKnowledgeRecordSchema.nullable(),
+        error: z.string().optional(),
+    }),
+});
+export const ProjectKnowledgeRootApplyRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.root.apply.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    slug: z.string(),
+    body: z.string(),
+});
+export const ProjectKnowledgeRootApplyResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.root.apply.response"),
+    payload: z.object({
+        requestId: z.string(),
+        page: ProjectKnowledgeRootPageSchema.nullable(),
+    }),
+});
+export const ProjectKnowledgeDeleteRequestMessageSchema = z.object({
+    type: z.literal("project.knowledge.delete.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    id: z.string(),
+    reason: z.string(),
+    expectedUpdatedAt: z.string().optional(),
+});
+export const ProjectKnowledgeDeleteResponseMessageSchema = z.object({
+    type: z.literal("project.knowledge.delete.response"),
+    payload: z.object({
+        requestId: z.string(),
+        deleted: z.boolean(),
+        error: z.string().optional(),
+    }),
+});
+//# sourceMappingURL=project-knowledge.js.map

package/dist/project-links.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+/**
+ * Otto project-link wire schemas: the project.links.* RPCs and their payloads. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+export declare const ProjectLinkSchema: z.ZodObject<{
+    projectAId: z.ZodString;
+    projectBId: z.ZodString;
+}, z.core.$strip>;
+export declare const ProjectLinksListRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"project.links.list.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const ProjectLinksSetRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"project.links.set.request">;
+    projectId: z.ZodString;
+    otherProjectId: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const ProjectLinksUnsetRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"project.links.unset.request">;
+    projectId: z.ZodString;
+    otherProjectId: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const ProjectLinksListResponsePayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        projectAId: z.ZodString;
+        projectBId: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ProjectLinksListResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"project.links.list.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            projectAId: z.ZodString;
+            projectBId: z.ZodString;
+        }, z.core.$strip>>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ProjectLinksMutationResponsePayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    accepted: z.ZodBoolean;
+    links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        projectAId: z.ZodString;
+        projectBId: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ProjectLinksSetResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"project.links.set.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        accepted: z.ZodBoolean;
+        links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            projectAId: z.ZodString;
+            projectBId: z.ZodString;
+        }, z.core.$strip>>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ProjectLinksUnsetResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"project.links.unset.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        accepted: z.ZodBoolean;
+        links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            projectAId: z.ZodString;
+            projectBId: z.ZodString;
+        }, z.core.$strip>>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ProjectLinksChangedPayloadSchema: z.ZodObject<{
+    links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        projectAId: z.ZodString;
+        projectBId: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ProjectLinksChangedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"project.links.changed">;
+    payload: z.ZodObject<{
+        links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            projectAId: z.ZodString;
+            projectBId: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ProjectLink = z.infer<typeof ProjectLinkSchema>;
+export type ProjectLinksListResponse = z.infer<typeof ProjectLinksListResponseSchema>;
+export type ProjectLinksListResponsePayload = z.infer<typeof ProjectLinksListResponsePayloadSchema>;
+export type ProjectLinksSetResponse = z.infer<typeof ProjectLinksSetResponseSchema>;
+export type ProjectLinksUnsetResponse = z.infer<typeof ProjectLinksUnsetResponseSchema>;
+export type ProjectLinksMutationResponsePayload = z.infer<typeof ProjectLinksMutationResponsePayloadSchema>;
+export type ProjectLinksChanged = z.infer<typeof ProjectLinksChangedSchema>;
+export type ProjectLinksListRequest = z.infer<typeof ProjectLinksListRequestSchema>;
+export type ProjectLinksSetRequest = z.infer<typeof ProjectLinksSetRequestSchema>;
+export type ProjectLinksUnsetRequest = z.infer<typeof ProjectLinksUnsetRequestSchema>;
+//# sourceMappingURL=project-links.d.ts.map

package/dist/project-links.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+/**
+ * Otto project-link wire schemas: the project.links.* RPCs and their payloads. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+// An unordered pair of linked projects. The daemon stores the pair in a
+// canonical order, but clients treat it as undirected: a link between A and B
+// permits opening files across both projects. See the gated-multi-root project.
+export const ProjectLinkSchema = z.object({
+    projectAId: z.string(),
+    projectBId: z.string(),
+});
+export const ProjectLinksListRequestSchema = z.object({
+    type: z.literal("project.links.list.request"),
+    requestId: z.string(),
+});
+export const ProjectLinksSetRequestSchema = z.object({
+    type: z.literal("project.links.set.request"),
+    // Order is irrelevant; the daemon canonicalizes. Linking is idempotent.
+    projectId: z.string(),
+    otherProjectId: z.string(),
+    requestId: z.string(),
+});
+export const ProjectLinksUnsetRequestSchema = z.object({
+    type: z.literal("project.links.unset.request"),
+    projectId: z.string(),
+    otherProjectId: z.string(),
+    requestId: z.string(),
+});
+export const ProjectLinksListResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    links: z.array(ProjectLinkSchema).default([]),
+    error: z.string().nullable(),
+});
+export const ProjectLinksListResponseSchema = z.object({
+    type: z.literal("project.links.list.response"),
+    payload: ProjectLinksListResponsePayloadSchema,
+});
+export const ProjectLinksMutationResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    accepted: z.boolean(),
+    // The full link set after the mutation, so the client refreshes in one hop.
+    links: z.array(ProjectLinkSchema).default([]),
+    error: z.string().nullable(),
+});
+export const ProjectLinksSetResponseSchema = z.object({
+    type: z.literal("project.links.set.response"),
+    payload: ProjectLinksMutationResponsePayloadSchema,
+});
+export const ProjectLinksUnsetResponseSchema = z.object({
+    type: z.literal("project.links.unset.response"),
+    payload: ProjectLinksMutationResponsePayloadSchema,
+});
+// Pushed to the session whenever the link set changes (mutation or cascade on
+// project removal) so open UIs re-evaluate cross-project access without polling.
+export const ProjectLinksChangedPayloadSchema = z.object({
+    links: z.array(ProjectLinkSchema).default([]),
+});
+export const ProjectLinksChangedSchema = z.object({
+    type: z.literal("project.links.changed"),
+    payload: ProjectLinksChangedPayloadSchema,
+});
+//# sourceMappingURL=project-links.js.map

package/dist/provider-config.d.ts

@@ -260,6 +260,66 @@ export declare const COMPACTION_THRESHOLD_PERCENTS: readonly [50, 60, 70, 80, 90
 export declare const MAX_TOOL_ROUNDS_DEFAULT = 50;
 export declare const MAX_TOOL_ROUNDS_MIN = 1;
 export declare const MAX_TOOL_ROUNDS_MAX = 1000;
+/**
+ * Action circuit-breaker for daemon-hosted tool loops (openai-compat /
+ * Otto Brain). When enabled, an action (tool name + exact arguments) that
+ * fails this many times in a row stops being executed: the rest of the
+ * round's identical calls are dropped, and a repair prompt is sent to the
+ * model explaining what failed and how to change course. Small local models
+ * can degenerate into emitting the same broken action hundreds of times per
+ * round (the 2,912-call browser_navigate({}) incident); without the breaker
+ * each identical failure is appended to the conversation verbatim until the
+ * context window is blown and the turn dies. Defaults are safe for every
+ * model; bounds keep the setting a guard rail, not an off switch.
+ */
+export declare const ACTION_BREAKER_DEFAULT_THRESHOLD = 5;
+export declare const ACTION_BREAKER_MIN_THRESHOLD = 2;
+export declare const ACTION_BREAKER_MAX_THRESHOLD = 100;
+/**
+ * Tool-emission stall guard (daemon-wide, provider-agnostic). A healthy agent
+ * turn either acts - it emits a tool call - or it hands back to the human. An
+ * assistant message that does neither has no side effect, so a run that only
+ * produces those is not working, it is stuck. This is the count of consecutive
+ * such messages tolerated before the daemon interrupts the run.
+ *
+ * Purely structural: it counts stream events, never their text. A tool call
+ * resets it to zero, so a long working loop (a 200-turn investigation with a
+ * tool call every few turns) can never trip it; so does a real user prompt, so
+ * ordinary back-and-forth chat can never trip it either.
+ *
+ * `0` disables the guard. Bounds keep the setting a guard rail rather than a
+ * hair trigger. See agent-stall-guard.ts and the "unbounded tool-call
+ * announcement" finding: a local model emitted ~840 consecutive text-only
+ * messages over five minutes, re-announcing three tool calls it never sent, and
+ * nothing in the runtime noticed.
+ */
+export declare const STALL_GUARD_DEFAULT_THRESHOLD = 15;
+export declare const STALL_GUARD_MIN_THRESHOLD = 3;
+export declare const STALL_GUARD_MAX_THRESHOLD = 500;
+/**
+ * Per-round assistant-text budget for daemon-hosted tool loops (openai-compat /
+ * Otto Brain). The same invariant the stall guard enforces across messages, held
+ * *within* one: a model round that has streamed this much prose while emitting
+ * no tool call is neither acting nor finishing, so the turn is interrupted.
+ *
+ * This is the sibling STALL_GUARD_* cannot cover. That counter keys on
+ * `messageId` so a message streamed as a burst of deltas counts once - correct,
+ * and the reason it reads 1 for a *single* runaway generation. In the
+ * "unbounded tool-call announcement" incident the model produced 66,384
+ * characters inside one completion over 5m40s, never emitting a stop token and
+ * never emitting a tool call; the run ended only because the user typed
+ * /compact. Counting characters within the round is what catches that shape.
+ *
+ * Structural, not textual: it measures how much was produced, never what was
+ * said. Reasoning/thinking text is deliberately excluded - high-effort thinking
+ * is legitimately long, and the degeneration this bounds is in content.
+ *
+ * The default is far above any real answer (roughly 8K tokens of prose in one
+ * round), so it is a safety valve rather than a style limit. `0` disables it.
+ */
+export declare const MAX_ROUND_TEXT_CHARS_DEFAULT = 32000;
+export declare const MAX_ROUND_TEXT_CHARS_MIN = 2000;
+export declare const MAX_ROUND_TEXT_CHARS_MAX = 2000000;
 /**
  * Compaction tuning for providers whose conversation the daemon owns
  * (openai-compat). These set the provider-level defaults; the per-agent
@@ -273,6 +333,19 @@ export declare const ProviderCompactionConfigSchema: z.ZodObject<{
     hideSelector: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ProviderCompactionConfig = z.infer<typeof ProviderCompactionConfigSchema>;
+/**
+ * Action circuit-breaker tuning for daemon-hosted tool loops (openai-compat /
+ * Otto Brain). When enabled, an action that fails `threshold` times in a row
+ * (same tool name + same arguments) stops being executed for the rest of the
+ * round, and the model receives a repair prompt instead of a dead-end error.
+ * Omitted or `enabled: false` keeps the historical behavior: every tool call
+ * the model emits is executed, failures and all.
+ */
+export declare const ProviderActionBreakerConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ProviderActionBreakerConfig = z.infer<typeof ProviderActionBreakerConfigSchema>;
 export declare const ProviderOverrideSchema: z.ZodObject<{
     extends: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
@@ -306,13 +379,13 @@ export declare const ProviderOverrideSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     ottoToolGroups: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        artifacts: "artifacts";
         preview: "preview";
         browser: "browser";
         web: "web";
         agents: "agents";
         terminals: "terminals";
         schedules: "schedules";
+        artifacts: "artifacts";
         widgets: "widgets";
         workspace: "workspace";
     }>>>;
@@ -345,6 +418,12 @@ export declare const ProviderOverrideSchema: z.ZodObject<{
         hideSelector: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     maxToolRounds: z.ZodOptional<z.ZodNumber>;
+    actionBreaker: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    maxRoundTextChars: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodNumber]>>;
+    midSessionContextUpdates: z.ZodOptional<z.ZodBoolean>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     order: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -381,13 +460,13 @@ export declare const ProviderOverridesSchema: z.ZodRecord<z.ZodString, z.ZodObje
     }, z.core.$strip>>>;
     disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     ottoToolGroups: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        artifacts: "artifacts";
         preview: "preview";
         browser: "browser";
         web: "web";
         agents: "agents";
         terminals: "terminals";
         schedules: "schedules";
+        artifacts: "artifacts";
         widgets: "widgets";
         workspace: "workspace";
     }>>>;
@@ -420,6 +499,12 @@ export declare const ProviderOverridesSchema: z.ZodRecord<z.ZodString, z.ZodObje
         hideSelector: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     maxToolRounds: z.ZodOptional<z.ZodNumber>;
+    actionBreaker: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    maxRoundTextChars: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodNumber]>>;
+    midSessionContextUpdates: z.ZodOptional<z.ZodBoolean>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     order: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>>;

package/dist/provider-config.js

@@ -221,6 +221,66 @@ export const COMPACTION_THRESHOLD_PERCENTS = [50, 60, 70, 80, 90];
 export const MAX_TOOL_ROUNDS_DEFAULT = 50;
 export const MAX_TOOL_ROUNDS_MIN = 1;
 export const MAX_TOOL_ROUNDS_MAX = 1000;
+/**
+ * Action circuit-breaker for daemon-hosted tool loops (openai-compat /
+ * Otto Brain). When enabled, an action (tool name + exact arguments) that
+ * fails this many times in a row stops being executed: the rest of the
+ * round's identical calls are dropped, and a repair prompt is sent to the
+ * model explaining what failed and how to change course. Small local models
+ * can degenerate into emitting the same broken action hundreds of times per
+ * round (the 2,912-call browser_navigate({}) incident); without the breaker
+ * each identical failure is appended to the conversation verbatim until the
+ * context window is blown and the turn dies. Defaults are safe for every
+ * model; bounds keep the setting a guard rail, not an off switch.
+ */
+export const ACTION_BREAKER_DEFAULT_THRESHOLD = 5;
+export const ACTION_BREAKER_MIN_THRESHOLD = 2;
+export const ACTION_BREAKER_MAX_THRESHOLD = 100;
+/**
+ * Tool-emission stall guard (daemon-wide, provider-agnostic). A healthy agent
+ * turn either acts - it emits a tool call - or it hands back to the human. An
+ * assistant message that does neither has no side effect, so a run that only
+ * produces those is not working, it is stuck. This is the count of consecutive
+ * such messages tolerated before the daemon interrupts the run.
+ *
+ * Purely structural: it counts stream events, never their text. A tool call
+ * resets it to zero, so a long working loop (a 200-turn investigation with a
+ * tool call every few turns) can never trip it; so does a real user prompt, so
+ * ordinary back-and-forth chat can never trip it either.
+ *
+ * `0` disables the guard. Bounds keep the setting a guard rail rather than a
+ * hair trigger. See agent-stall-guard.ts and the "unbounded tool-call
+ * announcement" finding: a local model emitted ~840 consecutive text-only
+ * messages over five minutes, re-announcing three tool calls it never sent, and
+ * nothing in the runtime noticed.
+ */
+export const STALL_GUARD_DEFAULT_THRESHOLD = 15;
+export const STALL_GUARD_MIN_THRESHOLD = 3;
+export const STALL_GUARD_MAX_THRESHOLD = 500;
+/**
+ * Per-round assistant-text budget for daemon-hosted tool loops (openai-compat /
+ * Otto Brain). The same invariant the stall guard enforces across messages, held
+ * *within* one: a model round that has streamed this much prose while emitting
+ * no tool call is neither acting nor finishing, so the turn is interrupted.
+ *
+ * This is the sibling STALL_GUARD_* cannot cover. That counter keys on
+ * `messageId` so a message streamed as a burst of deltas counts once - correct,
+ * and the reason it reads 1 for a *single* runaway generation. In the
+ * "unbounded tool-call announcement" incident the model produced 66,384
+ * characters inside one completion over 5m40s, never emitting a stop token and
+ * never emitting a tool call; the run ended only because the user typed
+ * /compact. Counting characters within the round is what catches that shape.
+ *
+ * Structural, not textual: it measures how much was produced, never what was
+ * said. Reasoning/thinking text is deliberately excluded - high-effort thinking
+ * is legitimately long, and the degeneration this bounds is in content.
+ *
+ * The default is far above any real answer (roughly 8K tokens of prose in one
+ * round), so it is a safety valve rather than a style limit. `0` disables it.
+ */
+export const MAX_ROUND_TEXT_CHARS_DEFAULT = 32000;
+export const MAX_ROUND_TEXT_CHARS_MIN = 2000;
+export const MAX_ROUND_TEXT_CHARS_MAX = 2000000;
 /**
  * Compaction tuning for providers whose conversation the daemon owns
  * (openai-compat). These set the provider-level defaults; the per-agent
@@ -244,6 +304,28 @@ export const ProviderCompactionConfigSchema = z.object({
      */
     hideSelector: z.boolean().optional(),
 });
+/**
+ * Action circuit-breaker tuning for daemon-hosted tool loops (openai-compat /
+ * Otto Brain). When enabled, an action that fails `threshold` times in a row
+ * (same tool name + same arguments) stops being executed for the rest of the
+ * round, and the model receives a repair prompt instead of a dead-end error.
+ * Omitted or `enabled: false` keeps the historical behavior: every tool call
+ * the model emits is executed, failures and all.
+ */
+export const ProviderActionBreakerConfigSchema = z.object({
+    /** false (default) disables the breaker; true enables it. */
+    enabled: z.boolean().optional(),
+    /**
+     * Consecutive identical failures before the breaker trips.
+     * Default ACTION_BREAKER_DEFAULT_THRESHOLD (5), clamped to [MIN, MAX].
+     */
+    threshold: z
+        .number()
+        .int()
+        .min(ACTION_BREAKER_MIN_THRESHOLD)
+        .max(ACTION_BREAKER_MAX_THRESHOLD)
+        .optional(),
+});
 export const ProviderOverrideSchema = z.object({
     extends: z.string().optional(),
     label: z.string().optional(),
@@ -276,6 +358,34 @@ export const ProviderOverrideSchema = z.object({
      * (openai-compat). Omitted = the built-in default (MAX_TOOL_ROUNDS_DEFAULT).
      */
     maxToolRounds: z.number().int().min(MAX_TOOL_ROUNDS_MIN).max(MAX_TOOL_ROUNDS_MAX).optional(),
+    /**
+     * Action circuit-breaker for daemon-hosted tool loops (openai-compat /
+     * Otto Brain). Stops a repeatedly-failing identical action and repairs
+     * instead of re-executing it. Omitted = disabled (historical behavior).
+     */
+    actionBreaker: ProviderActionBreakerConfigSchema.optional(),
+    /**
+     * Assistant-text budget for one model round (openai-compat / Otto Brain).
+     * A round that streams past this many characters without emitting a tool call
+     * interrupts the turn. Omitted = MAX_ROUND_TEXT_CHARS_DEFAULT; `0` disables.
+     */
+    maxRoundTextChars: z
+        .union([
+        z.literal(0),
+        z.number().int().min(MAX_ROUND_TEXT_CHARS_MIN).max(MAX_ROUND_TEXT_CHARS_MAX),
+    ])
+        .optional(),
+    /**
+     * Whether the daemon-hosted tool loop (openai-compat / Otto Brain) may add
+     * context to a conversation after it has started. Today that is the
+     * subdirectory instruction file loaded when the agent first touches a subtree;
+     * anything else the loop wants to inject mid-conversation rides under the same
+     * switch. Omitted = true (the shipped behavior). Turn it off for a small local
+     * context window, where a few thousand tokens arriving unannounced mid-task
+     * costs more than the rules are worth. Providers whose conversation Otto does
+     * not own (every ACP/CLI provider) are unaffected either way.
+     */
+    midSessionContextUpdates: z.boolean().optional(),
     enabled: z.boolean().optional(),
     order: z.number().optional(),
 });