fix(login,workflow): keep the output schema on retry and persist the picked effort

Two defects a review swarm surfaced, both verified against source and both
reproduced by a failing test before the fix.

A workflow subagent lost its output schema whenever a provider rate limit forced
its turn to be retried: the retry path never forwarded the schema, so the model
was not offered the StructuredOutput tool, answered in prose, and the batch
recorded it as completed rather than as a schema failure. The structured-output
contract was void on exactly the path most likely to be taken under load, with
no trace. Existing coverage only exercised the spawn path, which is why this
stayed green.

Login stored only an on/off thinking flag, so picking low, medium, or xhigh
reopened the session at high, and an OpenAI Codex login reopened at the model's
maximum effort no matter what was chosen. The level now travels with the
boolean, and a level the model does not declare is still ignored rather than
persisted. The TUI's own model picker also built its aliases by hand and dropped
the declared efforts, so it now shares the one converter.

Also adds the changesets this branch was missing: the size guideline and kill
switch, the fan-out caps, run correlation, and the ACP method rename.

Author: elkaix

.changeset/acp-login-auth-method.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": minor
+---
+
+Rename the ACP authentication method to reflect that login is multi-provider: it now reads "Log in with a provider" and explains that the provider is chosen in a terminal. Clients matching the previous wording will need updating.

.changeset/login-effort-persists.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": patch
+---
+
+Save the thinking-effort level picked during login. Only an on/off flag was stored, so choosing low, medium, or xhigh reopened the session at high, and an OpenAI Codex login reopened at the model's maximum effort regardless of the choice.

.changeset/workflow-retry-keeps-output-schema.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": patch
+---
+
+Keep a Dynamic Workflow subagent's output schema when a provider rate limit forces its turn to be retried. The retried turn lost the schema, so the subagent answered in prose and the workflow reported it as completed rather than as a schema failure.

.changeset/workflow-run-correlation.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": minor
+---
+
+Give every Dynamic Workflow run an id and stamp it on the subagent events it produces, so a client can tell which run a given subagent belongs to when several are in flight.

.changeset/workflow-size-guideline-and-kill-switch.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": minor
+---
+
+Add two ways to rein in Dynamic Workflow fan-out: `disableWorkflows` turns the tool off entirely, and `workflowSizeGuideline` sets an advisory ceiling that is mentioned to the model and warned about, on every surface, when a run exceeds it. Both are settable in config or by environment variable.

.changeset/workflow-subagent-caps.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": minor
+---
+
+Bound subagent fan-out with hard caps: 128 subagents per call, 200 per session, and a nesting depth of 3. Nesting was previously unbounded, so a workflow that spawned workflows could grow without limit; past depth 3 the call now fails instead.

apps/pythinker-code/src/tui/commands/prompts.ts

@@ -4,12 +4,12 @@ import {
   DEFAULT_CATALOG_URL,
   fetchCatalog,
   loadBuiltInCatalog,
+  managedModelToAlias,
   type Catalog,
   type CatalogModel,
   type ModelAlias,
   type PlatformSelection,
 } from '@pythoughts/pythinker-code-sdk';
