@otto-code/protocol 0.5.1 → 0.5.4

package/dist/orchestration.d.ts

@@ -0,0 +1,152 @@
+import { z } from "zod";
+export declare const RUN_PHASE_TYPES: readonly ["research", "plan", "refactor", "implement", "design", "verify", "gate", "deliver"];
+export type RunPhaseType = (typeof RUN_PHASE_TYPES)[number];
+export declare function isRunPhaseType(value: string): value is RunPhaseType;
+/** The role a phase type dispatches to by default (null for human `gate`). */
+export declare function defaultRoleForPhaseType(type: RunPhaseType): string | null;
+export declare const RUN_PHASE_STATUSES: readonly ["pending", "running", "blocked", "done", "failed", "skipped"];
+export type RunPhaseStatus = (typeof RUN_PHASE_STATUSES)[number];
+export declare const RUN_STATUSES: readonly ["pending", "running", "paused", "done", "failed", "canceled"];
+export type RunStatus = (typeof RUN_STATUSES)[number];
+export declare function isRunPhaseStatus(value: string): value is RunPhaseStatus;
+export declare function isRunStatus(value: string): value is RunStatus;
+/** Terminal run statuses — no further phases will run. */
+export declare function isTerminalRunStatus(value: string): boolean;
+/** Terminal phase statuses — the phase will not change again on its own. */
+export declare function isTerminalPhaseStatus(value: string): boolean;
+export declare const RunPhaseJudgeSpecSchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodString>;
+    criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const RunPhaseDeclarationSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    title: z.ZodString;
+    task: z.ZodString;
+    role: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fanOut: z.ZodOptional<z.ZodNumber>;
+    keepBest: z.ZodOptional<z.ZodNumber>;
+    judge: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type RunPhaseDeclaration = z.infer<typeof RunPhaseDeclarationSchema>;
+export declare const RunPlanSchema: z.ZodObject<{
+    title: z.ZodString;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    autopilot: z.ZodOptional<z.ZodBoolean>;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        title: z.ZodString;
+        task: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fanOut: z.ZodOptional<z.ZodNumber>;
+        keepBest: z.ZodOptional<z.ZodNumber>;
+        judge: z.ZodOptional<z.ZodObject<{
+            role: z.ZodOptional<z.ZodString>;
+            criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type RunPlan = z.infer<typeof RunPlanSchema>;
+export declare const RunPhaseCandidateSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    personalityId: z.ZodOptional<z.ZodString>;
+    verdict: z.ZodOptional<z.ZodObject<{
+        verdict: z.ZodString;
+        score: z.ZodOptional<z.ZodNumber>;
+        criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            met: z.ZodBoolean;
+            evidence: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type RunPhaseCandidate = z.infer<typeof RunPhaseCandidateSchema>;
+export declare const RunPhaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    title: z.ZodString;
+    task: z.ZodString;
+    status: z.ZodString;
+    assigneeRole: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fanOut: z.ZodOptional<z.ZodNumber>;
+    keepBest: z.ZodOptional<z.ZodNumber>;
+    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        personalityId: z.ZodOptional<z.ZodString>;
+        verdict: z.ZodOptional<z.ZodObject<{
+            verdict: z.ZodString;
+            score: z.ZodOptional<z.ZodNumber>;
+            criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                met: z.ZodBoolean;
+                evidence: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    notes: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type RunPhase = z.infer<typeof RunPhaseSchema>;
+export declare const RunSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    autopilot: z.ZodOptional<z.ZodBoolean>;
+    phases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        title: z.ZodString;
+        task: z.ZodString;
+        status: z.ZodString;
+        assigneeRole: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fanOut: z.ZodOptional<z.ZodNumber>;
+        keepBest: z.ZodOptional<z.ZodNumber>;
+        candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agentId: z.ZodString;
+            personalityId: z.ZodOptional<z.ZodString>;
+            verdict: z.ZodOptional<z.ZodObject<{
+                verdict: z.ZodString;
+                score: z.ZodOptional<z.ZodNumber>;
+                criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    met: z.ZodBoolean;
+                    evidence: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>>;
+                summary: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        notes: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    conductorAgentId: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    teamName: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    summaryStatus: z.ZodOptional<z.ZodString>;
+    agentCount: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type Run = z.infer<typeof RunSchema>;
+export declare const RUN_SUMMARY_STATUSES: readonly ["pending", "ready", "failed"];
+export type RunSummaryStatus = (typeof RUN_SUMMARY_STATUSES)[number];
+//# sourceMappingURL=orchestration.d.ts.map

package/dist/orchestration.js

@@ -0,0 +1,199 @@
+import { z } from "zod";
+import { JudgeVerdictSchema } from "./judge-verdict.js";
+// The orchestration data model — a daemon-owned "Run": one execution of a
+// declared multi-agent plan, and its observable/resumable projection to clients.
+// See projects/agent-orchestration/agent-orchestration.md. This is Otto's
+// provider-agnostic answer to a harness "Workflow": the conductor (an
+// orchestrator-role agent) DECLARES the shape (typed phases, assignments, the
+// loop target) via `start_run`, and the daemon runtime drives control flow —
+// fan-out, gather-barrier, gate, loop — in code, so orchestrating is cheaper
+// than hand-tracking N agent ids across async notifications.
+//
+// Wire-forward-compat, per the protocol contract: every open vocabulary (phase
+// type, phase/run status) rides as a plain string leaf validated by a
+// normalizer, never a z.enum, so the daemon can grow the vocabulary without
+// breaking an older client's parse. Objects `.passthrough()`; no transforms.
+// ── The deterministic plan vocabulary ──────────────────────────────────────
+// Fixed phase types used by the runtime (NOT roles). The dispatcher maps a phase
+// type to the role that fills it: research→researcher, plan→planner,
+// refactor/implement→coder, design→designer, verify→judger, gate→human (no
+// agent), deliver→coder/writer.
+export const RUN_PHASE_TYPES = [
+    "research",
+    "plan",
+    "refactor",
+    "implement",
+    "design",
+    "verify",
+    "gate",
+    "deliver",
+];
+const PHASE_TYPE_SET = new Set(RUN_PHASE_TYPES);
+export function isRunPhaseType(value) {
+    return PHASE_TYPE_SET.has(value);
+}
+// The default role that fills each phase type. `gate` has no role — it's a human
+// approval point. `deliver` defaults to coder (a writer may cover small text
+// deliverables; the conductor can override per phase).
+const PHASE_TYPE_DEFAULT_ROLE = {
+    research: "researcher",
+    plan: "planner",
+    refactor: "coder",
+    implement: "coder",
+    design: "designer",
+    verify: "judger",
+    gate: null,
+    deliver: "coder",
+};
+/** The role a phase type dispatches to by default (null for human `gate`). */
+export function defaultRoleForPhaseType(type) {
+    return PHASE_TYPE_DEFAULT_ROLE[type];
+}
+// ── Phase + run status (open vocabularies, plain-string on the wire) ─────────
+export const RUN_PHASE_STATUSES = [
+    "pending",
+    "running",
+    "blocked", // a gate phase awaiting human approval
+    "done",
+    "failed",
+    "skipped",
+];
+export const RUN_STATUSES = [
+    "pending",
+    "running",
+    "paused", // stopped at an attended gate, awaiting the user
+    "done",
+    "failed",
+    "canceled",
+];
+const PHASE_STATUS_SET = new Set(RUN_PHASE_STATUSES);
+const RUN_STATUS_SET = new Set(RUN_STATUSES);
+export function isRunPhaseStatus(value) {
+    return PHASE_STATUS_SET.has(value);
+}
+export function isRunStatus(value) {
+    return RUN_STATUS_SET.has(value);
+}
+/** Terminal run statuses — no further phases will run. */
+export function isTerminalRunStatus(value) {
+    return value === "done" || value === "failed" || value === "canceled";
+}
+/** Terminal phase statuses — the phase will not change again on its own. */
+export function isTerminalPhaseStatus(value) {
+    return value === "done" || value === "failed" || value === "skipped";
+}
+// ── Declaration schema (the `start_run` input) ──────────────────────────────
+// What the conductor DECLARES. Kept minimal and schema-validated so a bad plan
+// is rejected at the tool boundary. `role` overrides the phase-type default;
+// `fanOut` spawns N parallel candidates; `judge` attaches a verify sub-step so a
+// making/research phase's output is graded and (with `keepBest`) looped until
+// enough candidates pass.
+export const RunPhaseJudgeSpecSchema = z
+    .object({
+    role: z.string().min(1).optional(),
+    criteria: z.array(z.string().min(1)).optional(),
+})
+    .passthrough();
+export const RunPhaseDeclarationSchema = z
+    .object({
+    // Caller-assigned id, referenced by other phases' `dependsOn`.
+    id: z.string().min(1),
+    type: z.string().min(1),
+    title: z.string().min(1),
+    // The instruction handed to the assigned agent(s) as their prompt.
+    task: z.string().min(1),
+    // Override the phase-type's default role (e.g. deliver→writer).
+    role: z.string().min(1).optional(),
+    // Phase ids that must reach a terminal state before this phase starts.
+    // Absent/empty ⇒ runs after the previous declared phase (linear default).
+    dependsOn: z.array(z.string().min(1)).optional(),
+    // Spawn N parallel candidates from the same task (different angles). 1 ⇒ solo.
+    fanOut: z.number().int().min(1).max(16).optional(),
+    // With a judge: keep the best N passers; if fewer pass, the runtime
+    // re-dispatches replacements until the target is met or a cap trips.
+    keepBest: z.number().int().min(1).max(16).optional(),
+    // Attach a structured-judge sub-step to a non-verify phase.
+    judge: RunPhaseJudgeSpecSchema.optional(),
+})
+    .passthrough();
+export const RunPlanSchema = z
+    .object({
+    title: z.string().min(1),
+    // Immutable acceptance criteria — the run is "not done until every one is
+    // met." Carried onto the Run and shown at gates.
+    requirements: z.array(z.string().min(1)).optional(),
+    // Attended by default: the run pauses at `gate` phases for the user.
+    // Autopilot runs straight through (eligibility enforced daemon-side).
+    autopilot: z.boolean().optional(),
+    phases: z.array(RunPhaseDeclarationSchema).min(1).max(64),
+})
+    .passthrough();
+// ── Projection schema (the Run the daemon persists + pushes to clients) ─────
+// One spawned candidate for a phase: the observable child agent plus, when the
+// phase judged it, that candidate's verdict.
+export const RunPhaseCandidateSchema = z
+    .object({
+    agentId: z.string().min(1),
+    // The personality that filled the role for this candidate, if resolved.
+    personalityId: z.string().min(1).optional(),
+    verdict: JudgeVerdictSchema.optional(),
+    // The candidate's final message (synthesis input); may be large — clients
+    // truncate for display.
+    summary: z.string().optional(),
+})
+    .passthrough();
+export const RunPhaseSchema = z
+    .object({
+    id: z.string().min(1),
+    type: z.string().min(1),
+    title: z.string().min(1),
+    task: z.string().min(1),
+    status: z.string().min(1),
+    // Resolved dispatch target. `assigneeRole` is what the type/override asked
+    // for; `candidates` are the spawned agents (>1 when fanned out).
+    assigneeRole: z.string().min(1).optional(),
+    dependsOn: z.array(z.string().min(1)).optional(),
+    fanOut: z.number().int().min(1).optional(),
+    keepBest: z.number().int().min(1).optional(),
+    candidates: z.array(RunPhaseCandidateSchema).optional(),
+    // Free-text runtime notes (why it blocked, which cap tripped, gap named).
+    notes: z.string().optional(),
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+})
+    .passthrough();
+export const RunSchema = z
+    .object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    status: z.string().min(1),
+    // Immutable requirements block (see RunPlan.requirements).
+    requirements: z.array(z.string().min(1)).optional(),
+    autopilot: z.boolean().optional(),
+    phases: z.array(RunPhaseSchema).default([]),
+    // The conductor agent that owns this run, and the workspace it runs in.
+    conductorAgentId: z.string().min(1).optional(),
+    cwd: z.string().optional(),
+    workspaceId: z.string().optional(),
+    // The team that was active when this run started (id for a stable filter key,
+    // name for display). Absent on runs started without an active team.
+    teamId: z.string().min(1).optional(),
+    teamName: z.string().min(1).optional(),
+    // Set when the run ends in failure or a cap trips.
+    error: z.string().optional(),
+    // AI-generated, human-readable summary of the whole run (from a Writer
+    // personality). `summaryStatus` is a plain-string, forward-compat leaf:
+    // "pending" (being generated), "ready", or "failed". Both absent on daemons
+    // or runs without the run-summary feature.
+    summary: z.string().optional(),
+    summaryStatus: z.string().optional(),
+    // Total child agents this run spawned (makers + judgers) — a complexity
+    // signal surfaced in the Runs display. Grows as the run executes.
+    agentCount: z.number().int().min(0).optional(),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+})
+    .passthrough();
+// Summary generation lifecycle (plain-string on the wire; see RunSchema.summaryStatus).
+export const RUN_SUMMARY_STATUSES = ["pending", "ready", "failed"];
+//# sourceMappingURL=orchestration.js.map

package/dist/provider-manifest.d.ts

@@ -8,6 +8,7 @@ export interface AgentModeVisuals {
 }
 export type AgentProviderModeDefinition = Omit<AgentMode, "icon" | "colorTier"> & AgentModeVisuals & {
     isUnattended?: boolean;
+    userSelectable?: boolean;
 };
 export interface AgentProviderDefinition {
     id: string;
@@ -30,5 +31,14 @@ export declare const AGENT_PROVIDER_IDS: string[];
 export declare const AgentProviderSchema: z.ZodString;
 export declare function isValidAgentProvider(value: string, validIds?: Iterable<string>): boolean;
 export declare function getUnattendedModeId(provider: string, definitions?: AgentProviderDefinition[]): string | undefined;
+/**
+ * Whether a user may pick this mode themselves. False only for modes explicitly
+ * flagged `userSelectable: false` in the static manifest (Claude "dontAsk") — a
+ * system-assigned mode that agents can run in but no one selects by hand. Unknown
+ * modes (dynamic/ACP, custom providers) default to selectable. The flag is a
+ * static property of the mode, so this always consults the built-in manifest
+ * rather than snapshot-derived definitions (which don't carry it).
+ */
+export declare function isUserSelectableMode(provider: string, modeId: string): boolean;
 export declare function getModeVisuals(provider: string, modeId: string, definitions: AgentProviderDefinition[]): AgentModeVisuals | undefined;
 //# sourceMappingURL=provider-manifest.d.ts.map

package/dist/provider-manifest.js

@@ -28,6 +28,21 @@ 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,
+        // System-assigned only: the coercion target for unattended runs and for Auto
+        // on models that can't run it (Haiku). Users never pick it — it's hidden from
+        // mode dropdowns and locks the control when it's an agent's active mode.
+        userSelectable: false,
+    },
     {
         id: "bypassPermissions",
         label: "Bypass",
@@ -217,6 +232,19 @@ export function getUnattendedModeId(provider, definitions = [
     const definition = definitions.find((entry) => entry.id === provider);
     return definition?.modes.find((mode) => mode.isUnattended)?.id;
 }
+/**
+ * Whether a user may pick this mode themselves. False only for modes explicitly
+ * flagged `userSelectable: false` in the static manifest (Claude "dontAsk") — a
+ * system-assigned mode that agents can run in but no one selects by hand. Unknown
+ * modes (dynamic/ACP, custom providers) default to selectable. The flag is a
+ * static property of the mode, so this always consults the built-in manifest
+ * rather than snapshot-derived definitions (which don't carry it).
+ */
+export function isUserSelectableMode(provider, modeId) {
+    const definition = [...AGENT_PROVIDER_DEFINITIONS, ...DEV_AGENT_PROVIDER_DEFINITIONS].find((entry) => entry.id === provider);
+    const mode = definition?.modes.find((entry) => entry.id === modeId);
+    return mode?.userSelectable !== false;
+}
 export function getModeVisuals(provider, modeId, definitions) {
     const definition = definitions.find((entry) => entry.id === provider);
     const mode = definition?.modes.find((m) => m.id === modeId);

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,13 +119,14 @@ 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>;
+            id: z.ZodString;
             status: z.ZodEnum<{
+                paused: "paused";
                 completed: "completed";
                 active: "active";
-                paused: "paused";
             }>;
-            id: z.ZodString;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -166,12 +168,11 @@ 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<{
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>>>;
             lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             pausedAt: z.ZodNullable<z.ZodString>;
@@ -186,13 +187,14 @@ 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>;
+            id: z.ZodString;
             status: z.ZodEnum<{
+                paused: "paused";
                 completed: "completed";
                 active: "active";
-                paused: "paused";
             }>;
-            id: z.ZodString;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -234,12 +236,11 @@ 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<{
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>>>;
             lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             pausedAt: z.ZodNullable<z.ZodString>;
@@ -297,17 +298,17 @@ export declare const ScheduleInspectResponseSchema: z.ZodObject<{
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">;
             status: z.ZodEnum<{
+                paused: "paused";
                 completed: "completed";
                 active: "active";
-                paused: "paused";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             nextRunAt: z.ZodNullable<z.ZodString>;
             lastRunAt: z.ZodNullable<z.ZodString>;
             lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>>>;
             lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             pausedAt: z.ZodNullable<z.ZodString>;
@@ -320,8 +321,8 @@ export declare const ScheduleInspectResponseSchema: z.ZodObject<{
                 endedAt: z.ZodNullable<z.ZodString>;
                 status: z.ZodEnum<{
                     running: "running";
-                    succeeded: "succeeded";
                     failed: "failed";
+                    succeeded: "succeeded";
                 }>;
                 agentId: z.ZodNullable<z.ZodGUID>;
                 workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -343,8 +344,8 @@ export declare const ScheduleLogsResponseSchema: z.ZodObject<{
             endedAt: z.ZodNullable<z.ZodString>;
             status: z.ZodEnum<{
                 running: "running";
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>;
             agentId: z.ZodNullable<z.ZodGUID>;
             workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -359,13 +360,14 @@ 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>;
+            id: z.ZodString;
             status: z.ZodEnum<{
+                paused: "paused";
                 completed: "completed";
                 active: "active";
-                paused: "paused";
             }>;
-            id: z.ZodString;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -407,12 +409,11 @@ 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<{
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>>>;
             lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             pausedAt: z.ZodNullable<z.ZodString>;
@@ -427,13 +428,14 @@ 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>;
+            id: z.ZodString;
             status: z.ZodEnum<{
+                paused: "paused";
                 completed: "completed";
                 active: "active";
-                paused: "paused";
             }>;
-            id: z.ZodString;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -475,12 +477,11 @@ 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<{
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>>>;
             lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             pausedAt: z.ZodNullable<z.ZodString>;
@@ -546,17 +547,17 @@ export declare const ScheduleRunOnceResponseSchema: z.ZodObject<{
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">;
             status: z.ZodEnum<{
+                paused: "paused";
                 completed: "completed";
                 active: "active";
-                paused: "paused";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             nextRunAt: z.ZodNullable<z.ZodString>;
             lastRunAt: z.ZodNullable<z.ZodString>;
             lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>>>;
             lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             pausedAt: z.ZodNullable<z.ZodString>;
@@ -569,8 +570,8 @@ export declare const ScheduleRunOnceResponseSchema: z.ZodObject<{
                 endedAt: z.ZodNullable<z.ZodString>;
                 status: z.ZodEnum<{
                     running: "running";
-                    succeeded: "succeeded";
                     failed: "failed";
+                    succeeded: "succeeded";
                 }>;
                 agentId: z.ZodNullable<z.ZodGUID>;
                 workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -629,17 +630,17 @@ export declare const ScheduleUpdateResponseSchema: z.ZodObject<{
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">;
             status: z.ZodEnum<{
+                paused: "paused";
                 completed: "completed";
                 active: "active";
-                paused: "paused";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             nextRunAt: z.ZodNullable<z.ZodString>;
             lastRunAt: z.ZodNullable<z.ZodString>;
             lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
             }>>>;
             lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             pausedAt: z.ZodNullable<z.ZodString>;
@@ -652,8 +653,8 @@ export declare const ScheduleUpdateResponseSchema: z.ZodObject<{
                 endedAt: z.ZodNullable<z.ZodString>;
                 status: z.ZodEnum<{
                     running: "running";
-                    succeeded: "succeeded";
                     failed: "failed";
+                    succeeded: "succeeded";
                 }>;
                 agentId: z.ZodNullable<z.ZodGUID>;
                 workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;

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(),