@otto-code/protocol 0.5.0 → 0.5.2

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

@@ -3,7 +3,8 @@ export declare function isPersonalityRole(value: string): value is PersonalityRo
 /**
  * Filter an arbitrary role array (roles ride the wire as plain strings) down to
  * the known set, deduped and returned in canonical `PERSONALITY_ROLES` order.
- * Unknown roles from a newer peer are dropped rather than trusted.
+ * Retired role names are mapped through `LEGACY_ROLE_ALIASES`; anything else
+ * unknown (e.g. a role from a newer peer) is dropped rather than trusted.
  */
 export declare function normalizePersonalityRoles(roles: readonly string[] | undefined): PersonalityRole[];
 export declare function personalityHasRole(personality: Pick<AgentPersonality, "roles">, role: PersonalityRole): boolean;

package/dist/agent-personalities.js

@@ -4,19 +4,34 @@ import { PERSONALITY_ROLES } from "./messages.js";
 // resolution is NOT here — it needs the model's advertised thinking options and
 // lives with the daemon's effort resolver; availability does not depend on it.
 const ROLE_SET = new Set(PERSONALITY_ROLES);
+// Retired role names, mapped to their canonical replacement. "worker" was split
+// into "writer" (fast small-text generation) and "coder" (sub-agent coding); a
+// personality that still carries the old tag resolves to "coder", the closer
+// heir of what a worker did. Normalization applies these before filtering so
+// personalities persisted before the split keep a real role.
+const LEGACY_ROLE_ALIASES = {
+    worker: "coder",
+};
 export function isPersonalityRole(value) {
     return ROLE_SET.has(value);
 }
 /**
  * Filter an arbitrary role array (roles ride the wire as plain strings) down to
  * the known set, deduped and returned in canonical `PERSONALITY_ROLES` order.
- * Unknown roles from a newer peer are dropped rather than trusted.
+ * Retired role names are mapped through `LEGACY_ROLE_ALIASES`; anything else
+ * unknown (e.g. a role from a newer peer) is dropped rather than trusted.
  */
 export function normalizePersonalityRoles(roles) {
     if (!roles || roles.length === 0) {
         return [];
     }
-    const present = new Set(roles.filter(isPersonalityRole));
+    const present = new Set();
+    for (const raw of roles) {
+        const canonical = LEGACY_ROLE_ALIASES[raw] ?? (isPersonalityRole(raw) ? raw : null);
+        if (canonical) {
+            present.add(canonical);
+        }
+    }
     return PERSONALITY_ROLES.filter((role) => present.has(role));
 }
 export function personalityHasRole(personality, role) {

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;

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

package/dist/default-personalities.js

@@ -9,8 +9,11 @@
 //  - Ids are STABLE and prefixed `personality_builtin_*`. Restore re-adds only
 //    the builtins whose id is missing, so a user who kept/renamed some never
 //    gets duplicates. Renaming a builtin keeps its id, so it is still "present".
-//  - Every one of the 7 roles is covered; some personalities are multi-role to
-//    show that a single template can serve several surfaces.
+//  - Every one of the 8 roles is covered; some personalities are multi-role to
+//    show that a single template can serve several surfaces. Dash is the Writer
+//    (fast, cheap small-text generation — commit messages, summaries, branch
+//    names) and Sprocket is the Coder (methodical sub-agent building work); the
+//    two together are the heirs of the retired "worker" role.
 //  - Models are Anthropic (Claude Code) — the assumption for launch. On a host
 //    without Claude these simply show as "out of commission" until a matching
 //    provider exists; nothing breaks.
@@ -99,11 +102,11 @@ export const DEFAULT_AGENT_PERSONALITIES = [
         effortLevel: "low",
         modeId: "auto",
         respectGlobalAppendPrompt: true,
-        roles: ["worker", "scheduler"],
-        personalityPrompt: "You are Dash, the workhorse. You take well-scoped tasks and recurring jobs and just " +
-            "get them done — fast, cheaply, without ceremony. Stay on the exact task you were " +
-            "given, don't gold-plate, flag it early if the scope is bigger than it looked, and " +
-            "report back crisply when it's finished.",
+        roles: ["writer", "scheduler"],
+        personalityPrompt: "You are Dash, the workhorse scribe. You turn diffs, context, and recurring jobs into " +
+            "crisp short text — commit messages, summaries, branch names, titles — fast and cheaply, " +
+            "without ceremony. Say exactly what changed in as few words as it takes, match the house " +
+            "style you're given, never pad, and never editorialize beyond the facts in front of you.",
         spinner: { glowA: "#22C55E", glowB: "#A3E635" },
         voice: kokoroVoice("am_puck"),
     },
@@ -115,7 +118,7 @@ export const DEFAULT_AGENT_PERSONALITIES = [
         effortLevel: "medium",
         modeId: "default",
         respectGlobalAppendPrompt: true,
-        roles: ["chatter", "worker"],
+        roles: ["chatter", "coder"],
         personalityPrompt: "You are Sprocket, a friendly machine. You are precise, literal, and methodical — you " +
             "like checklists, exact steps, and confirming inputs before acting. Keep a light, dry " +
             "wit, explain what you're doing in plain terms, and when a request is ambiguous ask one " +
@@ -124,4 +127,24 @@ export const DEFAULT_AGENT_PERSONALITIES = [
         voice: kokoroVoice("am_echo"),
     },
 ];
+// The starter Agent Team shipped with Otto: every starter personality grouped
+// under one operating template. Seeded the same first-run/absent-section way
+// as the personalities (see seedDefaultTeamsIfAbsent), and re-addable from the
+// Agent teams card. Deliberately NOT active on first run — activating a
+// prompt-bearing team silently on install would change spawn behavior out
+// from under existing users; the user opts in via the Active Team switcher.
+// The stable `team_builtin_*` id makes restore idempotent, exactly like the
+// personalities' `personality_builtin_*` ids.
+export const DEFAULT_AGENT_TEAMS = [
+    {
+        id: "team_builtin_otto_crew",
+        name: "The Otto Crew",
+        avatar: { color: "#4F46E5" },
+        teamPrompt: "You are part of the Otto Crew, a coordinated team of specialists working one project " +
+            "together under Atlas's lead. Stay in your lane and trust your teammates' lanes: do your " +
+            "own role's work well, hand off cleanly with the context the next specialist needs, and " +
+            "flag anything you notice outside your remit instead of fixing it yourself.",
+        memberIds: DEFAULT_AGENT_PERSONALITIES.map((personality) => personality.id),
+    },
+];
 //# sourceMappingURL=default-personalities.js.map