@otto-code/protocol 0.6.6 → 0.6.7

package/dist/messages.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { TerminalActivitySchema } from "./terminal-activity.js";
-import { RunSchema } from "./orchestration.js";
+import { OrchestrationGraphSchema, RunSchema } from "./orchestration.js";
 import { ArtifactMetadataSchema } from "./artifacts/types.js";
 import { ArtifactListRequestSchema, ArtifactCreateRequestSchema, ArtifactUpdateRequestSchema, ArtifactRegenerateRequestSchema, ArtifactCancelRequestSchema, ArtifactDeleteRequestSchema, ArtifactStarRequestSchema, ArtifactGetContentRequestSchema, ArtifactListResponseSchema, ArtifactCreateResponseSchema, ArtifactUpdateResponseSchema, ArtifactRegenerateResponseSchema, ArtifactCancelResponseSchema, ArtifactDeleteResponseSchema, ArtifactStarResponseSchema, ArtifactGetContentResponseSchema, ArtifactCreatedNotificationSchema, ArtifactUpdatedNotificationSchema, ArtifactDeletedNotificationSchema, } from "./artifacts/rpc-schemas.js";
 import { CLIENT_CAPS } from "./client-capabilities.js";
@@ -372,6 +372,12 @@ export const MutableDaemonConfigSchema = z
         preferWriterPersonalities: false,
     }),
     autoArchiveAfterMerge: z.boolean().default(false),
+    // Drop the "Merge into <base>" action from the client's source-control menu
+    // (and stop promoting it to the primary CTA) for a pull-request-only
+    // workflow. Host-level so the whole team's clients share one policy.
+    // Defaults false so a new client parsing an old daemon's config keeps the
+    // action visible. Gated by server_info features.hideMergeIntoBaseSetting.
+    hideMergeIntoBaseAction: z.boolean().default(false),
     enableTerminalAgentHooks: z.boolean().default(false),
     appendSystemPrompt: z.string().default(""),
     terminalProfiles: z.array(TerminalProfileSchema).optional(),
@@ -412,6 +418,8 @@ export const MutableDaemonConfigPatchSchema = z
         .optional(),
     metadataGeneration: MutableMetadataGenerationConfigSchema.partial().optional(),
     autoArchiveAfterMerge: z.boolean().optional(),
+    // Gated by server_info features.hideMergeIntoBaseSetting.
+    hideMergeIntoBaseAction: z.boolean().optional(),
     enableTerminalAgentHooks: z.boolean().optional(),
     appendSystemPrompt: z.string().optional(),
     terminalProfiles: z.array(TerminalProfileSchema).optional(),
@@ -1369,6 +1377,35 @@ export const SpeechTtsPreviewRequestSchema = z.object({
         .passthrough()
         .optional(),
 });
+// Read a full assistant message aloud on demand (the per-message playback
+// button). Unlike the preview RPC — which truncates to a short sample and
+// returns one buffered clip — this synthesizes the ENTIRE text and streams it
+// back as `audio_output` chunks (isVoiceMode: false), one group per sentence, so
+// playback starts after the first sentence instead of the whole message.
+// `voice` (optional) is the speaking agent's personality voice, resolved on the
+// client from the live personality (same soft-binding semantics as the preview
+// button); absent uses the host default. The correlated response lands once
+// playback finishes, is canceled, or errors.
+export const SpeechTtsSpeakRequestSchema = z.object({
+    type: z.literal("speech.tts.speak.request"),
+    requestId: z.string(),
+    text: z.string(),
+    voice: z
+        .object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+        name: z.string(),
+    })
+        .passthrough()
+        .optional(),
+});
+// Stop the session's in-flight message playback (the button's stop press).
+// Aborts synthesis on the host; the pending speak response then resolves as
+// canceled and the client flushes its own audio queue.
+export const SpeechTtsSpeakCancelRequestSchema = z.object({
+    type: z.literal("speech.tts.speak.cancel.request"),
+    requestId: z.string(),
+});
 // COMPAT(visualizerVoiceCues): added in v0.6.3; gate lives in
 // features.visualizerVoiceCues. Author short spoken "cue" lines for a
 // personality — a handful of variations each for three Visualizer moments
