fix: address review findings on the workflow and mission-control changes

reloadSkills refreshed the registry but not the rendered prompt, so a workflow
saved mid-session was invocable as `/<name>` and still absent from the skill
listing the model reads. Agent gains a prompt-only re-render that leaves the
active tool set and turn limit alone, and remembers the profile its prompt was
built from so a main agent on a custom profile is not re-rendered as the default.

A member row recorded only the last line of a delta, so a provider that packed
several closed lines into one chunk lost the rest. Every closed line is now its
own event; the unclosed tail is shown but is not one.

refreshSkillCommands applied whichever listing finished last. Several callers
start it without awaiting, so a slow list for the session the user just left
could land on the one they switched to. A generation guard drops stale results,
and a failure now clears commands that belong to another session.

Applying experimental flags rebuilt the command set before reloadSession, so it
read the registry the reload was about to replace.

Also: bump the SDK for the new public reloadSkills, note the auto-mode approval
exception in the config reference, split the DynamicWorkflow reference into one
idea per paragraph, and format changelog values as code.

Author: elkaix

.changeset/saved-workflow-invocable.md

@@ -1,5 +1,6 @@
 ---
 "@pythoughts/pythinker-code": patch
+"@pythoughts/pythinker-code-sdk": minor
 ---
 
-Fix `/workflow save` leaving the saved workflow uncallable until the session was reloaded.
+Fix `/workflow save` leaving the saved workflow uncallable until the session was reloaded, and add `Session.reloadSkills()` to re-discover skills written while a session is open.

apps/pythinker-code/CHANGELOG.md

