feat: live user skill catalog refresh, streaming and session-list fixes

.changeset/anthropic-undefined-model.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Fix a crash when a model config entry lacks its model name.

.changeset/background-env-bindings.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Add environment variable overrides for the background Bash task timeout and the print-mode background policy.

.changeset/cron-replay-boundaries.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Fix slow resume replay for sessions with many cron turns.

.changeset/session-index-stray-files.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Fix recent sessions missing from the session list when the sessions folder contains stray files.

.changeset/warn-trust-gated-mcp.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Warn in print mode when an untrusted folder skips project-level MCP servers.

.changeset/watch-user-skill-roots.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": minor
+---
+
+Refresh the skill catalog automatically when user-level skills are created, changed, or deleted while Pythinker Code is running.

apps/pythinker-code/src/cli/sub/web/remote-control.ts

@@ -128,7 +128,7 @@ export type RemoteControlStatus =
 export interface RemoteControlOptions {
   readonly homeDir: string;
   readonly localOrigin: string;
-  readonly localServerToken: string;
+  readonly localServerToken: string | (() => string);
   readonly relayKey: string;
   readonly relayOrigin?: string;
   readonly stderr?: Pick<NodeJS.WriteStream, 'write'>;
@@ -340,7 +340,10 @@ function scriptStringLiteral(value: string): string {
 export async function startRemoteControl(
   options: RemoteControlOptions,
 ): Promise<RemoteControlHandle> {
-  if (options.localServerToken.length === 0) {
+  const tokenOption = options.localServerToken;
+  const resolveServerToken: () => string =
+    typeof tokenOption === 'function' ? tokenOption : () => tokenOption;
+  if (resolveServerToken().length === 0) {
     throw new Error('Remote Control requires local server authentication.');
   }
   if (options.relayKey.length === 0) {
@@ -359,6 +362,7 @@ export async function startRemoteControl(
   });
   const client = new RemoteControlClient({
     ...options,
+    localServerToken: resolveServerToken,
     relayOrigin,
     deviceId,
     relayToken: options.relayKey,
@@ -374,15 +378,18 @@ export async function startRemoteControl(
     deviceName,
     url,
     close: async () => {
-      await client.close();
-      await lock.release();
+      try {
+        await client.close();
+      } finally {
+        await lock.release();
+      }
     },
   };
 }
 
 class RemoteControlClient {
   private readonly localOrigin: string;
-  private readonly localServerToken: string;
+  private readonly localServerToken: () => string;
   private readonly relayOrigin: string;
   private readonly deviceId: string;
   private readonly relayToken: string;
@@ -410,6 +417,7 @@ class RemoteControlClient {
       readonly relayOrigin: string;
       readonly deviceId: string;
       readonly relayToken: string;
+      readonly localServerToken: () => string;
     },
   ) {
     this.localOrigin = options.localOrigin.replace(/\/+$/, '');
@@ -654,7 +662,7 @@ class RemoteControlClient {
       const response = await requestLocalHttp(
         this.localOrigin,
         parsed,
-        this.localServerToken,
+        this.localServerToken(),
         this.publicPrefix(),
       );
       this.sendHttpResponse(requestId, response);
@@ -693,7 +701,7 @@ class RemoteControlClient {
     try {
       local = await connectWebSocket(
         localWebSocketUrl(this.localOrigin, path),
-        this.localServerToken,
+        this.localServerToken(),
         relayHeaders(payload['headers']),
         earlyLocalFrames,
       );

apps/pythinker-code/src/cli/sub/web/run.ts

@@ -259,7 +259,7 @@ export async function handleWebCommand(
         remoteControl = await (deps.startRemoteControl ?? startRemoteControl)({
           homeDir: dataDir,
           localOrigin: origin,
-          localServerToken: token,
+          localServerToken: () => deps.resolveToken?.() ?? '',
           relayKey,
           relayOrigin,
           stderr: deps.stderr,

apps/pythinker-code/src/cli/v2/run-v2-print.ts

@@ -30,7 +30,9 @@ import {
   IBootstrapService,
   IConfigService,
   IEventBus,
+  IHostFileSystem,
   ISessionIndex,
+  IWorkspaceInstanceManager,
   ISessionManager,
   ITelemetryService,
   PRINT_MAX_TURNS_DEFAULT,
@@ -54,8 +56,13 @@ import {
   type ISessionScopeHandle,
   type LoopRunResult,
   type PrintBackgroundMode,
+  type McpServerConfig,
   type Scope,
 } from '@pymodel/agent-core-v2';
+import {
+  loadMcpServersDetailed,
+  resolveMcpJsonPaths,
+} from '@pymodel/agent-core-v2/app/mcpConfig/configLoader';
 import { createPythinkerDefaultHeaders, createPythinkerDeviceId } from '@pymodel/pythinker-code-oauth';
 import type { GoalUpdated } from '@pymodel/agent-core-v2/features/goal/goalOps';
 import type { TurnEnded } from '@pymodel/agent-core-v2/agent/loop/turnOps';
@@ -217,6 +224,13 @@ export async function runV2Print(
       );
     }
 
+    try {
+      const gated = await listTrustGatedMcpServers(app, workDir, homeDir);
+      if (gated.length > 0) stderr.write(formatTrustGatedMcpWarning(gated));
+    } catch {
+      // Best-effort: a broken mcp.json or trust store must not fail the run.
+    }
+
     const resolved = await resolveNativeSession(app, opts, workDir, defaultModel, stderr);
     restorePermission = resolved.restorePermission;
 
@@ -266,6 +280,49 @@ interface ResolvedNativeSession {
   readonly goalModel: string | undefined;
 }
 
+export interface TrustGatedMcpServer {
+  readonly name: string;
+  readonly target: string;
+}
+
+export async function listTrustGatedMcpServers(
+  app: Scope,
+  workDir: string,
+  homeDir: string,
+): Promise<readonly TrustGatedMcpServer[]> {
+  const workspace = await app.accessor
+    .get(IWorkspaceInstanceManager)
+    .getOrCreate({ root: workDir });
+  if (await workspace.program.trust.get()) return [];
+  const fs = app.accessor.get(IHostFileSystem);
+  const [paths, loaded] = await Promise.all([
+    resolveMcpJsonPaths({ fs, cwd: workDir, homeDir }),
+    loadMcpServersDetailed({ fs, cwd: workDir, homeDir, includeProject: true }),
+  ]);
+  const projectPaths = new Set([paths.projectRoot, paths.project]);
+  return Object.entries(loaded.servers)
+    .filter(([name]) => projectPaths.has(loaded.origins[name] ?? ''))
+    .map(([name, config]) => ({ name, target: describeMcpTarget(config) }))
+    .toSorted((a, b) => a.name.localeCompare(b.name));
+}
+
+export function formatTrustGatedMcpWarning(servers: readonly TrustGatedMcpServer[]): string {
+  const noun = servers.length === 1 ? 'server' : 'servers';
+  const list = servers.map((server) => `${server.name} (${server.target})`).join(', ');
+  return (
+    `Warning: this folder is not trusted; skipped ${servers.length} project-level MCP ${noun}: ${list}.\n` +
+    '  Run `pythinker` here and choose "Trust this folder" to enable them.\n\n'
+  );
+}
+
+function describeMcpTarget(config: McpServerConfig): string {
+  if (config.transport === 'stdio') {
+    const args = config.args === undefined ? '' : ` ${config.args.join(' ')}`;
+    return `stdio: ${config.command}${args}`;
+  }
+  return `${config.transport}: ${config.url}`;
+}
+
 async function resolveNativeSession(
   app: Scope,
   opts: CLIOptions,

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

@@ -93,7 +93,7 @@ export async function handleRemoteControlCommand(host: SlashCommandHost): Promis
           remoteControl = await startRemoteControl({
             homeDir: dataDir,
             localOrigin: origin,
-            localServerToken: token,
+            localServerToken: () => tryResolveServerToken(dataDir) ?? '',
             relayKey,
             relayOrigin,
             onStatus,

apps/pythinker-code/src/utils/usage/debug-timing.ts

@@ -24,6 +24,7 @@ export interface StepTimingInput {
    */
   readonly llmServerDecodeMs?: number;
   readonly llmClientConsumeMs?: number;
+  readonly llmClientBlockedMs?: number;
   readonly usage?: DebugTokenUsage;
 }
 
@@ -119,7 +120,9 @@ function formatDecodeSplit(input: StepTimingInput): string {
   const server = input.llmServerDecodeMs;
   const client = input.llmClientConsumeMs;
   if (server === undefined || client === undefined) return '';
-  return `; server ${formatDuration(server)} + client ${formatDuration(client)}`;
+  const blocked = input.llmClientBlockedMs;
+  const blockedPart = blocked === undefined ? '' : ` (busy ${formatDuration(blocked)})`;
+  return `; server ${formatDuration(server)}${blockedPart} + client ${formatDuration(client)}`;
 }
 
 function formatDuration(ms: number): string {

apps/pythinker-code/test/cli/run-v2-print.test.ts

@@ -4,9 +4,11 @@ import { describe, expect, it, vi } from 'vitest';
 import {
   applyPrintBackgroundPolicy,
   createPrintTurnEndings,
+  formatTrustGatedMcpWarning,
   PrintSteeredTurnFailedError,
   type PrintTurnEnding,
   type PrintTurnEndings,
+  type TrustGatedMcpServer,
 } from '#/cli/v2/run-v2-print';
 
 function ending(
@@ -502,3 +504,23 @@ describe('createPrintTurnEndings', () => {
     await expect(pending).resolves.toMatchObject({ turnId: 7 });
   });
 });
+
+describe('formatTrustGatedMcpWarning', () => {
+  it('singularizes the noun for one skipped server', () => {
+    const text = formatTrustGatedMcpWarning([
+      { name: 'fs', target: 'stdio: node server.js' },
+    ]);
+    expect(text).toContain('skipped 1 project-level MCP server: fs (stdio: node server.js).');
+    expect(text).toContain('"Trust this folder"');
+  });
+
+  it('pluralizes and joins multiple skipped servers', () => {
+    const servers: readonly TrustGatedMcpServer[] = [
+      { name: 'api', target: 'http: https://example.test/mcp' },
+      { name: 'fs', target: 'stdio: node server.js' },
+    ];
+    const text = formatTrustGatedMcpWarning(servers);
+    expect(text).toContain('skipped 2 project-level MCP servers:');
+    expect(text).toContain('api (http: https://example.test/mcp), fs (stdio: node server.js)');
+  });
+});

apps/pythinker-code/test/cli/web/remote-control.test.ts

@@ -629,6 +629,57 @@ describe('Remote Control tunnel', () => {
     expect(logs).toContain('DEPLOYING');
     expect(handle.url).toContain('?rc=1&from=pythinker_code_cli');
   }, 15_000);
+  it('re-reads the local server token on every forwarded request', async () => {
+    const homeDir = createRemoteControlHome();
+    const relayToken = RELAY_TOKEN;
+    const relay = await startAuthRelay();
+    let handle: RemoteControlHandle | undefined;
+    cleanups.push(async () => handle?.close());
+
+    const authorizationHeaders: string[] = [];
+    const localServer = createServer((_request, response) => {
+      authorizationHeaders.push(String(_request.headers.authorization));
+      response.writeHead(200, { 'Content-Type': 'text/plain' });
+      response.end('ok');
+    });
+    const localPort = await listen(localServer);
+    cleanups.push(() => closeServer(localServer));
+
+    let currentToken = 'local-server-token';
+    handle = await startRemoteControl({
+      homeDir,
+      localOrigin: `http://127.0.0.1:${localPort}`,
+      localServerToken: () => currentToken,
+      relayKey: relayToken,
+      relayOrigin: `http://127.0.0.1:${relay.port}/coding-relay`,
+      stderr: { write: () => true },
+    });
+
+    const rawRequest = Buffer.from('GET / HTTP/1.1\r\nHost: relay.test\r\n\r\n');
+    const forward = async (): Promise<void> => {
+      const responsePromise = nextJsonMessage(relay.httpSockets.at(-1)!);
+      relay.httpSockets.at(-1)!.send(
+        JSON.stringify({
+          request_id: `request-${String(authorizationHeaders.length)}`,
+          type: 'request',
+          is_last: true,
+          body_base64: rawRequest.toString('base64'),
+        }),
+      );
+      await responsePromise;
+    };
+
+    await forward();
+    expect(authorizationHeaders).toEqual(['Bearer local-server-token']);
+
+    currentToken = 'rotated-server-token';
+    await forward();
+    expect(authorizationHeaders).toEqual([
+      'Bearer local-server-token',
+      'Bearer rotated-server-token',
+    ]);
+  });
+
 });
 
 describe('Remote Control single-instance lock', () => {

apps/pythinker-code/test/cli/web/web.test.ts

@@ -497,9 +497,13 @@ describe('`pythinker web` opens the browser', () => {
       expect.objectContaining({
         relayOrigin: 'https://relay.example.test',
         relayKey: 'relay-key-1',
-        localServerToken: 'tok-1',
+        localServerToken: expect.any(Function),
       }),
     );
+    const options = (startRemoteControl.mock.calls as unknown as[
+      [{ localServerToken: () => string }],
+    ])[0]?.[0];
+    expect(options?.localServerToken()).toBe('tok-1');
   });
 
   it('refuses to start Remote Control without a relay key', async () => {

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

@@ -246,9 +246,11 @@ describe('handleRemoteControlCommand', () => {
         expect.objectContaining({
           homeDir: dataDir,
           localOrigin: 'http://127.0.0.1:58627',
-          localServerToken: 'local-server-token',
+          localServerToken: expect.any(Function),
         }),
       );
+      const options = mocks.startRemoteControl.mock.calls[0]?.[0];
+      expect(options.localServerToken()).toBe('local-server-token');
       expect(mocks.openUrl).toHaveBeenCalledWith(sessionUrl);
       const written = writeSpy.mock.calls.map((call) => String(call[0])).join('');
       expect(written).toContain('Pythinker Remote Control ready');

apps/pythinker-code/test/utils/usage/debug-timing.test.ts

@@ -27,6 +27,20 @@ describe('formatStepDebugTiming', () => {
     expect(result).toBe('[Debug] TTFT: 800ms | TPS: 40.0 tok/s (200 tokens in 5.0s)');
   });
 
+  it('appends the blocked share to the decode split when present', () => {
+    const result = formatStepDebugTiming({
+      llmFirstTokenLatencyMs: 800,
+      llmStreamDurationMs: 6000,
+      llmServerDecodeMs: 6000,
+      llmClientConsumeMs: 25,
+      llmClientBlockedMs: 4875,
+      usage: { output: 216 },
+    });
+    expect(result).toBe(
+      '[Debug] TTFT: 800ms | TPS: 36.0 tok/s (216 tokens in 6.0s; server 6.0s (busy 4.9s) + client 25ms)',
+    );
+  });
+
   it('formats input tokens and cache read/write counts', () => {
     const result = formatStepDebugTiming({
       llmFirstTokenLatencyMs: 800,

apps/vis/web/src/components/analysis/TimelineTab.tsx

@@ -307,9 +307,10 @@ function StepRow({ step, turnDurationMs }: { step: StepNode; turnDurationMs?: nu
         {step.llmServerDecodeMs !== undefined && step.llmClientConsumeMs !== undefined ? (
           <span
             className="text-fg-3 tabular"
-            title="decode window split (server awaiting parts + client processing parts)"
+            title="decode window split (server awaiting parts + client processing parts; busy = event loop busy with other work)"
           >
             decode {step.llmServerDecodeMs}+{step.llmClientConsumeMs}ms
+            {step.llmClientBlockedMs !== undefined ? ` (busy ${step.llmClientBlockedMs}ms)` : ''}
           </span>
         ) : null}
         {step.contextTokens !== undefined ? (