@otto-code/protocol 0.8.14 → 0.8.16

package/dist/agent-profiles.d.ts

@@ -1,28 +1,46 @@
-import { type AgentPersonality, type PersonalityRole } from "./messages.js";
-export declare function isPersonalityRole(value: string): value is PersonalityRole;
+import { type AgentPersonality, type ProfileRole } from "./messages.js";
+export declare function isProfileRole(value: string): value is ProfileRole;
 /**
  * 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.
+ * the known set, deduped and returned in canonical `PROFILE_ROLES` order.
  * 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;
-export type PersonalityRoleTier = "coordinator" | "focused";
-interface PersonalityRoleInfo {
-    tier: PersonalityRoleTier;
+export declare function normalizeProfileRoles(roles: readonly string[] | undefined): ProfileRole[];
+export declare function profileHasRole(personality: Pick<AgentPersonality, "roles">, role: ProfileRole): boolean;
+/**
+ * Resolve one roster entry from either identifier a caller might hold.
+ *
+ * Two kinds of caller reach the roster and they hold different things. A model
+ * reads `list_agent_profiles` and passes the display name it saw. Daemon-internal
+ * callers (orchestration role resolution, a stored schedule binding) already
+ * hold the stable id and must not round-trip through a name: names carry no
+ * uniqueness constraint, so a name lookup can land on a different entry than the
+ * one the caller meant.
+ *
+ * Id is checked first because ids are opaque and unique, so an id match is never
+ * ambiguous. The exact-name pass comes before the case-insensitive one so an
+ * exact match always wins over a differently-cased near-miss.
+ */
+export declare function findProfileByRef<T extends {
+    id: string;
+    name: string;
+}>(roster: readonly T[], ref: string): T | undefined;
+export type ProfileRoleTier = "coordinator" | "focused";
+interface ProfileRoleInfo {
+    tier: ProfileRoleTier;
     guidance: string;
 }
-export declare const PERSONALITY_ROLE_INFO: Readonly<Record<PersonalityRole, PersonalityRoleInfo>>;
+export declare const PROFILE_ROLE_INFO: Readonly<Record<ProfileRole, ProfileRoleInfo>>;
 /**
  * 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;
+export declare function profileCanLaunch(personality: Pick<AgentPersonality, "roles">): boolean;
+export interface ProfileSelectionSummary {
+    tier: ProfileRoleTier;
     canLaunch: boolean;
     /** The "why you'd choose me" blurb - each of the personality's roles, joined. */
     guidance: string;
