@otto-code/cli 0.5.2 → 0.5.4

package/dist/commands/agent/run.d.ts

@@ -21,6 +21,7 @@ export interface AgentRunOptions extends CommandOptions {
     model?: string;
     thinking?: string;
     mode?: string;
+    personality?: string;
     worktree?: string;
     base?: string;
     workspace?: string;

package/dist/commands/agent/run.js

@@ -19,6 +19,7 @@ export function addRunOptions(cmd) {
         .option("--model <model>", "Model to use (e.g., claude-sonnet-4-20250514, claude-3-5-haiku-20241022)")
         .option("--thinking <id>", "Thinking option ID to use for this run")
         .option("--mode <mode>", "Provider-specific mode (e.g., plan, default, bypass)")
+        .option("--personality <name>", "Spawn as a host personality (name or id): applies its provider/model/mode and identity/prompt. Explicit --provider/--model/--mode override.")
         .option("--worktree <name>", "Create agent in a new git worktree")
         .option("--base <branch>", "Base branch for worktree (default: current branch)")
         .option("--workspace <id>", "Run in an existing workspace (default: a new workspace is created per run; falls back to $OTTO_WORKSPACE_ID)")
@@ -132,6 +133,50 @@ async function fetchStructuredOutput(caller, prompt, outputSchema) {
         throw err;
     }
 }
+// Resolve --personality (name or id) against the host roster. Returns the
+// personality's brain (provider/model/mode) to seed the run config and its id so
+// the daemon overlays the personality's identity + system prompt (e.g. the
+// orchestrator directive). Explicit --provider/--model/--mode still override.
+async function resolveRunPersonality(client, nameOrId) {
+    if (!nameOrId) {
+        return undefined;
+    }
+    const query = nameOrId.trim();
+    const { config } = await client.getDaemonConfig();
+    const roster = config.agentPersonalities?.personalities ?? [];
+    const match = roster.find((p) => p.id === query) ??
+        roster.find((p) => p.name.toLowerCase() === query.toLowerCase());
+    if (!match) {
+        const available = roster.map((p) => p.name).join(", ") || "none configured";
+        throw {
+            code: "PERSONALITY_NOT_FOUND",
+            message: `No personality matches "${query}"`,
+            details: `Available personalities: ${available}`,
+        };
+    }
+    return {
+        id: match.id,
+        provider: match.provider,
+        model: match.model,
+        ...(match.modeId ? { modeId: match.modeId } : {}),
+    };
+}
+// Resolve the agent's brain for a run: a --personality (if any) seeds
+// provider/model/mode + identity; explicit --provider/--model/--mode override.
+// Without a personality, provider stays required (resolveProviderAndModel throws).
+async function resolveRunBrain(client, options) {
+    const personality = await resolveRunPersonality(client, options.personality);
+    const providerModel = resolveProviderAndModel({
+        provider: options.provider,
+        model: options.model,
+        ...(personality ? { defaultProvider: `${personality.provider}/${personality.model}` } : {}),
+    });
+    return {
+        providerModel,
+        modeId: options.mode ?? personality?.modeId,
+        personalityId: personality?.id,
+    };
+}
 export async function resolveStructuredResponseMessage(options) {
     const direct = options.lastMessage?.trim();
     if (direct) {
@@ -336,10 +381,10 @@ export async function runRunCommand(prompt, options, _command) {
     const outputSchema = options.outputSchema ? loadOutputSchema(options.outputSchema) : undefined;
     validateRunOptions(prompt, options, outputSchema);
     const waitTimeoutMs = parseWaitTimeoutOption(options.waitTimeout);
-    const resolvedProviderModel = resolveProviderAndModel(options);
     const resolvedTitle = options.title ?? options.name;
     const client = await connectToDaemonOrThrow(options.host, host);
     try {
+        const { providerModel: resolvedProviderModel, modeId: resolvedMode, personalityId, } = await resolveRunBrain(client, options);
         // Resolve working directory
         const cwd = options.cwd ?? process.cwd();
         const thinkingOptionId = options.thinking?.trim();
@@ -367,9 +412,10 @@ export async function runRunCommand(prompt, options, _command) {
                         cwd: runCwd,
                         workspaceId,
                         title: resolvedTitle,
-                        modeId: options.mode,
+                        modeId: resolvedMode,
                         model: resolvedProviderModel.model,
                         thinkingOptionId,
+                        personality: personalityId,
                         initialPrompt: structuredPrompt,
                         outputSchema,
                         images,
@@ -421,9 +467,10 @@ export async function runRunCommand(prompt, options, _command) {
             cwd: runCwd,
             workspaceId,
             title: resolvedTitle,
-            modeId: options.mode,
+            modeId: resolvedMode,
             model: resolvedProviderModel.model,
             thinkingOptionId,
+            personality: personalityId,
             initialPrompt: prompt,
             images,
             env: requestEnv,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/cli",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Otto CLI - control your AI coding agents from the command line",
   "bin": {
     "otto": "bin/otto"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@otto-code/client": "0.5.2",
-    "@otto-code/protocol": "0.5.2",
-    "@otto-code/server": "0.5.2",
+    "@otto-code/client": "0.5.4",
+    "@otto-code/protocol": "0.5.4",
+    "@otto-code/server": "0.5.4",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",