-import { capabilitiesForModel } from '@pythoughts/pythinker-code-oauth';
 import type {
   ManagedKimiCodeModelInfo,
   OpenPlatformDefinition,
@@ -160,13 +160,7 @@ export async function promptModelSelectionForOpenPlatform(
 ): Promise<{ model: ManagedKimiCodeModelInfo; effort: string } | undefined> {
   const modelDict: Record<string, ModelAlias> = {};
   for (const m of models) {
-    modelDict[`${platform.id}/${m.id}`] = {
-      provider: platform.id,
-      model: m.id,
-      maxContextSize: m.contextLength,
-      capabilities: capabilitiesForModel(m),
-      displayName: m.displayName,
-    };
+    modelDict[`${platform.id}/${m.id}`] = managedModelToAlias(platform.id, m);
   }
   const selection = await runModelSelector(host, modelDict);
   if (selection === undefined) return undefined;

packages/agent-core/src/agent/turn/index.ts

@@ -191,8 +191,13 @@ export class TurnFlow {
     return this.launch(input, origin);
   }
 
-  retry(trigger?: string): number | null {
-    return this.prompt([], { kind: 'retry', trigger });
+  /**
+   * Re-runs the turn. The schema must be passed again: a retried turn builds a
+   * fresh StructuredOutputState, and without one the model is never offered the
+   * StructuredOutput tool, so a schema'd subagent would quietly answer in prose.
+   */
+  retry(trigger?: string, outputSchema?: Record<string, unknown>): number | null {
+    return this.prompt([], { kind: 'retry', trigger }, outputSchema);
   }
 
   private launch(

packages/agent-core/src/session/subagent-host.ts

@@ -312,7 +312,10 @@ export class SessionSubagentHost {
           this.childModelConfig(parent, child, this.tryResolveProfile(parent, profileName), runOptions),
         );
         this.emitSubagentStarted(parent, agentId, runOptions);
-        const turnId = child.turn.retry('agent-host');
+        // The schema has to ride along: waitForChildCompletion still branches on
+        // runOptions.outputSchema, so a retry that dropped it would skip the
+        // continuation AND find no structured output, silently yielding prose.
+        const turnId = child.turn.retry('agent-host', runOptions.outputSchema);
         if (turnId === null) {
           throw new Error(`Agent instance "${agentId}" could not start a retry turn`);
         }

packages/agent-core/test/session/subagent-host.test.ts

@@ -1646,6 +1646,65 @@ describe('SessionSubagentHost', () => {
     expect(userTextMessages(histories[1] ?? [])).toEqual(['Implement the retry-safe change']);
   });
 
+  it('keeps the output schema when a rate-limited subagent is retried', async () => {
+    const parent = testAgent();
+    parent.configure();
+    parent.newEvents();
+
+    const outputSchema = {
+      type: 'object',
+      properties: { answer: { type: 'string' } },
+      required: ['answer'],
+    };
+    const toolNamesPerCall: string[][] = [];
+    let generateCalls = 0;
+    const generate: GenerateFn = async (
+      _provider,
+      _systemPrompt,
+      tools,
+      _history,
+      callbacks,
+    ) => {
+      toolNamesPerCall.push(tools.map((tool) => tool.name));
+      generateCalls += 1;
+      if (generateCalls === 1) {
+        throw new APIStatusError(429, 'Rate limited', 'req-429');
+      }
+      // Answers in prose instead of calling StructuredOutput.
+      await callbacks?.onMessagePart?.({ type: 'text', text: 'plain prose answer' });
+      return textResult('plain prose answer');
+    };
+    const child = testAgent({
+      generate,
+      initialConfig: { providers: {}, loopControl: { maxRetriesPerStep: 1 } },
+    });
+    child.configure();
+
+    const session = fakeSession(parent.agent, child.agent);
+    const host = new SessionSubagentHost(session, 'main');
+    const retrySpy = vi.spyOn(child.agent.turn, 'retry');
+
+    const options = {
+      profileName: 'coder',
+      outputSchema,
+      parentToolCallId: 'call_agent',
+      prompt: 'Return structured output',
+      description: 'Structured task',
+      runInBackground: false,
+      signal,
+    };
+    const handle = await host.spawn(options);
+    await expect(handle.completion).rejects.toThrow('Rate limited');
+
+    const retryHandle = await host.retry(handle.agentId, options);
+
+    // Dropping the schema here used to let the retried turn answer in prose and
+    // report completed, silently voiding the structured-output contract.
+    await expect(retryHandle.completion).rejects.toThrow('structured_output.max_retries');
+    expect(retrySpy.mock.calls[0]?.[1]).toBe(outputSchema);
+    expect(toolNamesPerCall.at(-1)).toContain('StructuredOutput');
+  });
+
   it('realigns a resumed subagent to the parent agent current model', async () => {
     const parent = testAgent();
     parent.configure();