@@ -2368,6 +2405,97 @@ export const RunsClearedNotificationSchema = z.object({
         runIds: z.array(z.string()),
     }),
 });
+// ── Orchestration graphs (user orchestrations) ──────────────────────────────
+// Host-level reusable graph templates + user-initiated orchestration start.
+// Gated by server_info.features.orchestrationGraphs. UI says "Orchestration"
+// and "Graph"; the wire keeps the short `runs.` namespace (see docs/glossary.md).
+// See projects/orchestration-graphs.
+export const RunsGraphsListRequestSchema = z.object({
+    type: z.literal("runs.graphs.list.request"),
+    requestId: z.string(),
+});
+export const RunsGraphsListResponseSchema = z.object({
+    type: z.literal("runs.graphs.list.response"),
+    payload: z.object({
+        graphs: z.array(OrchestrationGraphSchema),
+        requestId: z.string(),
+    }),
+});
+// Upsert a graph template (create when the id is new). Built-in graphs are
+// copy-on-edit daemon-side: saving over a builtIn id persists a user copy.
+export const RunsGraphsSaveRequestSchema = z.object({
+    type: z.literal("runs.graphs.save.request"),
+    graph: OrchestrationGraphSchema,
+    requestId: z.string(),
+});
+export const RunsGraphsSaveResponseSchema = z.object({
+    type: z.literal("runs.graphs.save.response"),
+    payload: z.object({
+        graph: OrchestrationGraphSchema.optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const RunsGraphsDeleteRequestSchema = z.object({
+    type: z.literal("runs.graphs.delete.request"),
+    graphId: z.string(),
+    requestId: z.string(),
+});
+export const RunsGraphsDeleteResponseSchema = z.object({
+    type: z.literal("runs.graphs.delete.response"),
+    payload: z.object({
+        deleted: z.boolean(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+// Broadcast after any save/delete so every client's graph cache converges,
+// mirroring runs.updated.notification's role for runs.
+export const RunsGraphsChangedNotificationSchema = z.object({
+    type: z.literal("runs.graphs.changed.notification"),
+    payload: z.object({
+        graphs: z.array(OrchestrationGraphSchema),
+    }),
+});
+// Start (or draft) a user-initiated orchestration from the New Orchestration
+// dialog. `flavor` is an open vocabulary: "ai" (prompt-and-go — the daemon
+// spawns an orchestrator agent that declares its own plan via start_run) or
+// "graph" (deterministic — the daemon executes `graphId` with `graphInputs`).
+// `draft: true` creates the record without executing (the designer flow);
+// `runId` executes an existing draft in place.
+export const RunsStartRequestSchema = z.object({
+    type: z.literal("runs.start.request"),
+    flavor: z.string(),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    // Orchestrator seat when the active team doesn't fill it: a personality, or
+    // a bare provider/model pair.
+    orchestratorPersonalityId: z.string().optional(),
+    orchestratorProvider: z.string().optional(),
+    orchestratorModel: z.string().optional(),
+    orchestratorThinkingOptionId: z.string().optional(),
+    prompt: z.string().optional(),
+    graphId: z.string().optional(),
+    graphInputs: z.record(z.string(), z.string()).optional(),
+    draft: z.boolean().optional(),
+    runId: z.string().optional(),
+    requestId: z.string(),
+});
+export const RunsStartResponseSchema = z.object({
+    type: z.literal("runs.start.response"),
+    payload: z.object({
+        runId: z.string().optional(),
+        // The root/orchestrator agent whose chat the client navigates to, and the
+        // workspace the daemon resolved it into (the dialog only knows a project
+        // target's cwd).
+        agentId: z.string().optional(),
+        workspaceId: z.string().optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
 // 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.
@@ -2733,6 +2861,23 @@ export const ArchiveWorkspaceRequestSchema = z.object({
     type: z.literal("archive_workspace_request"),
     workspaceId: z.string(),
     requestId: z.string(),
+    // COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7, drop the optional
+    // gate when daemon floor >= v0.6.7. Absent means "keep" — the leftover local
+    // branch is never touched (old-client behavior). "delete" asks the daemon to
+    // remove the worktree's local branch after the backing directory is torn down
+    // (only when this was the last reference to it and the branch is not checked
+    // out elsewhere). Gated by server_info.features.worktreeArchiveBranchCleanup.
+    branchDisposition: z.enum(["keep", "delete"]).optional(),
+});
+// Read-only pre-archive inspection for a worktree-backed workspace: what branch
+// it is on, whether that branch is merged into its base, and whether archiving
+// will actually free the branch (last reference, not checked out elsewhere). The
+// client uses this to render the "delete the leftover branch?" confirmation.
+// COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7.
+export const WorkspaceArchivePreflightRequestSchema = z.object({
+    type: z.literal("workspace.archive.preflight.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
 });
 // Create a new workspace record. Unlike open_project, this never deduplicates by
 // directory: it always produces a fresh workspace. The source discriminates
@@ -2765,6 +2910,36 @@ export const WorkspaceCreateRequestSchema = z.object({
         }),
     ]),
 });
+// Re-attach a "left" Otto worktree as a live workspace. Two targets: revive an
+// archived worktree workspace record in place (recreating its backing directory
+// from the kept branch when it is gone), or bind a fresh workspace to an orphaned
+// on-disk Otto worktree that no live workspace references.
+// COMPAT(worktreeReattach): added in v0.6.7. Gated by server_info.features.worktreeReattach.
+export const WorktreeReattachTargetSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("workspace"),
+        workspaceId: z.string(),
+    }),
+    z.object({
+        kind: z.literal("orphan"),
+        worktreePath: z.string(),
+        projectId: z.string().optional(),
+    }),
+]);
+export const WorktreeReattachRequestSchema = z.object({
+    type: z.literal("worktree.reattach.request"),
+    requestId: z.string(),
+    target: WorktreeReattachTargetSchema,
+});
+// List re-attachable Otto worktrees for a project/repo: archived worktree
+// workspace records whose branch is kept, plus orphaned on-disk worktrees with no
+// live workspace. Either projectId or a cwd inside the repo is required.
+export const WorktreeReattachListRequestSchema = z.object({
+    type: z.literal("worktree.reattach.list.request"),
+    requestId: z.string(),
+    projectId: z.string().optional(),
+    cwd: z.string().optional(),
+});
 export const WorkspaceClearAttentionRequestSchema = z.object({
     type: z.literal("workspace.clear_attention.request"),
     workspaceId: z.union([z.string(), z.array(z.string())]),
@@ -3108,6 +3283,8 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigRequestMessageSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
+    SpeechTtsSpeakRequestSchema,
+    SpeechTtsSpeakCancelRequestSchema,
     VisualizerVoiceCuesGenerateRequestSchema,
     AgentPersonalitiesGetStatsRequestSchema,
     ReadProjectConfigRequestMessageSchema,
@@ -3169,6 +3346,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     RunsGateRespondRequestSchema,
     RunsCancelRequestSchema,
     RunsClearRequestSchema,
+    RunsGraphsListRequestSchema,
+    RunsGraphsSaveRequestSchema,
+    RunsGraphsDeleteRequestSchema,
+    RunsStartRequestSchema,
     CheckoutMergeRequestSchema,
     CheckoutMergeFromBaseRequestSchema,
     CheckoutPullRequestSchema,
@@ -3204,6 +3385,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     OpenProjectRequestSchema,
     ProjectAddRequestSchema,
     ArchiveWorkspaceRequestSchema,
+    WorkspaceArchivePreflightRequestSchema,
+    WorktreeReattachListRequestSchema,
+    WorktreeReattachRequestSchema,
     WorkspaceCreateRequestSchema,
     WorkspaceClearAttentionRequestSchema,
     FileExplorerRequestSchema,
@@ -3476,6 +3660,9 @@ export const ServerInfoStatusPayloadSchema = z
         agentPersonalities: z.boolean().optional(),
         // COMPAT(ttsPreview): added in v0.4.7, drop the gate when daemon floor >= v0.4.7.
         ttsPreview: z.boolean().optional(),
+        // COMPAT(ttsSpeak): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        // Host can stream a full message aloud on demand (per-message playback).
+        ttsSpeak: z.boolean().optional(),
         // COMPAT(visualizerVoiceCues): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
         visualizerVoiceCues: z.boolean().optional(),
         // COMPAT(setAgentPersonality): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
@@ -3494,6 +3681,21 @@ export const ServerInfoStatusPayloadSchema = z
         // once.
         // COMPAT(checkoutGitFileHistory): added in v0.6.6, drop the gate when daemon floor >= v0.6.6.
         checkoutGitFileHistory: z.boolean().optional(),
+        // Set when the daemon can inspect a worktree's leftover branch before
+        // archiving (workspace.archive.preflight.*) and delete it as part of the
+        // archive (archive_workspace_request.branchDisposition). Without it the
+        // client archives the worktree exactly as before and never offers to
+        // remove the branch — no degraded client-side branch detection exists.
+        // COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        worktreeArchiveBranchCleanup: z.boolean().optional(),
+        // COMPAT(worktreeReattach): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        worktreeReattach: z.boolean().optional(),
+        // Set when the daemon persists the host-level hideMergeIntoBaseAction
+        // workspace policy (read/written via the daemon config RPCs). Without
+        // it the client hides the Workspaces toggle, since patching the field
+        // on an old daemon would silently fail to stick.
+        // COMPAT(hideMergeIntoBaseSetting): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        hideMergeIntoBaseSetting: 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.
@@ -3506,6 +3708,8 @@ export const ServerInfoStatusPayloadSchema = z
         activityStats: z.boolean().optional(),
         // COMPAT(runsClear): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
         runsClear: z.boolean().optional(),
+        // COMPAT(orchestrationGraphs): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        orchestrationGraphs: z.boolean().optional(),
         // COMPAT(projectLinks): added in v0.5.6, drop the gate when daemon floor >= v0.5.6.
         projectLinks: z.boolean().optional(),
         // COMPAT(fileOutsideWorkspace): added in v0.5.8, drop the gate when daemon floor >= v0.5.8.
@@ -4052,6 +4256,79 @@ export const ArchiveWorkspaceResponseMessageSchema = z.object({
         workspaceId: z.string(),
         archivedAt: z.string().nullable(),
         error: z.string().nullable(),
+        // COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7. The name of the
+        // local branch the daemon deleted as part of this archive (when the request
+        // asked for branchDisposition: "delete" and the branch was actually
+        // removed), else null/absent. Old daemons omit it.
+        deletedBranch: z.string().nullable().optional(),
+    }),
+});
+// Whether/how a worktree-backed workspace's local branch can be cleaned up when
+// the workspace is archived. See WorkspaceArchivePreflightRequestSchema.
+export const WorktreeArchiveBranchDetectionSchema = z.object({
+    // True only for Otto-owned worktrees whose branch we can offer to delete.
+    // False for local checkouts, plain directories, and non-owned worktrees — the
+    // client then skips the branch-cleanup UI entirely.
+    isOttoWorktree: z.boolean(),
+    // The local branch checked out in the worktree, or null when detached/unknown.
+    branchName: z.string().nullable(),
+    // The base ref the branch was created from (origin/ stripped), or null.
+    baseBranch: z.string().nullable(),
+    mergeState: z.enum(["merged", "unmerged", "unknown"]),
+    // Commits on the branch not contained in the base ref; null when unknown.
+    unmergedCommitCount: z.number().int().nonnegative().nullable(),
+    // A matching origin/<branch> exists — deleting the local branch keeps the
+    // remote copy. Purely informational for the confirmation copy.
+    hasRemoteBranch: z.boolean(),
+    // The branch is checked out in another worktree too, so git will refuse to
+    // delete it even after this worktree is removed. The client hides the option.
+    branchCheckedOutElsewhere: z.boolean(),
+    // Archiving will actually remove the backing directory (this is the last
+    // active workspace referencing it). Branch cleanup is only offered when true.
+    directoryWillBeRemoved: z.boolean(),
+});
+export const WorkspaceArchivePreflightResponseSchema = z.object({
+    type: z.literal("workspace.archive.preflight.response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.string(),
+        // Null when detection failed (see error) or the workspace is gone.
+        detection: WorktreeArchiveBranchDetectionSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+// A re-attachable Otto worktree surfaced by worktree.reattach.list.
+// COMPAT(worktreeReattach): added in v0.6.7.
+export const WorktreeReattachCandidateSchema = z.object({
+    // Present when an archived workspace record still backs this worktree; null for
+    // an orphaned on-disk worktree with no record. The reattach request keys off
+    // whichever identity is available.
+    workspaceId: z.string().nullable(),
+    worktreePath: z.string(),
+    branchName: z.string().nullable(),
+    baseBranch: z.string().nullable(),
+    // The worktree directory currently exists on disk. False means the record was
+    // archived away and the directory must be recreated from the branch on reattach.
+    directoryOnDisk: z.boolean(),
+    // The workspace's human name when we have a record, else null.
+    displayName: z.string().nullable(),
+    archivedAt: z.string().nullable(),
+});
+export const WorktreeReattachListResponseSchema = z.object({
+    type: z.literal("worktree.reattach.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        candidates: z.array(WorktreeReattachCandidateSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const WorktreeReattachResponseSchema = z.object({
+    type: z.literal("worktree.reattach.response"),
+    payload: z.object({
+        requestId: z.string(),
+        // The revived/created workspace descriptor, or null on error.
+        workspace: WorkspaceDescriptorPayloadSchema.nullable(),
+        error: z.string().nullable(),
     }),
 });
 export const FetchAgentResponseMessageSchema = z.object({
@@ -4243,6 +4520,23 @@ export const SpeechTtsPreviewResponseSchema = z.object({
     })
         .passthrough(),
 });
+export const SpeechTtsSpeakResponseSchema = z.object({
+    type: z.literal("speech.tts.speak.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // True when the full message played to completion; absent/false when it was
+        // canceled or produced no audio. `error` carries a human-readable failure.
+        ok: z.boolean().optional(),
+        canceled: z.boolean().optional(),
+        error: z.string().optional(),
+    })
+        .passthrough(),
+});
+export const SpeechTtsSpeakCancelResponseSchema = z.object({
+    type: z.literal("speech.tts.speak.cancel.response"),
+    payload: z.object({ requestId: z.string() }).passthrough(),
+});
 export const VisualizerVoiceCuesGenerateResponseSchema = z.object({
     type: z.literal("visualizer.voiceCues.generate.response"),
     payload: z
@@ -5824,6 +6118,9 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     LegacyListAvailableEditorsResponseMessageSchema,
     LegacyOpenInEditorResponseMessageSchema,
     ArchiveWorkspaceResponseMessageSchema,
+    WorkspaceArchivePreflightResponseSchema,
+    WorktreeReattachListResponseSchema,
+    WorktreeReattachResponseSchema,
     FetchAgentResponseMessageSchema,
     FetchAgentTimelineResponseMessageSchema,
     AgentForkContextResponseMessageSchema,
@@ -5840,6 +6137,8 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigResponseMessageSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
+    SpeechTtsSpeakResponseSchema,
+    SpeechTtsSpeakCancelResponseSchema,
     VisualizerVoiceCuesGenerateResponseSchema,
     AgentPersonalitiesGetStatsResponseSchema,
     ReadProjectConfigResponseMessageSchema,
@@ -5893,6 +6192,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     RunsCancelResponseSchema,
     RunsClearResponseSchema,
     RunsClearedNotificationSchema,
+    RunsGraphsListResponseSchema,
+    RunsGraphsSaveResponseSchema,
+    RunsGraphsDeleteResponseSchema,
+    RunsGraphsChangedNotificationSchema,
+    RunsStartResponseSchema,
     CheckoutMergeResponseSchema,
     CheckoutMergeFromBaseResponseSchema,
     CheckoutPullResponseSchema,

package/dist/orchestration.d.ts

@@ -6,7 +6,7 @@ export declare function isRunPhaseType(value: string): value is RunPhaseType;
 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 declare const RUN_STATUSES: readonly ["draft", "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;
@@ -102,7 +102,11 @@ export type RunPhase = z.infer<typeof RunPhaseSchema>;
 export declare const RunSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
     status: z.ZodString;
+    kind: z.ZodOptional<z.ZodString>;
+    graphId: z.ZodOptional<z.ZodString>;
+    graphInputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
     autopilot: z.ZodOptional<z.ZodBoolean>;
     phases: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -149,4 +153,98 @@ export declare const RunSchema: z.ZodObject<{
 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];
+export declare const GraphInputSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    multiline: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type GraphInput = z.infer<typeof GraphInputSchema>;
+export declare const GRAPH_NODE_KINDS: readonly ["orchestrator", "agent"];
+export type GraphNodeKind = (typeof GRAPH_NODE_KINDS)[number];
+export declare const GraphNodeLoopSchema: z.ZodObject<{
+    times: z.ZodOptional<z.ZodNumber>;
+    until: z.ZodOptional<z.ZodObject<{
+        criteria: z.ZodArray<z.ZodString>;
+        judgeRole: z.ZodOptional<z.ZodString>;
+        max: z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type GraphNodeLoop = z.infer<typeof GraphNodeLoopSchema>;
+export declare const GraphNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    title: z.ZodString;
+    role: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    promptFromInput: z.ZodOptional<z.ZodString>;
+    autonomous: z.ZodOptional<z.ZodBoolean>;
+    loop: z.ZodOptional<z.ZodObject<{
+        times: z.ZodOptional<z.ZodNumber>;
+        until: z.ZodOptional<z.ZodObject<{
+            criteria: z.ZodArray<z.ZodString>;
+            judgeRole: z.ZodOptional<z.ZodString>;
+            max: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    model: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type GraphNode = z.infer<typeof GraphNodeSchema>;
+export declare const GraphEdgeSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$loose>;
+export type GraphEdge = z.infer<typeof GraphEdgeSchema>;
+export declare const OrchestrationGraphSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        multiline: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        title: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+        promptFromInput: z.ZodOptional<z.ZodString>;
+        autonomous: z.ZodOptional<z.ZodBoolean>;
+        loop: z.ZodOptional<z.ZodObject<{
+            times: z.ZodOptional<z.ZodNumber>;
+            until: z.ZodOptional<z.ZodObject<{
+                criteria: z.ZodArray<z.ZodString>;
+                judgeRole: z.ZodOptional<z.ZodString>;
+                max: z.ZodNumber;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        model: z.ZodOptional<z.ZodString>;
+        position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$loose>>>;
+    builtIn: z.ZodOptional<z.ZodBoolean>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type OrchestrationGraph = z.infer<typeof OrchestrationGraphSchema>;
+export declare function validateOrchestrationGraph(graph: OrchestrationGraph): string[];
 //# sourceMappingURL=orchestration.d.ts.map