@otto-code/protocol 0.5.0 → 0.5.2

package/dist/messages.js

@@ -133,13 +133,17 @@ export const MutableGitHostingConfigSchema = z
     .passthrough();
 // Canonical personality roles, in display order. Kept as an exported const so
 // the daemon and app share one vocabulary, but the wire schema stores roles as
-// plain strings (below) — adding an 8th role later must never break an older
-// peer's parsing. Consumers filter incoming role arrays to this known set.
+// plain strings (below) — adding a role later must never break an older peer's
+// parsing. Consumers filter incoming role arrays to this known set. The retired
+// "worker" role is mapped to "coder" on the way in (see LEGACY_ROLE_ALIASES in
+// agent-personalities.ts) so personalities persisted before the split keep their
+// role rather than silently losing it.
 export const PERSONALITY_ROLES = [
     "chatter",
     "artificer",
     "scheduler",
-    "worker",
+    "writer",
+    "coder",
     "judger",
     "advisor",
     "orchestrator",
@@ -194,6 +198,75 @@ const MutableAgentPersonalitiesConfigSchema = z
     personalities: z.array(AgentPersonalitySchema).default([]),
 })
     .passthrough();
+// Patch shape declared explicitly rather than via .partial(): partial() keeps
+// the personalities .default([]), so a patch touching the section without an
+// explicit personalities array would have an empty array injected and
+// deep-merge would wipe the stored roster.
+const MutableAgentPersonalitiesConfigPatchSchema = z
+    .object({
+    personalities: z.array(AgentPersonalitySchema).optional(),
+})
+    .passthrough();
+// A team's avatar. v1 ships only `color` (hex, validated at the editor like
+// spinner colors); `imageId` is reserved for the future themed avatar set —
+// when present it wins over color, and color stays the fallback so an old
+// client that doesn't know `imageId` keeps rendering the swatch. Plain
+// strings for forward compat.
+const AgentTeamAvatarSchema = z
+    .object({
+    color: z.string().min(1).optional(),
+    imageId: z.string().min(1).optional(),
+})
+    .passthrough();
+// A named, per-host grouping of agent personalities that acts as an operating
+// template: which personalities are on deck, plus a shared team prompt stacked
+// directly ahead of the member's personality prompt at spawn. `id` is the
+// stable identity everything binds to; `name` is a freely-renamable label.
+// `memberIds` bind personality ids (order = display order) — an entry pointing
+// at a deleted personality is tolerated and ignored everywhere, then pruned on
+// the next save of that team. Membership is many-to-many.
+export const AgentTeamSchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    avatar: AgentTeamAvatarSchema.optional(),
+    teamPrompt: z.string().optional(),
+    memberIds: z.array(z.string().min(1)).optional(),
+})
+    .passthrough();
+const MutableAgentTeamsConfigSchema = z
+    .object({
+    teams: z.array(AgentTeamSchema).default([]),
+    // The host's active team id; null/absent = no team active (exactly legacy
+    // behavior). Host-scoped daemon config rather than device-local: the team
+    // prompt is applied daemon-side at spawn, so headless spawns (MCP
+    // create_agent, schedule runs) must see it, and a patch from any client
+    // hot-reloads the switch to every connected client.
+    activeTeamId: z.string().nullable().optional(),
+})
+    .passthrough();
+// Patch shape declared explicitly rather than via .partial(): partial() keeps
+// the teams .default([]), so a patch that only touches activeTeamId would have
+// an empty array injected and deep-merge would wipe the stored teams.
+const MutableAgentTeamsConfigPatchSchema = z
+    .object({
+    teams: z.array(AgentTeamSchema).optional(),
+    activeTeamId: z.string().nullable().optional(),
+})
+    .passthrough();
+export const ModelTierSchema = z.enum(["deep", "standard", "fast"]);
+// A user's explicit tier tag for one model of one provider. The daemon stamps
+// `model.tier` at ingest, preferring a matching override here over inference
+// (see model-tiers.ts). Stored as an array (not a nested record) so a patch
+// replaces it wholesale — that's how a tag gets cleared, since deep-merge can't
+// delete a record key.
+export const ModelTierOverrideSchema = z
+    .object({
+    provider: z.string().min(1),
+    modelId: z.string().min(1),
+    tier: ModelTierSchema,
+})
+    .passthrough();
 export const MutableDaemonConfigSchema = z
     .object({
     mcp: z
@@ -216,6 +289,14 @@ export const MutableDaemonConfigSchema = z
     // feature; defaults to an empty roster so a new client parsing an old
     // daemon's config still sees a well-formed section.
     agentPersonalities: MutableAgentPersonalitiesConfigSchema.default({ personalities: [] }),
+    // Per-host agent teams + the active team id. Gated by the agentTeams
+    // feature; defaults to an empty section so a new client parsing an old
+    // daemon's config still sees a well-formed shape.
+    agentTeams: MutableAgentTeamsConfigSchema.default({ teams: [] }),
+    // Per-host user overrides of model tiers, keyed by provider + model id.
+    // Gated by the modelTierOverrides feature; defaults empty so a new client
+    // parsing an old daemon's config still sees a well-formed array.
+    modelTierOverrides: z.array(ModelTierOverrideSchema).default([]),
 })
     .passthrough();
 export const MutableDaemonConfigPatchSchema = z