@@ -30,11 +48,11 @@ export interface PersonalitySelectionSummary {
 /**
  * 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
+ * multi-role "why choose me" blurb. Surfaced by list_agent_profiles 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 OTTO_WORK_VOCABULARY_DIRECTIVE = "Otto work vocabulary: a suggested task is deferred work for the user and does not start work; a chat is an active Otto chat session; a child chat is created by another chat; a personality profile is a reusable provider, model, mode, effort, and behavior template; an orchestration coordinates multiple chats; a schedule starts a background chat when due; a heartbeat sends a reminder or prompt and does not start a chat. Use suggest_task for concrete work to preserve for later, create_chat to start one chat now, and start_orchestration only for managed multi-chat coordination. Use list_personalities, optionally filtered by roles, before choosing a personality profile. Never substitute a harness-native agent-spawn tool for suggest_task, and when a user names an Otto tool exactly, use that exact Otto tool.";
+export declare function summarizeProfileForSelection(personality: Pick<AgentPersonality, "roles">): ProfileSelectionSummary;
+export declare const OTTO_WORK_VOCABULARY_DIRECTIVE = "Otto work vocabulary: a suggested task is deferred work for the user and does not start work; a chat is an active Otto chat session; a child chat is created by another chat; a Personality is a reusable provider, model, mode, effort, and behavior template; an orchestration coordinates multiple chats; a schedule starts a background chat when due; a heartbeat sends a reminder or prompt and does not start a chat. Use suggest_task for concrete work to preserve for later, create_chat to start one chat now, and start_orchestration only for managed multi-chat coordination. Use list_agent_profiles, optionally filtered by roles, before choosing a Personality. Never substitute a harness-native agent-spawn tool for suggest_task, and when a user names an Otto tool exactly, use that exact Otto tool.";
 export declare const ORCHESTRATOR_METHOD_DIRECTIVE: string;
 /**
  * The in-context "role directive" injected into a personality's system prompt at
@@ -45,14 +63,14 @@ export declare const ORCHESTRATOR_METHOD_DIRECTIVE: string;
  */
 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 {
+export interface ProfileAvailabilityInput {
     /** Provider snapshot status, or undefined when the provider is absent entirely. */
     providerStatus: "ready" | "loading" | "error" | "unavailable" | undefined;
     providerEnabled: boolean | undefined;
     modelIds: readonly string[] | undefined;
     modeIds: readonly string[] | undefined;
 }
-export type PersonalityAvailability = {
+export type ProfileAvailability = {
     available: true;
 } | {
     available: false;
@@ -70,10 +88,10 @@ export type PersonalityAvailability = {
  * means the provider only has to advertise SOME model; the concrete id is
  * chosen at resolution time, not here.
  */
-export declare function checkPersonalityAvailability(personality: {
+export declare function checkProfileAvailability(personality: {
     provider: string;
     model?: string | undefined;
     modeId?: string | undefined;
-}, input: PersonalityAvailabilityInput): PersonalityAvailability;
+}, input: ProfileAvailabilityInput): ProfileAvailability;
 export {};
 //# sourceMappingURL=agent-profiles.d.ts.map

package/dist/agent-profiles.js

@@ -1,9 +1,9 @@
-import { PERSONALITY_ROLES } from "./messages.js";
+import { PROFILE_ROLES } from "./messages.js";
 // Pure, dependency-free personality helpers shared by the daemon (spawn-time
 // resolution) and the app (picker availability + role filtering). Effort
 // 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);
+const ROLE_SET = new Set(PROFILE_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
@@ -12,32 +12,55 @@ const ROLE_SET = new Set(PERSONALITY_ROLES);
 const LEGACY_ROLE_ALIASES = {
     worker: "coder",
 };
-export function isPersonalityRole(value) {
+export function isProfileRole(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.
+ * the known set, deduped and returned in canonical `PROFILE_ROLES` order.
  * 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) {
+export function normalizeProfileRoles(roles) {
     if (!roles || roles.length === 0) {
         return [];
     }
     const present = new Set();
     for (const raw of roles) {
-        const canonical = LEGACY_ROLE_ALIASES[raw] ?? (isPersonalityRole(raw) ? raw : null);
+        const canonical = LEGACY_ROLE_ALIASES[raw] ?? (isProfileRole(raw) ? raw : null);
         if (canonical) {
             present.add(canonical);
         }
     }
-    return PERSONALITY_ROLES.filter((role) => present.has(role));
+    return PROFILE_ROLES.filter((role) => present.has(role));
 }
-export function personalityHasRole(personality, role) {
-    return normalizePersonalityRoles(personality.roles).includes(role);
+export function profileHasRole(personality, role) {
+    return normalizeProfileRoles(personality.roles).includes(role);
 }
-export const PERSONALITY_ROLE_INFO = {
+/**
+ * Resolve one roster entry from either identifier a caller might hold.
+ *
+ * Two kinds of caller reach the roster and they hold different things. A model
+ * reads `list_agent_profiles` and passes the display name it saw. Daemon-internal
+ * callers (orchestration role resolution, a stored schedule binding) already
+ * hold the stable id and must not round-trip through a name: names carry no
+ * uniqueness constraint, so a name lookup can land on a different entry than the
+ * one the caller meant.
+ *
+ * Id is checked first because ids are opaque and unique, so an id match is never
+ * ambiguous. The exact-name pass comes before the case-insensitive one so an
+ * exact match always wins over a differently-cased near-miss.
+ */
+export function findProfileByRef(roster, ref) {
+    const trimmed = ref.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return (roster.find((entry) => entry.id === trimmed) ??
+        roster.find((entry) => entry.name === trimmed) ??
+        roster.find((entry) => entry.name.toLowerCase() === trimmed.toLowerCase()));
+}
+export const PROFILE_ROLE_INFO = {
     // ── Surfaces ──────────────────────────────────────────────────────────────
     chatter: {
         tier: "coordinator",
@@ -93,22 +116,22 @@ export const PERSONALITY_ROLE_INFO = {
  * 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");
+export function profileCanLaunch(personality) {
+    return normalizeProfileRoles(personality.roles).some((role) => PROFILE_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
+ * multi-role "why choose me" blurb. Surfaced by list_agent_profiles 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");
+export function summarizeProfileForSelection(personality) {
+    const roles = normalizeProfileRoles(personality.roles);
+    const canLaunch = roles.some((role) => PROFILE_ROLE_INFO[role].tier === "coordinator");
     return {
         tier: canLaunch ? "coordinator" : "focused",
         canLaunch,
-        guidance: roles.map((role) => PERSONALITY_ROLE_INFO[role].guidance).join(" "),
+        guidance: roles.map((role) => PROFILE_ROLE_INFO[role].guidance).join(" "),
     };
 }
 // The conductor's standing directive - the distilled `/epic` method taught to
@@ -116,7 +139,7 @@ export function summarizePersonalityForSelection(personality) {
 // chat, a suggested task, or an orchestration by the task's actual needs rather than
 // treating orchestration as the default. Kept here as one exported constant so
 // the wording is testable and shared. See projects/agent-orchestration/agent-orchestration.md.
-export const OTTO_WORK_VOCABULARY_DIRECTIVE = "Otto work vocabulary: a suggested task is deferred work for the user and does not start work; a chat is an active Otto chat session; a child chat is created by another chat; a personality profile is a reusable provider, model, mode, effort, and behavior template; an orchestration coordinates multiple chats; a schedule starts a background chat when due; a heartbeat sends a reminder or prompt and does not start a chat. Use suggest_task for concrete work to preserve for later, create_chat to start one chat now, and start_orchestration only for managed multi-chat coordination. Use list_personalities, optionally filtered by roles, before choosing a personality profile. Never substitute a harness-native agent-spawn tool for suggest_task, and when a user names an Otto tool exactly, use that exact Otto tool.";
+export const OTTO_WORK_VOCABULARY_DIRECTIVE = "Otto work vocabulary: a suggested task is deferred work for the user and does not start work; a chat is an active Otto chat session; a child chat is created by another chat; a Personality is a reusable provider, model, mode, effort, and behavior template; an orchestration coordinates multiple chats; a schedule starts a background chat when due; a heartbeat sends a reminder or prompt and does not start a chat. Use suggest_task for concrete work to preserve for later, create_chat to start one chat now, and start_orchestration only for managed multi-chat coordination. Use list_agent_profiles, optionally filtered by roles, before choosing a Personality. Never substitute a harness-native agent-spawn tool for suggest_task, and when a user names an Otto tool exactly, use that exact Otto tool.";
 export const ORCHESTRATOR_METHOD_DIRECTIVE = "You are the orchestrator - the team's sole conductor. Choose tools because the task needs their specific capability, never because a tool is available or named. " +
     "Do a small, self-contained task directly. Use create_chat only for an independently executable piece of active work that benefits from its own chat. Use suggest_task only to preserve a concrete, out-of-scope follow-up for later. Use start_orchestration only when the active work needs a declared multi-chat plan with daemon-managed fan-out, gathering, judging, loops, or approval gates. " +
     "For work that genuinely needs orchestration: (1) if the shape is unclear, dispatch research and planning chats; (2) declare the plan with start_orchestration - phases typed research/plan/implement/design/verify/gate/deliver, fanning out 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. " +
@@ -129,7 +152,7 @@ export const ORCHESTRATOR_METHOD_DIRECTIVE = "You are the orchestrator - the tea
  * nothing. This is guidance, not a gate - the tools stay available either way.
  */
 export function composeRoleFocusDirective(roles) {
-    const normalized = normalizePersonalityRoles(roles);
+    const normalized = normalizeProfileRoles(roles);
     if (normalized.length === 0) {
         return undefined;
     }
@@ -137,10 +160,10 @@ export function composeRoleFocusDirective(roles) {
     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 when the task benefits from it: use list_personalities to see who else is available, then either do the work directly, create a child chat for an independent active piece, or hand off genuinely multi-chat work to the team's orchestrator.`;
+    if (normalized.some((role) => PROFILE_ROLE_INFO[role].tier === "coordinator")) {
+        return `You are a coordinator personality (roles: ${roleList}). You front interactive work and may delegate when the task benefits from it: use list_agent_profiles to see who else is available, then either do the work directly, create a child chat for an independent active piece, or hand off genuinely multi-chat work to the team's orchestrator.`;
     }
-    return `You are a focused 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 create child chats or start side workflows unless it is genuinely essential to completing this job.`;
+    return `You are a focused personality (roles: ${roleList}). Someone is waiting on this specific task - stay on it and finish it. You can still call list_agent_profiles to see the roster, but don't create child chats 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.
@@ -153,7 +176,7 @@ export function composeRoleFocusDirective(roles) {
  * means the provider only has to advertise SOME model; the concrete id is
  * chosen at resolution time, not here.
  */
-export function checkPersonalityAvailability(personality, input) {
+export function checkProfileAvailability(personality, input) {
     if (input.providerStatus === undefined) {
         return {
             available: false,

package/dist/agent-teams.d.ts

@@ -1,4 +1,4 @@
-import type { AgentProfile, AgentTeam, PersonalityRole } from "./messages.js";
+import type { AgentProfile, AgentTeam, ProfileRole } 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
@@ -48,9 +48,9 @@ export declare function pruneTeamMemberIds(memberIds: readonly string[] | undefi
 export declare function resolveExclusiveTeamMembers(team: Pick<AgentTeam, "memberIds"> | null | undefined, otherTeams: readonly Pick<AgentTeam, "memberIds">[] | undefined, personalities: readonly AgentProfile[] | undefined): AgentProfile[];
 /**
  * The union of all members' roles, normalized and returned in canonical
- * `PERSONALITY_ROLES` order - the team card's role-pill strip.
+ * `PROFILE_ROLES` order - the team card's role-pill strip.
  */
-export declare function teamRoleUnion(team: Pick<AgentTeam, "memberIds"> | null | undefined, personalities: readonly AgentProfile[] | undefined): PersonalityRole[];
+export declare function teamRoleUnion(team: Pick<AgentTeam, "memberIds"> | null | undefined, personalities: readonly AgentProfile[] | undefined): ProfileRole[];
 /**
  * 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).

package/dist/agent-teams.js

@@ -1,9 +1,9 @@
-import { normalizePersonalityRoles } from "./agent-profiles.js";
+import { normalizeProfileRoles } from "./agent-profiles.js";
 // Pure, dependency-free team helpers shared by the daemon (spawn-time active
-// team resolution, list_personalities scoping) and the app (team cards,
+// team resolution, list_agent_profiles 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.
+// or not, judged by checkProfileAvailability 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
@@ -100,11 +100,11 @@ export function resolveExclusiveTeamMembers(team, otherTeams, personalities) {
 }
 /**
  * The union of all members' roles, normalized and returned in canonical
- * `PERSONALITY_ROLES` order - the team card's role-pill strip.
+ * `PROFILE_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);
+    return normalizeProfileRoles(roles);
 }
 /**
  * A team prompt only stacks when it has content; a team with an empty or

package/dist/artifacts/types.js

@@ -4,7 +4,7 @@ export const ArtifactStatusSchema = z.enum(["generating", "ready", "error"]);
 // Two glow colors for the generating spinner, snapshotted from the Agent
 // Personality the artifact was generated under (BlobLoader glowA/glowB), so its
 // card spinner renders in the personality's identity. Passthrough for
-// forward-compat, mirroring AgentPersonalitySpinnerSchema in messages.ts.
+// forward-compat, mirroring AgentProfileSpinnerSchema in messages.ts.
 export const ArtifactSpinnerSchema = z
     .object({
     glowA: z.string().min(1),
@@ -35,7 +35,7 @@ export const ArtifactMetadataSchema = z.object({
     // Spinner glow colors of the Agent Personality this artifact was generated
     // under, snapshotted at create time like the provider/model above. Absent ⇒
     // the card falls back to the theme's default spinner colors. Purely additive
-    // (no daemon floor needed). See docs/agent-personalities.md.
+    // (no daemon floor needed). See docs/agent-profiles.md.
     generationSpinner: ArtifactSpinnerSchema.nullable().optional(),
     // Human name of the Agent Personality that generated (last generated) this
     // artifact, snapshotted at create/regenerate time like the provider/model

package/dist/daemon-config.js

@@ -191,7 +191,7 @@ export const MutableAgentTeamsConfigSchema = z
     // The host's active team id; null/absent = no team active (exactly legacy
     // behavior). Host-scoped daemon config rather than device-local: the team
     // prompt is applied daemon-side at spawn, so headless spawns (MCP
-    // create_agent, schedule runs) must see it, and a patch from any client
+    // create_chat, schedule runs) must see it, and a patch from any client
     // hot-reloads the switch to every connected client.
     activeTeamId: z.string().nullable().optional(),
 })

package/dist/default-personalities.js

@@ -5,7 +5,7 @@
 // restore button) import this one list so the shipped set stays identical on
 // both sides.
 //
-// Design notes (see docs/agent-personalities.md):
+// Design notes (see docs/agent-profiles.md):
 //  - 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".