@otto-code/protocol 0.5.1 → 0.5.4

package/dist/agent-attention-notification.js

@@ -41,13 +41,59 @@ const buildNotificationPreview = (text) => {
     }
     return truncateNotificationText(normalized, NOTIFICATION_PREVIEW_LIMIT);
 };
-const safeStringify = (value) => {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
+// Human-readable labels for common tool names, so a permission notification reads
+// like a request ("Run command: …") instead of dumping the raw tool identifier.
+const TOOL_NAME_LABELS = {
+    bash: "Run command",
+    exec: "Run command",
+    shell: "Run command",
+    read: "Read file",
+    write: "Write file",
+    edit: "Edit file",
+    multiedit: "Edit file",
+    grep: "Search",
+    glob: "Find files",
+    webfetch: "Fetch page",
+    websearch: "Web search",
+    task: "Start subagent",
+    external_directory: "Access directory",
+};
+const humanizeToolName = (name) => {
+    const trimmed = name.trim();
+    return TOOL_NAME_LABELS[trimmed.toLowerCase()] ?? trimmed;
+};
+// Input fields that carry the meaningful, user-legible part of a tool call, in
+// priority order. The first non-empty string wins.
+const PERMISSION_INPUT_DESCRIPTION_KEYS = [
+    "command",
+    "description",
+    "file_path",
+    "path",
+    "url",
+    "pattern",
+    "query",
+    "prompt",
+];
+// Deterministic field extraction — NOT an AI summary. Picks an existing string
+// field out of the tool's input (by the priority list, then any string field)
+// so the notification can show it verbatim instead of raw JSON.
+const describePermissionInput = (input) => {
+    if (!input) {
         return null;
     }
+    for (const key of PERMISSION_INPUT_DESCRIPTION_KEYS) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    // Fall back to the first string-valued field rather than raw JSON.
+    for (const value of Object.values(input)) {
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
 };
 const buildPermissionDetails = (request) => {
     if (!request) {
@@ -65,15 +111,17 @@ const buildPermissionDetails = (request) => {
     if (details.length > 0) {
         return details.join(" - ");
     }
-    const inputPreview = request.input ? safeStringify(request.input) : null;
-    if (inputPreview) {
-        return inputPreview;
+    // No provider-supplied title/description: build a legible line from the tool
+    // name and a meaningful input field instead of stringifying the payload.
+    const name = request.name?.trim();
+    const inputDescription = describePermissionInput(request.input);
+    if (name && inputDescription) {
+        return `${humanizeToolName(name)}: ${inputDescription}`;
     }
-    const metadataPreview = request.metadata ? safeStringify(request.metadata) : null;
-    if (metadataPreview) {
-        return metadataPreview;
+    if (inputDescription) {
+        return inputDescription;
     }
-    return request.name?.trim() || request.kind;
+    return name ? humanizeToolName(name) : request.kind;
 };
 export function findLatestAssistantMessageFromTimeline(timeline) {
     // Providers may stream assistant content in consecutive chunks.

package/dist/agent-personalities.d.ts

@@ -8,6 +8,41 @@ export declare function isPersonalityRole(value: string): value is PersonalityRo
  */
 export declare function normalizePersonalityRoles(roles: readonly string[] | undefined): PersonalityRole[];
 export declare function personalityHasRole(personality: Pick<AgentPersonality, "roles">, role: PersonalityRole): boolean;
+export type PersonalityRoleTier = "coordinator" | "focused";
+interface PersonalityRoleInfo {
+    tier: PersonalityRoleTier;
+    guidance: string;
+}
+export declare const PERSONALITY_ROLE_INFO: Readonly<Record<PersonalityRole, PersonalityRoleInfo>>;
+/**
+ * A personality may launch/coordinate when it carries at least one coordinator
+ * role. A personality whose roles are entirely focused (researcher, planner,
+ * judger, advisor, coder, designer, writer), or that has no roles at all, is a
+ * "lifter": it should finish its task, not fan out.
+ */
+export declare function personalityCanLaunch(personality: Pick<AgentPersonality, "roles">): boolean;
+export interface PersonalitySelectionSummary {
+    tier: PersonalityRoleTier;
+    canLaunch: boolean;
+    /** The "why you'd choose me" blurb — each of the personality's roles, joined. */
+    guidance: string;
+}
+/**
+ * Build the selection decision-aid for a personality from its roles: the tier
+ * (coordinator if any role coordinates), whether it may launch, and a short
+ * multi-role "why choose me" blurb. Surfaced by list_personalities so a
+ * deciding agent can pick the right teammate from the list alone.
+ */
+export declare function summarizePersonalityForSelection(personality: Pick<AgentPersonality, "roles">): PersonalitySelectionSummary;
+export declare const ORCHESTRATOR_METHOD_DIRECTIVE: string;
+/**
+ * The in-context "role directive" injected into a personality's system prompt at
+ * spawn. The orchestrator gets the full conductor method; other coordinators
+ * (chatter/artificer/scheduler) get a lighter delegate nudge; focused workers
+ * are told to stay on the task someone is waiting on. Roleless spawns get
+ * nothing. This is guidance, not a gate — the tools stay available either way.
+ */
+export declare function composeRoleFocusDirective(roles: readonly string[] | undefined): string | undefined;
 export type PersonalityUnavailableCode = "provider-missing" | "provider-disabled" | "provider-not-ready" | "model-missing" | "mode-missing";
 export interface PersonalityAvailabilityInput {
     /** Provider snapshot status, or undefined when the provider is absent entirely. */
@@ -30,4 +65,5 @@ export type PersonalityAvailability = {
  * The caller grays it out in pickers and hard-fails it in automation.
  */
 export declare function checkPersonalityAvailability(personality: Pick<AgentPersonality, "provider" | "model" | "modeId">, input: PersonalityAvailabilityInput): PersonalityAvailability;
+export {};
 //# sourceMappingURL=agent-personalities.d.ts.map

package/dist/agent-personalities.js

@@ -37,6 +37,110 @@ export function normalizePersonalityRoles(roles) {
 export function personalityHasRole(personality, role) {
     return normalizePersonalityRoles(personality.roles).includes(role);
 }
+export const PERSONALITY_ROLE_INFO = {
+    // ── Surfaces ──────────────────────────────────────────────────────────────
+    chatter: {
+        tier: "coordinator",
+        guidance: "Interactive driver — converse, plan, and delegate. Pick to run a chat or coordinate work.",
+    },
+    artificer: {
+        tier: "coordinator",
+        guidance: "Builds and manages artifacts; may run multi-step work to produce them. Pick for artifact creation.",
+    },
+    scheduler: {
+        tier: "coordinator",
+        guidance: "Creates and manages schedules; may orchestrate recurring or multi-step jobs. Pick for scheduling.",
+    },
+    // ── Thinking workers (read-only, structured findings) ─────────────────────
+    researcher: {
+        tier: "focused",
+        guidance: "Read-only surveyor — maps the code or domain and reports files, types, patterns, and gotchas. Pick to gather facts; proposes no solutions and edits nothing.",
+    },
+    planner: {
+        tier: "focused",
+        guidance: "Planning specialist — turns a goal into a typed, sequenced phase plan for others to execute. Pick to draft an actionable plan; stays on the plan and doesn't dispatch.",
+    },
+    judger: {
+        tier: "focused",
+        guidance: "Review specialist — evaluates work or a plan against criteria and returns a structured verdict. Pick for a focused review; stays on task.",
+    },
+    advisor: {
+        tier: "focused",
+        guidance: "Read-only second opinion — weighs the trade-offs and returns one recommendation. Pick for advice; never edits and does not fan out.",
+    },
+    // ── Making workers (produce code, design, or text) ────────────────────────
+    coder: {
+        tier: "focused",
+        guidance: "Focused implementer — writes code for one sub-task others are waiting on. Pick to get a coding job done; stays on task.",
+    },
+    designer: {
+        tier: "focused",
+        guidance: "Design maker — styling and layout plus the human-skill text (copy, naming). Pick for the look-and-feel or the words; stays on task.",
+    },
+    writer: {
+        tier: "focused",
+        guidance: "Fast small-text specialist — commit messages, summaries, names. Pick for quick text; stays on the one task.",
+    },
+    // ── Conductor ─────────────────────────────────────────────────────────────
+    orchestrator: {
+        tier: "coordinator",
+        guidance: "The sole conductor — plans team-shaped work, dispatches typed tasks to the right teammates, gathers, and synthesizes. Pick to run a multi-agent workflow.",
+    },
+};
+/**
+ * A personality may launch/coordinate when it carries at least one coordinator
+ * role. A personality whose roles are entirely focused (researcher, planner,
+ * judger, advisor, coder, designer, writer), or that has no roles at all, is a
+ * "lifter": it should finish its task, not fan out.
+ */
+export function personalityCanLaunch(personality) {
+    return normalizePersonalityRoles(personality.roles).some((role) => PERSONALITY_ROLE_INFO[role].tier === "coordinator");
+}
+/**
+ * Build the selection decision-aid for a personality from its roles: the tier
+ * (coordinator if any role coordinates), whether it may launch, and a short
+ * multi-role "why choose me" blurb. Surfaced by list_personalities so a
+ * deciding agent can pick the right teammate from the list alone.
+ */
+export function summarizePersonalityForSelection(personality) {
+    const roles = normalizePersonalityRoles(personality.roles);
+    const canLaunch = roles.some((role) => PERSONALITY_ROLE_INFO[role].tier === "coordinator");
+    return {
+        tier: canLaunch ? "coordinator" : "focused",
+        canLaunch,
+        guidance: roles.map((role) => PERSONALITY_ROLE_INFO[role].guidance).join(" "),
+    };
+}
+// The conductor's standing directive — the distilled `/epic` method taught to
+// the sole orchestrator role at spawn, so orchestration is emergent (the agent
+// recognizes team-shaped work and runs it) rather than something a user must
+// invoke. Kept here as one exported constant so the wording is testable and
+// shared. See projects/agent-orchestration/agent-orchestration.md.
+export const ORCHESTRATOR_METHOD_DIRECTIVE = "You are the orchestrator — the team's sole conductor. Team-shaped work is yours to run, and you should reach for it naturally, not only when asked. " +
+    "First apply the complexity gate: if a task is small and not splittable, just do it — no ceremony. Only orchestrate when the work is large, parallelizable, or benefits from independent perspectives. " +
+    "When you do orchestrate: (1) if the shape is unclear, dispatch a researcher to survey and a planner to draft a typed plan; (2) declare that plan as a Run with start_run — phases typed research/plan/implement/design/verify/gate/deliver, fanning out candidates where several angles help and attaching a judger to grade them, looping until enough pass; (3) put a gate before irreversible or costly steps so the user approves; (4) synthesize the passing results into the deliverable. " +
+    "Prefer start_run over hand-spawning and tracking agents yourself — the runtime fans out, gathers typed verdicts, and enforces the loop for you. Every phase maps to a teammate's role; if the active team lacks a role a phase needs, say so plainly and stop rather than papering over the gap.";
+/**
+ * The in-context "role directive" injected into a personality's system prompt at
+ * spawn. The orchestrator gets the full conductor method; other coordinators
+ * (chatter/artificer/scheduler) get a lighter delegate nudge; focused workers
+ * are told to stay on the task someone is waiting on. Roleless spawns get
+ * nothing. This is guidance, not a gate — the tools stay available either way.
+ */
+export function composeRoleFocusDirective(roles) {
+    const normalized = normalizePersonalityRoles(roles);
+    if (normalized.length === 0) {
+        return undefined;
+    }
+    const roleList = normalized.join(", ");
+    if (normalized.includes("orchestrator")) {
+        return `${ORCHESTRATOR_METHOD_DIRECTIVE} (Your roles: ${roleList}.)`;
+    }
+    if (normalized.some((role) => PERSONALITY_ROLE_INFO[role].tier === "coordinator")) {
+        return `You are a coordinator personality (roles: ${roleList}). You front interactive work and may delegate: use list_personalities to see who else is available, and spawn other agents or hand off to the team's orchestrator whenever delegating gets the work done faster or better.`;
+    }
+    return `You are a focused worker personality (roles: ${roleList}). Someone is waiting on this specific task — stay on it and finish it. You can still call list_personalities to see the roster, but don't spawn sub-agents or start side workflows unless it is genuinely essential to completing this job.`;
+}
 /**
  * Decide whether a personality is usable against a provider's current snapshot.
  * A personality is out of commission the moment any bound setting can't resolve:

package/dist/agent-teams.d.ts

@@ -0,0 +1,49 @@
+import type { AgentPersonality, AgentTeam, PersonalityRole } from "./messages.js";
+/**
+ * The dynamic "Team's Scheduler" schedule binding. Stored in the schedule's
+ * `personality` field in place of a personality name; resolved at RUN time to
+ * the active team's first available member carrying the Scheduler role
+ * (member order). Deliberately contains "@" — personality names are sanitized
+ * to [A-Za-z0-9_-] at the authoring surface, so the sentinel can never collide
+ * with a real name. No active team, or no available Scheduler member, is a
+ * hard run failure with a named error (same loudness as a bound personality
+ * being out of commission).
+ */
+export declare const TEAM_SCHEDULER_PERSONALITY_SENTINEL = "@team-scheduler";
+export interface AgentTeamsConfigView {
+    teams?: readonly AgentTeam[] | undefined;
+    activeTeamId?: string | null | undefined;
+}
+export declare function findAgentTeam(teams: readonly AgentTeam[] | undefined, teamId: string | null | undefined): AgentTeam | null;
+/**
+ * Resolve the host's active team. A dangling `activeTeamId` (team deleted, or
+ * a patch raced a delete) reads as "no team active" — teamlessness is a valid
+ * state and must never error. The daemon additionally heals a dangling id back
+ * to null on the next config patch; this helper is the read-side tolerance.
+ */
+export declare function getActiveAgentTeam(section: AgentTeamsConfigView | undefined): AgentTeam | null;
+export declare function isTeamMember(team: Pick<AgentTeam, "memberIds"> | null | undefined, personalityId: string | null | undefined): boolean;
+/**
+ * Resolve a team's members against the personality roster, in `memberIds`
+ * order, deduped. A member id pointing at a deleted personality is tolerated
+ * and ignored (it is pruned opportunistically on the next save of the team,
+ * never eagerly cascaded on delete).
+ */
+export declare function resolveTeamMembers(team: Pick<AgentTeam, "memberIds"> | null | undefined, personalities: readonly AgentPersonality[] | undefined): AgentPersonality[];
+/**
+ * The save-time prune: drop member ids that no longer resolve to a personality
+ * (and dedupe), preserving order. Editors call this when persisting a team so
+ * dangling ids don't accumulate; readers never require it.
+ */
+export declare function pruneTeamMemberIds(memberIds: readonly string[] | undefined, personalities: readonly AgentPersonality[] | undefined): string[];
+/**
+ * The union of all members' roles, normalized and returned in canonical
+ * `PERSONALITY_ROLES` order — the team card's role-pill strip.
+ */
+export declare function teamRoleUnion(team: Pick<AgentTeam, "memberIds"> | null | undefined, personalities: readonly AgentPersonality[] | undefined): PersonalityRole[];
+/**
+ * A team prompt only stacks when it has content; a team with an empty or
+ * whitespace prompt is purely organizational (picker scoping, no prompt layer).
+ */
+export declare function getEffectiveTeamPrompt(team: Pick<AgentTeam, "teamPrompt"> | null | undefined): string | null;
+//# sourceMappingURL=agent-teams.d.ts.map

package/dist/agent-teams.js

@@ -0,0 +1,99 @@
+import { normalizePersonalityRoles } from "./agent-personalities.js";
+// Pure, dependency-free team helpers shared by the daemon (spawn-time active
+// team resolution, list_personalities scoping) and the app (team cards,
+// pickers, the Active Team switcher). Availability is deliberately NOT here —
+// a team is never "out of commission"; its members are individually available
+// or not, judged by checkPersonalityAvailability per member.
+/**
+ * The dynamic "Team's Scheduler" schedule binding. Stored in the schedule's
+ * `personality` field in place of a personality name; resolved at RUN time to
+ * the active team's first available member carrying the Scheduler role
+ * (member order). Deliberately contains "@" — personality names are sanitized
+ * to [A-Za-z0-9_-] at the authoring surface, so the sentinel can never collide
+ * with a real name. No active team, or no available Scheduler member, is a
+ * hard run failure with a named error (same loudness as a bound personality
+ * being out of commission).
+ */
+export const TEAM_SCHEDULER_PERSONALITY_SENTINEL = "@team-scheduler";
+export function findAgentTeam(teams, teamId) {
+    if (!teamId) {
+        return null;
+    }
+    return teams?.find((team) => team.id === teamId) ?? null;
+}
+/**
+ * Resolve the host's active team. A dangling `activeTeamId` (team deleted, or
+ * a patch raced a delete) reads as "no team active" — teamlessness is a valid
+ * state and must never error. The daemon additionally heals a dangling id back
+ * to null on the next config patch; this helper is the read-side tolerance.
+ */
+export function getActiveAgentTeam(section) {
+    return findAgentTeam(section?.teams, section?.activeTeamId);
+}
+export function isTeamMember(team, personalityId) {
+    if (!team || !personalityId) {
+        return false;
+    }
+    return (team.memberIds ?? []).includes(personalityId);
+}
+/**
+ * Resolve a team's members against the personality roster, in `memberIds`
+ * order, deduped. A member id pointing at a deleted personality is tolerated
+ * and ignored (it is pruned opportunistically on the next save of the team,
+ * never eagerly cascaded on delete).
+ */
+export function resolveTeamMembers(team, personalities) {
+    if (!team || !personalities || personalities.length === 0) {
+        return [];
+    }
+    const byId = new Map(personalities.map((personality) => [personality.id, personality]));
+    const seen = new Set();
+    const members = [];
+    for (const memberId of team.memberIds ?? []) {
+        if (seen.has(memberId)) {
+            continue;
+        }
+        seen.add(memberId);
+        const personality = byId.get(memberId);
+        if (personality) {
+            members.push(personality);
+        }
+    }
+    return members;
+}
+/**
+ * The save-time prune: drop member ids that no longer resolve to a personality
+ * (and dedupe), preserving order. Editors call this when persisting a team so
+ * dangling ids don't accumulate; readers never require it.
+ */
+export function pruneTeamMemberIds(memberIds, personalities) {
+    if (!memberIds || memberIds.length === 0) {
+        return [];
+    }
+    const known = new Set((personalities ?? []).map((personality) => personality.id));
+    const seen = new Set();
+    return memberIds.filter((memberId) => {
+        if (seen.has(memberId) || !known.has(memberId)) {
+            return false;
+        }
+        seen.add(memberId);
+        return true;
+    });
+}
+/**
+ * The union of all members' roles, normalized and returned in canonical
+ * `PERSONALITY_ROLES` order — the team card's role-pill strip.
+ */
+export function teamRoleUnion(team, personalities) {
+    const roles = resolveTeamMembers(team, personalities).flatMap((personality) => personality.roles ?? []);
+    return normalizePersonalityRoles(roles);
+}
+/**
+ * A team prompt only stacks when it has content; a team with an empty or
+ * whitespace prompt is purely organizational (picker scoping, no prompt layer).
+ */
+export function getEffectiveTeamPrompt(team) {
+    const prompt = team?.teamPrompt?.trim();
+    return prompt && prompt.length > 0 ? prompt : null;
+}
+//# sourceMappingURL=agent-teams.js.map

package/dist/agent-types.d.ts

@@ -67,6 +67,13 @@ export interface AgentMode {
     colorTier?: string;
 }
 export type ProviderStatus = "ready" | "loading" | "error" | "unavailable";
+/**
+ * A model's capability tier, used to bind personality "brains" provider-
+ * agnostically (deep = flagship reasoning, standard = everyday, fast = cheap/
+ * high-volume). Assigned by the daemon at ingest (catalog → name pattern), with
+ * a user per-model override winning; see model-tiers.ts.
+ */
+export type ModelTier = "deep" | "standard" | "fast";
 export interface AgentModelDefinition {
     provider: AgentProvider;
     id: string;
@@ -77,6 +84,19 @@ export interface AgentModelDefinition {
     contextWindowMaxTokens?: number;
     thinkingOptions?: AgentSelectOption[];
     defaultThinkingOptionId?: string;
+    /**
+     * Capability tier, stamped by the daemon when it ingests the provider's model
+     * list. Optional: absent from old daemons, and from models we can't classify
+     * and the user hasn't tagged. Consumers fall back to their own inference.
+     */
+    tier?: ModelTier;
+    /**
+     * False when this model cannot run the provider's "auto" permission mode
+     * (e.g. Claude's classifier-based Auto mode is unsupported on Haiku). Absent
+     * = supported or unknown (including old daemons); clients only hide the Auto
+     * option on an explicit false.
+     */
+    supportsAutoMode?: boolean;
 }
 export interface AgentSelectOption {
     id: string;
@@ -379,6 +399,10 @@ export type AgentStreamEvent = {
     item: AgentTimelineItem;
     turnId?: string;
     timestamp?: string;
+} | {
+    type: "background_shell_task_updated";
+    provider: AgentProvider;
+    update: BackgroundShellTaskUpdate;
 };
 export declare function getAgentStreamEventTurnId(event: AgentStreamEvent): string | undefined;
 /**
@@ -399,6 +423,23 @@ export interface ObservedSubagentUpdate {
     requiresAttention?: boolean;
     usage?: AgentUsage;
 }
+/**
+ * A background shell task reported by a provider's own Bash tool (Claude:
+ * `run_in_background`). `key` is a provider-local stable identifier (Claude:
+ * the Bash tool_use id); the daemon namespaces it under the owning agent.
+ * Unlike {@link ObservedSubagentUpdate} this has no transcript/pane — it's a
+ * plain status row (command, status, elapsed) in the Background Tasks track.
+ */
+export interface BackgroundShellTaskUpdate {
+    key: string;
+    /** Provider task id, used to stop the task (Claude: `task_id`). */
+    taskId?: string;
+    command?: string;
+    description?: string;
+    status: "running" | "idle" | "error" | "closed";
+    requiresAttention?: boolean;
+    usage?: AgentUsage;
+}
 export type AgentPermissionRequestKind = "tool" | "plan" | "question" | "mode" | "other";
 export type AgentPermissionUpdate = AgentMetadata;
 export interface AgentPermissionAction {

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

@@ -73,8 +73,8 @@ export declare const ArtifactListResponseSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -109,8 +109,8 @@ export declare const ArtifactCreateResponseSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -153,8 +153,8 @@ export declare const ArtifactStarResponseSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -189,8 +189,8 @@ export declare const ArtifactUpdateResponseSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -225,8 +225,8 @@ export declare const ArtifactRegenerateResponseSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -261,8 +261,8 @@ export declare const ArtifactCancelResponseSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -306,8 +306,8 @@ export declare const ArtifactCreatedNotificationSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -339,8 +339,8 @@ export declare const ArtifactUpdatedNotificationSchema: z.ZodObject<{
             starred: z.ZodBoolean;
             status: z.ZodEnum<{
                 error: "error";
-                generating: "generating";
                 ready: "ready";
+                generating: "generating";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;

package/dist/artifacts/types.d.ts

@@ -5,8 +5,8 @@ export declare const ArtifactKindSchema: z.ZodEnum<{
 export type ArtifactKind = z.infer<typeof ArtifactKindSchema>;
 export declare const ArtifactStatusSchema: z.ZodEnum<{
     error: "error";
-    generating: "generating";
     ready: "ready";
+    generating: "generating";
 }>;
 export type ArtifactStatus = z.infer<typeof ArtifactStatusSchema>;
 export declare const ArtifactSpinnerSchema: z.ZodObject<{
@@ -26,8 +26,8 @@ export declare const ArtifactMetadataSchema: z.ZodObject<{
     starred: z.ZodBoolean;
     status: z.ZodEnum<{
         error: "error";
-        generating: "generating";
         ready: "ready";
+        generating: "generating";
     }>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
@@ -55,8 +55,8 @@ export declare const ArtifactSummarySchema: z.ZodObject<{
     starred: z.ZodBoolean;
     status: z.ZodEnum<{
         error: "error";
-        generating: "generating";
         ready: "ready";
+        generating: "generating";
     }>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
@@ -79,8 +79,8 @@ export declare const ArtifactRunTriggerSchema: z.ZodEnum<{
 export type ArtifactRunTrigger = z.infer<typeof ArtifactRunTriggerSchema>;
 export declare const ArtifactRunStatusSchema: z.ZodEnum<{
     running: "running";
-    succeeded: "succeeded";
     failed: "failed";
+    succeeded: "succeeded";
 }>;
 export type ArtifactRunStatus = z.infer<typeof ArtifactRunStatusSchema>;
 export declare const ArtifactRunSchema: z.ZodObject<{
@@ -91,8 +91,8 @@ export declare const ArtifactRunSchema: z.ZodObject<{
     }>;
     status: z.ZodEnum<{
         running: "running";
-        succeeded: "succeeded";
         failed: "failed";
+        succeeded: "succeeded";
     }>;
     startedAt: z.ZodString;
     endedAt: z.ZodNullable<z.ZodString>;
@@ -114,8 +114,8 @@ export declare const StoredArtifactSchema: z.ZodObject<{
     starred: z.ZodBoolean;
     status: z.ZodEnum<{
         error: "error";
-        generating: "generating";
         ready: "ready";
+        generating: "generating";
     }>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
@@ -137,8 +137,8 @@ export declare const StoredArtifactSchema: z.ZodObject<{
         }>;
         status: z.ZodEnum<{
             running: "running";
-            succeeded: "succeeded";
             failed: "failed";
+            succeeded: "succeeded";
         }>;
         startedAt: z.ZodString;
         endedAt: z.ZodNullable<z.ZodString>;

package/dist/browser-automation/rpc-schemas.d.ts

@@ -482,8 +482,8 @@ export declare const BrowserAutomationWaitResultSchema: z.ZodObject<{
     command: z.ZodLiteral<"wait">;
     browserId: z.ZodString;
     matched: z.ZodEnum<{
-        text: "text";
         url: "url";
+        text: "text";
     }>;
 }, z.core.$strip>;
 export declare const BrowserAutomationTypeResultSchema: z.ZodObject<{
@@ -715,8 +715,8 @@ export declare const BrowserAutomationResultSchema: z.ZodDiscriminatedUnion<[z.Z
     command: z.ZodLiteral<"wait">;
     browserId: z.ZodString;
     matched: z.ZodEnum<{
-        text: "text";
         url: "url";
+        text: "text";
     }>;
 }, z.core.$strip>, z.ZodObject<{
     command: z.ZodLiteral<"type">;
@@ -1122,8 +1122,8 @@ export declare const BrowserAutomationExecuteResponseSchema: z.ZodObject<{
             command: z.ZodLiteral<"wait">;
             browserId: z.ZodString;
             matched: z.ZodEnum<{
-                text: "text";
                 url: "url";
+                text: "text";
             }>;
         }, z.core.$strip>, z.ZodObject<{
             command: z.ZodLiteral<"type">;

package/dist/default-personalities.d.ts

@@ -1,3 +1,4 @@
-import type { AgentPersonality } from "./messages.js";
+import type { AgentPersonality, AgentTeam } from "./messages.js";
 export declare const DEFAULT_AGENT_PERSONALITIES: readonly AgentPersonality[];
+export declare const DEFAULT_AGENT_TEAMS: readonly AgentTeam[];
 //# sourceMappingURL=default-personalities.d.ts.map