@@ -57,7 +57,7 @@
 
 - [#32](https://github.com/Pythoughts-labs/pythinker-code/pull/32) [`a504a82`](https://github.com/Pythoughts-labs/pythinker-code/commit/a504a820c4d9db14e213f4a021c86b048c4b916d) - Accept a provider's plain id for `--provider` at login, so a catalog provider no longer has to be named by its full display name, and stop a cancelled OpenAI Codex sign-in from holding the process open for the rest of its two-minute callback timeout. In the editor extension, signing in now shows one cancellable progress notification, a repeated sign-in joins the one already running instead of opening a second set of prompts, and a completed sign-in is no longer reported as failed when the status refresh behind it fails.
 
-- [#32](https://github.com/Pythoughts-labs/pythinker-code/pull/32) [`a504a82`](https://github.com/Pythoughts-labs/pythinker-code/commit/a504a820c4d9db14e213f4a021c86b048c4b916d) - 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.
+- [#32](https://github.com/Pythoughts-labs/pythinker-code/pull/32) [`a504a82`](https://github.com/Pythoughts-labs/pythinker-code/commit/a504a820c4d9db14e213f4a021c86b048c4b916d) - 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.
 
 - [#32](https://github.com/Pythoughts-labs/pythinker-code/pull/32) [`a504a82`](https://github.com/Pythoughts-labs/pythinker-code/commit/a504a820c4d9db14e213f4a021c86b048c4b916d) - Write the thinking effort picked at login to disk. The apply step recorded the level, but the patch that saved the result listed everything except it, so an API-key login still reopened at the default effort. Choosing `off` now also clears a level a previous login left behind, which a patch that only merges could not do by omitting the key.
 
@@ -127,7 +127,7 @@
 
 - [`c0f0976`](https://github.com/Pythoughts-labs/pythinker-code/commit/c0f09769e76c92002ca9b9a09d9cb820750f1046) - Remove the Pythinker Datasource plugin from the marketplace; its data gateway backend is not available, so every datasource query failed.
 
-- [`c0f0976`](https://github.com/Pythoughts-labs/pythinker-code/commit/c0f09769e76c92002ca9b9a09d9cb820750f1046) - Enable automatic updates for native installs on Windows: /update now installs the new version in the background instead of printing a manual command, and the installer safely replaces the running executable.
+- [`c0f0976`](https://github.com/Pythoughts-labs/pythinker-code/commit/c0f09769e76c92002ca9b9a09d9cb820750f1046) - Enable automatic updates for native installs on Windows: `/update` now installs the new version in the background instead of printing a manual command, and the installer safely replaces the running executable.
 
 ### Patch Changes
 

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

@@ -1198,15 +1198,18 @@ export async function applyExperimentalFeatureChanges(
     await host.harness.setConfig({ experimental });
     const features = await host.harness.getExperimentalFeatures();
     setExperimentalFeatures(features);
-    await host.refreshSkillCommands(host.session);
     host.restoreEditor();
     if (host.session !== undefined) {
       await host.session.reloadSession();
+      // After the reload, never before: a flag can gate which skills exist, so
+      // rebuilding first read the registry the reload was about to replace.
+      await host.refreshSkillCommands(host.session);
       await host.reloadCurrentSessionView(
         host.session,
         'Experimental features updated. Session reloaded.',
       );
     } else {
+      await host.refreshSkillCommands(undefined);
       host.showStatus('Experimental features updated.', 'success');
     }
     host.track('experimental_features_apply', { changed: changes.length });

apps/pythinker-code/src/tui/components/messages/dynamic-workflow-mission-control.ts

@@ -281,7 +281,6 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     const member = this.findMemberByAgentId(input.agentId);
     if (member === undefined || isTerminalPhase(member.phase) || input.delta.length === 0) return;
     this.markStarted(input.agentId);
-    const recordActivity = input.delta.includes('\n') || member.latest.length === 0;
     member.lastEventAtMs = Date.now();
     const combined = `${member.carry}${input.delta}`;
     // Only the text after the last newline is still being written. A delta that
@@ -291,7 +290,21 @@ export class DynamicWorkflowMissionControlComponent implements Component {
     const newlineIndex = combined.lastIndexOf('\n');
     const pending = newlineIndex < 0 ? combined : combined.slice(newlineIndex + 1);
     member.carry = clampLine(pending);
-    this.setLatest(member, clampLine(latestNonEmptyLine(combined)), recordActivity);
+
+    // Every line the delta closed is an event of its own. Recording only the
+    // last one dropped whole lines whenever a provider sent several in one
+    // chunk, so the same agent showed less activity on a batching provider than
+    // on one that streams a token at a time.
+    if (newlineIndex >= 0) {
+      for (const line of combined.slice(0, newlineIndex).split('\n')) {
+        this.setLatest(member, clampLine(line), true);
+      }
+    }
+    // The unclosed tail is shown but is not an event yet — except as the row's
+    // first text, which would otherwise leave the row blank until a newline.
+    if (pending.length > 0) {
+      this.setLatest(member, clampLine(pending), member.latest.length === 0);
+    }
   }
 
   markSuspended(input: {
@@ -1065,14 +1078,6 @@ function elapsedSeconds(startedAtMs: number, endedAtMs: number): number {
   return Math.floor(Math.max(0, endedAtMs - startedAtMs) / 1_000);
 }
 
-function latestNonEmptyLine(text: string): string {
-  for (const line of text.split(/\r?\n/).toReversed()) {
-    const normalized = normalizeText(line);
-    if (normalized.length > 0) return normalized;
-  }
-  return '';
-}
-
 /**
  * Keeps the head of one streamed line. The row shows the head and clips the
  * rest, so dropping the tail is invisible — and it is the only bound on a line

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

@@ -47,6 +47,7 @@ import {
   sortSlashCommands,
   type PythinkerSlashCommand,
   type SkillListSession,
+  type SkillSlashCommands,
 } from './commands';
 import {
   isExperimentalFlagEnabled,
@@ -259,6 +260,10 @@ export class PythinkerTUI {
   private readonly reverseRpcDisposers: Array<() => void> = [];
   private skillCommands: readonly PythinkerSlashCommand[] = [];
   readonly skillCommandMap = new Map<string, string>();
+  /** Bumped per refresh so a slow one cannot apply over a newer one. */
+  private skillCommandRefresh = 0;
+  /** The session whose skills the commands on screen were built from. */
+  private skillCommandSession: SkillListSession | undefined;
   private readonly imageStore = new ImageAttachmentStore();
   private fdPath: string | null = detectFdPath();
   private fdDownloadStarted = false;
@@ -438,23 +443,43 @@ export class PythinkerTUI {
    * never rebuilt from a skill list that has moved on.
    */
   async refreshSkillCommands(session?: SkillListSession): Promise<void> {
+    const refresh = (this.skillCommandRefresh += 1);
     if (session === undefined) {
+      this.skillCommandSession = undefined;
       this.skillCommands = [];
       this.skillCommandMap.clear();
       this.setupAutocomplete();
       return;
     }
 
+    let built: SkillSlashCommands | undefined;
     try {
-      const skillCommands = buildSkillSlashCommands(await session.listSkills());
-      this.skillCommands = skillCommands.commands;
-      this.skillCommandMap.clear();
-      for (const [commandName, skillName] of skillCommands.commandMap) {
-        this.skillCommandMap.set(commandName, skillName);
-      }
+      built = buildSkillSlashCommands(await session.listSkills());
     } catch {
-      // Keep the skills already known. The builtin command set may still have
-      // changed, so the autocomplete provider is rebuilt either way.
+      // What to do about a failure depends on which session the commands on
+      // screen came from, and that is only decided after the await below.
+    }
+
+    // A refresh that started later has already applied. Several callers start
+    // this without awaiting it, so a slow list for the session the user just
+    // left would otherwise land on top of the one they switched to.
+    if (refresh !== this.skillCommandRefresh) return;
+
+    if (built === undefined && this.skillCommandSession === session) {
+      // A transient failure for the session already on screen: its commands are
+      // still the right ones, so keep them. The builtin command set may still
+      // have changed, so the autocomplete provider is rebuilt either way.
+      this.setupAutocomplete();
+      return;
+    }
+
+    // Either it listed, or it failed for a session whose skills were never on
+    // screen — keeping another session's commands would be worse than none.
+    this.skillCommandSession = built === undefined ? undefined : session;
+    this.skillCommands = built?.commands ?? [];
+    this.skillCommandMap.clear();
+    for (const [commandName, skillName] of built?.commandMap ?? []) {
+      this.skillCommandMap.set(commandName, skillName);
     }
     this.setupAutocomplete();
   }

apps/pythinker-code/test/tui/commands/experiments.test.ts

@@ -88,6 +88,11 @@ describe('experimental feature command handlers', () => {
     expect(host.refreshSkillCommands).toHaveBeenCalled();
     expect(host.restoreEditor).toHaveBeenCalled();
     expect(host.session.reloadSession).toHaveBeenCalledOnce();
+    // A flag can gate which skills exist, so rebuilding the command set before
+    // the reload read the registry the reload was about to replace.
+    expect(host.session.reloadSession.mock.invocationCallOrder[0]).toBeLessThan(
+      host.refreshSkillCommands.mock.invocationCallOrder[0] ?? 0,
+    );
     expect(host.reloadCurrentSessionView).toHaveBeenCalledWith(
       host.session,
       'Experimental features updated. Session reloaded.',

apps/pythinker-code/test/tui/components/messages/dynamic-workflow-mission-control.test.ts

@@ -943,6 +943,44 @@ describe('DynamicWorkflowMissionControlComponent', () => {
     expect(line).toContain("I've read the files");
   });
 
+  it('records every line a provider packs into one delta', () => {
+    const component = createComponent();
+    component.updateArgs({ items: ['Work'] });
+    component.markInputComplete();
+    register(component, 'agent-1');
+    component.markStarted('agent-1');
+
+    // A provider that batches sends whole lines at once. Only the last one used
+    // to reach the activity list, so the same run showed less on that provider.
+    component.appendModelDelta({
+      agentId: 'agent-1',
+      delta: 'First line\nSecond line\nThird line\n',
+    });
+
+    const output = renderText(component, 200);
+    expect(output).toContain('First line');
+    expect(output).toContain('Second line');
+    expect(output).toContain('Third line');
+  });
+
+  it('does not report an unfinished line as an event of its own', () => {
+    const component = createComponent();
+    component.updateArgs({ items: ['Work'] });
+    component.markInputComplete();
+    register(component, 'agent-1');
+    component.markStarted('agent-1');
+    component.appendModelDelta({ agentId: 'agent-1', delta: 'Closed line\nstill wri' });
+
+    // The row shows the tail as it arrives, but the activity list only carries
+    // the line the delta actually closed.
+    expect(memberLine(renderText(component, 200), 1)).toContain('still wri');
+    const activity = renderText(component, 200).split('\n').filter(
+      (line) => /^│\s*001 \+/u.test(line),
+    );
+    expect(activity.join('\n')).toContain('Closed line');
+    expect(activity.join('\n')).not.toContain('still wri');
+  });
+
   it.each([64, 70, 80, 100, 200])(
     'keeps the task readable beside a long agent summary at width %i',
     (width) => {

docs/configuration/config-files.md

@@ -77,7 +77,7 @@ Fields in the config file fall into two categories: **top-level scalars** that d
 | --- | --- | --- | --- |
 | `default_model` | `string` | — | Default model alias; must be defined in `models` |
 | `default_thinking` | `boolean` | `false` | Whether new sessions enable Thinking (deep reasoning) mode by default; can be toggled from the model menu inside a session. Even when set to `true`, `[thinking].mode = "off"` will still force Thinking off |
-| `default_permission_mode` | `string` | `manual` | Default permission mode for new sessions; one of `manual` (prompt each time), `yolo` (auto-approve tool actions, but the agent may still ask questions), or `auto` (fully autonomous — the agent decides everything without asking) |
+| `default_permission_mode` | `string` | `manual` | Default permission mode for new sessions; one of `manual` (prompt each time), `yolo` (auto-approve tool actions, but the agent may still ask questions), or `auto` (fully autonomous — the agent decides everything without asking, except a `DynamicWorkflow` call, which still shows its plan for approval) |
 | `default_plan_mode` | `boolean` | `false` | Whether new sessions start in Plan mode (produce a plan before executing) by default |
 | `merge_all_available_skills` | `boolean` | `true` | Whether to merge Agent Skills from all available directories |
 | `extra_skill_dirs` | `array<string>` | — | Extra skill search directories, layered on top of the default directories |