@@ -241,7 +322,14 @@ export const MutableDaemonConfigPatchSchema = z
     // Gated by server_info features.agentPersonalities. A patch replaces the
     // full roster (read-modify-write the array), matching how terminalProfiles
     // and metadataGeneration.providers patch.
-    agentPersonalities: MutableAgentPersonalitiesConfigSchema.partial().optional(),
+    agentPersonalities: MutableAgentPersonalitiesConfigPatchSchema.optional(),
+    // Gated by server_info features.agentTeams. A `teams` patch replaces the
+    // full array (read-modify-write), matching agentPersonalities;
+    // `activeTeamId: null` deactivates the team without touching the array.
+    agentTeams: MutableAgentTeamsConfigPatchSchema.optional(),
+    // Gated by server_info features.modelTierOverrides. Replaces the full array
+    // (read-modify-write), so removing an entry clears that model's tag.
+    modelTierOverrides: z.array(ModelTierOverrideSchema).optional(),
 })
     .partial()
     .passthrough();
@@ -304,6 +392,12 @@ const AgentModelDefinitionSchema = z.object({
     contextWindowMaxTokens: z.number().optional(),
     thinkingOptions: z.array(AgentSelectOptionSchema).optional(),
     defaultThinkingOptionId: z.string().optional(),
+    // Daemon-stamped capability tier (deep/standard/fast). Optional: absent on old
+    // daemons and on models neither classified nor user-tagged.
+    tier: ModelTierSchema.optional(),
+    // False when the model can't run the provider's "auto" permission mode.
+    // Optional: absent on old daemons and when supported/unknown.
+    supportsAutoMode: z.boolean().optional(),
 });
 export const ProviderSnapshotEntrySchema = z.object({
     provider: AgentProviderSchema,
@@ -689,6 +783,13 @@ export const AgentSnapshotPayloadSchema = z.object({
     persistence: AgentPersistenceHandleSchema.nullable(),
     runtimeInfo: AgentRuntimeInfoSchema.optional(),
     lastUsage: AgentUsageSchema.optional(),
+    // Honest cumulative token total (Σ across the whole run) from the provider,
+    // for the subagents-track cost readout — the only currency that works for
+    // cost-less local models. Observed subagents source it from the provider's
+    // per-task usage.total_tokens (already cumulative-per-subagent). Purely
+    // additive; absent ⇒ no readout. Old clients ignore it.
+    // See projects/subagents-cleanup/subagents-cleanup.md (Item 3).
+    cumulativeTokens: z.number().optional(),
     lastError: z.string().optional(),
     title: z.string().nullable(),
     labels: z.record(z.string(), z.string()).default({}),
@@ -1483,6 +1584,78 @@ export const CheckoutCommitRequestSchema = z.object({
     addAll: z.boolean().optional(),
     requestId: z.string(),
 });
+// One entry in a git operation log (the "Git Commit"/"Git Push" log panes).
+// `seq` is a per-(cwd, operation) monotonic counter used for client-side
+// dedup between backfill and live pushes.
+export const GitOperationLogEntrySchema = z.object({
+    seq: z.number(),
+    timestamp: z.string(),
+    level: z.enum(["info", "output", "error"]),
+    text: z.string(),
+});
+// Backfill for a git operation log pane. `operation` is an open string on the
+// wire ("commit" | "pull" | "push" today) so newly watchable operations don't
+// break old peers. Gated by server_info.features.checkoutGitLog.
+export const CheckoutGitGetOperationLogRequestSchema = z.object({
+    type: z.literal("checkout.git.get_operation_log.request"),
+    cwd: z.string(),
+    operation: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutGitGetOperationLogResponseSchema = z.object({
+    type: z.literal("checkout.git.get_operation_log.response"),
+    payload: z.object({
+        cwd: z.string(),
+        operation: z.string(),
+        entries: z.array(GitOperationLogEntrySchema),
+        requestId: z.string(),
+    }),
+});
+// Live append notification, broadcast to connected clients while a watched git
+// operation runs. Carries only the appended entries; `seq` orders them against
+// the backfill.
+export const CheckoutGitLogAppendedNotificationSchema = z.object({
+    type: z.literal("checkout.git.log_appended.notification"),
+    payload: z.object({
+        cwd: z.string(),
+        operation: z.string(),
+        entries: z.array(GitOperationLogEntrySchema),
+    }),
+});
+// Namespaced successor to checkout_commit_request: per-file selection and
+// structured errors. Gated by server_info.features.checkoutGitCommit; the flat
+// RPC stays accepted for old clients.
+export const CheckoutGitCommitRequestSchema = z.object({
+    type: z.literal("checkout.git.commit.request"),
+    cwd: z.string(),
+    message: z.string(),
+    // Repo-relative paths to stage and commit. Only these paths land in the
+    // commit, even if other changes are already staged.
+    paths: z.array(z.string()),
+    // Set after the user confirms committing while agents are running in this
+    // workspace; without it the daemon refuses with kind "agents_running".
+    allowWithRunningAgents: z.boolean().optional(),
+    requestId: z.string(),
+});
+// Resolve which agent the daemon would use to author a commit message for this
+// checkout (the "writer" role) so the client can name it in a confirmation
+// before running the AI-authored commit. A pure query — it never commits. Gated
+// by server_info.features.checkoutGitCommitAgent.
+export const CheckoutGitCommitAgentRequestSchema = z.object({
+    type: z.literal("checkout.git.commit_agent.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+// Discard uncommitted working-tree changes for specific repo-relative paths
+// (restore tracked files from HEAD, delete newly-added files). Gated by
+// server_info.features.checkoutGitRollback.
+export const CheckoutGitRollbackRequestSchema = z.object({
+    type: z.literal("checkout.git.rollback.request"),
+    cwd: z.string(),
+    // Repo-relative paths whose uncommitted changes should be discarded.
+    paths: z.array(z.string()),
+    requestId: z.string(),
+});
 export const CheckoutMergeRequestSchema = z.object({
     type: z.literal("checkout_merge_request"),
     cwd: z.string(),
@@ -2170,6 +2343,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SubscribeCheckoutDiffRequestSchema,
     UnsubscribeCheckoutDiffRequestSchema,
     CheckoutCommitRequestSchema,
+    CheckoutGitCommitRequestSchema,
+    CheckoutGitCommitAgentRequestSchema,
+    CheckoutGitRollbackRequestSchema,
+    CheckoutGitGetOperationLogRequestSchema,
     CheckoutMergeRequestSchema,
     CheckoutMergeFromBaseRequestSchema,
     CheckoutPullRequestSchema,
@@ -2464,6 +2641,18 @@ export const ServerInfoStatusPayloadSchema = z
         ttsPreview: z.boolean().optional(),
         // COMPAT(setAgentPersonality): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
         setAgentPersonality: z.boolean().optional(),
+        // COMPAT(checkoutGitCommit): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitCommit: z.boolean().optional(),
+        // COMPAT(checkoutGitCommitAgent): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitCommitAgent: z.boolean().optional(),
+        // COMPAT(checkoutGitRollback): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitRollback: z.boolean().optional(),
+        // COMPAT(checkoutGitLog): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitLog: z.boolean().optional(),
+        // COMPAT(agentTeams): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
+        agentTeams: z.boolean().optional(),
+        // COMPAT(modelTierOverrides): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
+        modelTierOverrides: z.boolean().optional(),
     })
         .optional(),
 })
@@ -3021,6 +3210,11 @@ export const CancelAgentResponseMessageSchema = z.object({
         requestId: z.string(),
         agentId: z.string(),
         agent: AgentSnapshotPayloadSchema.nullable(),
+        // Whether an in-flight run was actually interrupted. False when the agent
+        // had nothing running (already finished, still initializing), so clients
+        // can say "nothing to stop" instead of silently no-oping. Purely additive;
+        // absent ⇒ unknown (old daemon). See projects/subagents-cleanup/subagents-cleanup.md (Item 2).
+        cancelled: z.boolean().optional(),
     }),
 });
 export const ClearAgentAttentionResponseMessageSchema = z.object({
@@ -3495,6 +3689,101 @@ export const CheckoutCommitResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+const CheckoutGitCommitRunningAgentSchema = z.object({
+    id: z.string(),
+    title: z.string().nullable(),
+});
+export const CheckoutGitCommitErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("agents_running"),
+        agents: z.array(CheckoutGitCommitRunningAgentSchema),
+    }),
+    z.object({
+        kind: z.literal("identity_missing"),
+        missingName: z.boolean(),
+        missingEmail: z.boolean(),
+    }),
+    z.object({
+        kind: z.literal("hook_failed"),
+        output: z.string(),
+        exitCode: z.number().nullable(),
+    }),
+    z.object({
+        kind: z.literal("signing_failed"),
+        detail: z.string(),
+    }),
+    z.object({
+        kind: z.literal("nothing_to_commit"),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+]);
+export const CheckoutGitCommitResponseSchema = z.object({
+    type: z.literal("checkout.git.commit.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        commitSha: z.string().nullable(),
+        error: CheckoutGitCommitErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+// The agent the daemon resolved to author a commit message. "personality" when
+// an available role-matched Agent Personality wins the mini-task routing (its
+// name plus the bound provider/model); "provider" when a bare provider/model is
+// used instead; "none" when nothing is configured to run the task, in which case
+// the client refuses the AI commit rather than falling back to placeholder text.
+export const CommitMessageAgentSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("personality"),
+        personalityId: z.string(),
+        personalityName: z.string(),
+        provider: z.string(),
+        providerLabel: z.string(),
+        model: z.string().nullable(),
+        modelLabel: z.string().nullable(),
+    }),
+    z.object({
+        kind: z.literal("provider"),
+        provider: z.string(),
+        providerLabel: z.string(),
+        model: z.string().nullable(),
+        modelLabel: z.string().nullable(),
+    }),
+    z.object({
+        kind: z.literal("none"),
+    }),
+]);
+export const CheckoutGitCommitAgentResponseSchema = z.object({
+    type: z.literal("checkout.git.commit_agent.response"),
+    payload: z.object({
+        cwd: z.string(),
+        agent: CommitMessageAgentSchema,
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGitRollbackErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("nothing_to_rollback"),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+]);
+export const CheckoutGitRollbackResponseSchema = z.object({
+    type: z.literal("checkout.git.rollback.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        // Repo-relative paths whose changes were discarded.
+        rolledBackPaths: z.array(z.string()),
+        error: CheckoutGitRollbackErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
 export const CheckoutMergeResponseSchema = z.object({
     type: z.literal("checkout_merge_response"),
     payload: z.object({
@@ -4535,6 +4824,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SubscribeCheckoutDiffResponseSchema,
     CheckoutDiffUpdateSchema,
     CheckoutCommitResponseSchema,
+    CheckoutGitCommitResponseSchema,
+    CheckoutGitCommitAgentResponseSchema,
+    CheckoutGitRollbackResponseSchema,
+    CheckoutGitGetOperationLogResponseSchema,
+    CheckoutGitLogAppendedNotificationSchema,
     CheckoutMergeResponseSchema,
     CheckoutMergeFromBaseResponseSchema,
     CheckoutPullResponseSchema,

package/dist/model-tiers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Model → tier classification, shared by the daemon (stamps `model.tier` at
+ * ingest) and the app (reads `model.tier`). Pure and dependency-free — no zod,
+ * no I/O.
+ *
+ * Deliberately NO name-pattern guessing: the official model ids are public
+ * record, so we classify what we KNOW (the shipped catalog) and leave everything
+ * else `undefined` = "Unknown". Size-in-the-name heuristics are unreliable
+ * (a Qwen-32B coder ≠ a Qwen-32B instruct), so we don't pretend — the user tags
+ * an Unknown model with an override and that's it.
+ *
+ * Resolution order for a single model:
+ *   1. user override (a per-model tag persisted in host config),
+ *   2. the shipped catalog of known models,
+ * else undefined ("Unknown"). At generation the consumer's context-window
+ * heuristic still fills a slot so a team can bind, but that's a last resort, not
+ * a claim about the model's tier.
+ */
+import type { AgentModelDefinition, ModelTier } from "./agent-types.js";
+export declare const KNOWN_MODEL_TIERS: Readonly<Record<string, ModelTier>>;
+export declare function catalogTier(modelId: string): ModelTier | undefined;
+/**
+ * Infer a model's tier from the shipped catalog alone (no guessing). Undefined
+ * for models we don't ship an id for — those read as "Unknown" until the user
+ * tags one.
+ */
+export declare function inferModelTier(model: Pick<AgentModelDefinition, "id">): ModelTier | undefined;
+/**
+ * The tier to stamp on a model at ingest: an explicit user override wins,
+ * otherwise the catalog. Undefined ("Unknown") leaves the model tier-less until
+ * the user tags it; the consumer's generation heuristic still binds a slot.
+ */
+export declare function resolveModelTier(model: Pick<AgentModelDefinition, "id">, override: ModelTier | undefined): ModelTier | undefined;
+//# sourceMappingURL=model-tiers.d.ts.map

package/dist/model-tiers.js

@@ -0,0 +1,92 @@
+/**
+ * Model → tier classification, shared by the daemon (stamps `model.tier` at
+ * ingest) and the app (reads `model.tier`). Pure and dependency-free — no zod,
+ * no I/O.
+ *
+ * Deliberately NO name-pattern guessing: the official model ids are public
+ * record, so we classify what we KNOW (the shipped catalog) and leave everything
+ * else `undefined` = "Unknown". Size-in-the-name heuristics are unreliable
+ * (a Qwen-32B coder ≠ a Qwen-32B instruct), so we don't pretend — the user tags
+ * an Unknown model with an override and that's it.
+ *
+ * Resolution order for a single model:
+ *   1. user override (a per-model tag persisted in host config),
+ *   2. the shipped catalog of known models,
+ * else undefined ("Unknown"). At generation the consumer's context-window
+ * heuristic still fills a slot so a team can bind, but that's a last resort, not
+ * a claim about the model's tier.
+ */
+// Shipped catalog of known, official model ids (public record). Matched
+// case-insensitively against the exact model id; decorated ids that miss here
+// fall through to patterns.
+export const KNOWN_MODEL_TIERS = {
+    // Anthropic (Claude) — the full Claude Code manifest. Tiering rule: 1M-context
+    // Opus variants are "deep", non-1M Opus and Sonnet are "standard", Haiku is
+    // "fast". Fable (1M, most powerful) is "deep".
+    "claude-fable-5": "deep",
+    "claude-opus-4-8[1m]": "deep",
+    "claude-opus-4-8": "standard",
+    "claude-opus-4-7[1m]": "deep",
+    "claude-opus-4-7": "standard",
+    "claude-opus-4-6[1m]": "deep",
+    "claude-opus-4-6": "standard",
+    "claude-sonnet-5": "standard",
+    "claude-sonnet-4-6[1m]": "standard",
+    "claude-sonnet-4-6": "standard",
+    "claude-haiku-4-5": "fast",
+    "claude-haiku-4-5-20251001": "fast",
+    // OpenAI (GPT / o-series)
+    "gpt-5": "deep",
+    "gpt-5-mini": "fast",
+    "gpt-5-nano": "fast",
+    o3: "deep",
+    "o3-mini": "fast",
+    "o4-mini": "fast",
+    "gpt-4.1": "standard",
+    "gpt-4.1-mini": "fast",
+    "gpt-4o": "standard",
+    "gpt-4o-mini": "fast",
+    // Google (Gemini)
+    "gemini-2.5-pro": "deep",
+    "gemini-2.5-flash": "fast",
+    "gemini-2.5-flash-lite": "fast",
+    "gemini-2.0-flash": "fast",
+    // DeepSeek
+    "deepseek-r1": "deep",
+    "deepseek-v3": "deep",
+    "deepseek-chat": "standard",
+    "deepseek-reasoner": "deep",
+    // Alibaba (Qwen) hosted tiers
+    "qwen-max": "deep",
+    "qwen-plus": "standard",
+    "qwen-turbo": "fast",
+    // xAI (Grok)
+    "grok-4": "deep",
+    "grok-3": "deep",
+    "grok-3-mini": "fast",
+    // Mistral
+    "mistral-large-latest": "deep",
+    "mistral-large": "deep",
+    "mistral-medium": "standard",
+    "mistral-small": "fast",
+};
+export function catalogTier(modelId) {
+    return KNOWN_MODEL_TIERS[modelId.toLowerCase()];
+}
+/**
+ * Infer a model's tier from the shipped catalog alone (no guessing). Undefined
+ * for models we don't ship an id for — those read as "Unknown" until the user
+ * tags one.
+ */
+export function inferModelTier(model) {
+    return catalogTier(model.id);
+}
+/**
+ * The tier to stamp on a model at ingest: an explicit user override wins,
+ * otherwise the catalog. Undefined ("Unknown") leaves the model tier-less until
+ * the user tags it; the consumer's generation heuristic still binds a slot.
+ */
+export function resolveModelTier(model, override) {
+    return override ?? inferModelTier(model);
+}
+//# sourceMappingURL=model-tiers.js.map

package/dist/provider-manifest.js

@@ -28,6 +28,17 @@ const CLAUDE_MODES = [
         icon: "LocalPolice",
         colorTier: "moderate",
     },
+    {
+        id: "dontAsk",
+        label: "Don't Ask",
+        description: "Runs without prompting — actions not pre-approved are denied",
+        // Guarded unattended mode: more dangerous than acceptEdits (edits only) but
+        // safer than bypass (deny-by-default vs. run-everything), so it sits at the
+        // "moderate" tier alongside Auto.
+        icon: "ShieldCheck",
+        colorTier: "moderate",
+        isUnattended: true,
+    },
     {
         id: "bypassPermissions",
         label: "Bypass",

package/dist/schedule/rpc-schemas.d.ts

@@ -100,6 +100,7 @@ export declare const ScheduleUpdateRequestSchema: z.ZodObject<{
     }, z.core.$strip>], "type">>;
     newAgentConfig: z.ZodOptional<z.ZodObject<{
         provider: z.ZodOptional<z.ZodString>;
+        personality: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         modeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         thinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -118,6 +119,7 @@ export declare const ScheduleCreateResponseSchema: z.ZodObject<{
     payload: z.ZodObject<{
         requestId: z.ZodString;
         schedule: z.ZodNullable<z.ZodObject<{
+            prompt: z.ZodString;
             name: z.ZodNullable<z.ZodString>;
             status: z.ZodEnum<{
                 completed: "completed";
@@ -166,7 +168,6 @@ export declare const ScheduleCreateResponseSchema: z.ZodObject<{
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">;
-            prompt: z.ZodString;
             nextRunAt: z.ZodNullable<z.ZodString>;
             lastRunAt: z.ZodNullable<z.ZodString>;
             lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
@@ -186,6 +187,7 @@ export declare const ScheduleListResponseSchema: z.ZodObject<{
     payload: z.ZodObject<{
         requestId: z.ZodString;
         schedules: z.ZodArray<z.ZodObject<{
+            prompt: z.ZodString;
             name: z.ZodNullable<z.ZodString>;
             status: z.ZodEnum<{
                 completed: "completed";
@@ -234,7 +236,6 @@ export declare const ScheduleListResponseSchema: z.ZodObject<{
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">;
-            prompt: z.ZodString;
             nextRunAt: z.ZodNullable<z.ZodString>;
             lastRunAt: z.ZodNullable<z.ZodString>;
             lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
@@ -359,6 +360,7 @@ export declare const SchedulePauseResponseSchema: z.ZodObject<{
     payload: z.ZodObject<{
         requestId: z.ZodString;
         schedule: z.ZodNullable<z.ZodObject<{
+            prompt: z.ZodString;
             name: z.ZodNullable<z.ZodString>;
             status: z.ZodEnum<{
                 completed: "completed";
@@ -407,7 +409,6 @@ export declare const SchedulePauseResponseSchema: z.ZodObject<{
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">;
-            prompt: z.ZodString;
             nextRunAt: z.ZodNullable<z.ZodString>;
             lastRunAt: z.ZodNullable<z.ZodString>;
             lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
@@ -427,6 +428,7 @@ export declare const ScheduleResumeResponseSchema: z.ZodObject<{
     payload: z.ZodObject<{
         requestId: z.ZodString;
         schedule: z.ZodNullable<z.ZodObject<{
+            prompt: z.ZodString;
             name: z.ZodNullable<z.ZodString>;
             status: z.ZodEnum<{
                 completed: "completed";
@@ -475,7 +477,6 @@ export declare const ScheduleResumeResponseSchema: z.ZodObject<{
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">;
-            prompt: z.ZodString;
             nextRunAt: z.ZodNullable<z.ZodString>;
             lastRunAt: z.ZodNullable<z.ZodString>;
             lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{

package/dist/schedule/rpc-schemas.js

@@ -62,6 +62,9 @@ export const ScheduleRunOnceRequestSchema = z.object({
 });
 const ScheduleUpdateNewAgentConfigSchema = z.object({
     provider: z.string().trim().min(1).optional(),
+    // Personality binding by name — or the "@team-scheduler" sentinel. Explicit
+    // null clears a stored binding; omission leaves it untouched.
+    personality: z.string().trim().min(1).nullable().optional(),
     model: z.string().trim().min(1).nullable().optional(),
     modeId: z.string().trim().min(1).nullable().optional(),
     thinkingOptionId: z.string().trim().min(1).nullable().optional(),

package/dist/schedule/types.d.ts

@@ -140,6 +140,7 @@ export declare const StoredScheduleSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type StoredSchedule = z.infer<typeof StoredScheduleSchema>;
 export declare const ScheduleSummarySchema: z.ZodObject<{
+    prompt: z.ZodString;
     name: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<{
         completed: "completed";
@@ -188,7 +189,6 @@ export declare const ScheduleSummarySchema: z.ZodObject<{
             mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
     }, z.core.$strip>], "type">;
-    prompt: z.ZodString;
     nextRunAt: z.ZodNullable<z.ZodString>;
     lastRunAt: z.ZodNullable<z.ZodString>;
     lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{