fix: address PR review findings

Author: elkaix

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

@@ -200,7 +200,10 @@ export const BUILTIN_SLASH_COMMANDS = [
     description: 'Show or control the second-opinion advisor',
     priority: 95,
     completeArgs: advisorArgumentCompletions,
-    availability: (args) => args.trim().toLowerCase() === 'status' ? 'always' : 'idle-only',
+    availability: (args) => {
+      const verb = args.trim().toLowerCase();
+      return verb === '' || verb === 'status' ? 'always' : 'idle-only';
+    },
   },
   {
     name: 'provider',

apps/pythinker-code/src/tui/components/chrome/transcript-container.ts

@@ -10,12 +10,6 @@ import {
 
 export type { TranscriptChildMetadata, TranscriptChildRole } from '../../utils/transcript-component-metadata';
 
-interface RenderedChild {
-  readonly child: Component;
-  readonly metadata: TranscriptChildMetadata;
-  readonly rows: readonly string[];
-}
-
 export class TranscriptContainer extends GutterContainer {
   private readonly leftGutter: number;
   private readonly rightGutter: number;
@@ -66,78 +60,58 @@ export class TranscriptContainer extends GutterContainer {
       throw new Error('Transcript child was added without metadata');
     }
     const inner = Math.max(1, width - this.leftGutter - this.rightGutter);
-    const following = this.children.slice(index + 1).map((followingChild) => {
+    let rows = 0;
+    let previousDurable = isDurable(metadata.role);
+    for (let childIndex = index + 1; childIndex < this.children.length; childIndex += 1) {
+      const followingChild = this.children[childIndex]!;
       const followingMetadata = getTranscriptChildMetadata(followingChild);
       if (followingMetadata === undefined) {
         throw new Error('Transcript child was added without metadata');
       }
-      return {
-        child: followingChild,
-        metadata: followingMetadata,
-        rows: this.normalizeRows(followingChild.render(inner), followingMetadata),
-      };
-    });
-    const firstVisible = following.find((segment) => segment.rows.length > 0);
-    const separator =
-      firstVisible !== undefined &&
-      isDurable(metadata.role) &&
-      isDurable(firstVisible.metadata.role)
-        ? 1
-        : 0;
-    return separator + this.rowsForSegments(following).length;
+      const followingRows = this.normalizeRows(
+        followingChild.render(inner),
+        followingMetadata,
+      );
+      if (followingRows.length === 0) continue;
+      if (previousDurable && isDurable(followingMetadata.role)) rows += 1;
+      rows += followingRows.length;
+      previousDurable = isDurable(followingMetadata.role);
+    }
+    return rows;
   }
 
   override render(width: number): string[] {
-    return this.rowsForSegments(this.renderedChildren(width)).map((row) => {
-      return ' '.repeat(this.leftGutter) + row;
-    });
-  }
-
-
-  private renderedChildren(width: number): RenderedChild[] {
     const inner = Math.max(1, width - this.leftGutter - this.rightGutter);
-    return this.children.map((child) => {
+    const lead = ' '.repeat(this.leftGutter);
+    const rows: string[] = [];
+    let hasVisible = false;
+    let previousDurable = false;
+    for (const child of this.children) {
       const metadata = getTranscriptChildMetadata(child);
       if (metadata === undefined) {
         throw new Error('Transcript child was added without metadata');
       }
-      return {
-        child,
-        metadata,
-        rows: this.normalizeRows(child.render(inner), metadata),
-      };
-    });
+      const childRows = this.normalizeRows(child.render(inner), metadata);
+      if (childRows.length === 0) continue;
+      if (hasVisible && previousDurable && isDurable(metadata.role)) rows.push(lead);
+      for (const row of childRows) rows.push(lead + row);
+      hasVisible = true;
+      previousDurable = isDurable(metadata.role);
+    }
+    return rows;
   }
 
   private normalizeRows(
     rows: readonly string[],
     metadata: TranscriptChildMetadata,
   ): readonly string[] {
-    if (metadata.edgeBlankPolicy === 'preserve') return [...rows];
+    if (metadata.edgeBlankPolicy === 'preserve') return rows;
     let start = 0;
     let end = rows.length;
     while (start < end && isPlainBlank(rows[start]!)) start += 1;
     while (end > start && isPlainBlank(rows[end - 1]!)) end -= 1;
     return rows.slice(start, end);
   }
-
-  private rowsForSegments(segments: readonly RenderedChild[]): string[] {
-    const rows: string[] = [];
-    const visibleSegments = segments.filter((segment) => segment.rows.length > 0);
-    for (let index = 0; index < visibleSegments.length; index += 1) {
-      const segment = visibleSegments[index]!;
-      rows.push(...segment.rows);
-      const next = visibleSegments[index + 1];
-      if (
-        next !== undefined &&
-        isDurable(segment.metadata.role) &&
-        isDurable(next.metadata.role)
-      ) {
-        rows.push('');
-      }
-    }
-    return rows;
-  }
 }
 
 function isPlainBlank(value: string): boolean {

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

@@ -78,7 +78,7 @@ describe('handleAdvisorCommand', () => {
     const { host, advisor, securityStatus } = makeHost();
     advisor.setEnabled.mockResolvedValueOnce([{ ...securityStatus, enabled: false }]);
 
-    await handleAdvisorCommand(host, 'off security');
+    await handleAdvisorCommand(host, 'toggle security');
 
     expect(advisor.setEnabled).toHaveBeenCalledWith(false, 'security');
     expect(host.showStatus).toHaveBeenCalledWith('Advisor security disabled.');

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

@@ -100,6 +100,15 @@ describe('built-in slash command registry', () => {
       { value: 'status', label: 'status', description: 'Show Fast mode status' },
     ]);
   });
+  it('keeps advisor status and the omitted verb available while busy', () => {
+    const advisor = findBuiltInSlashCommand('advisor');
+    expect(advisor).toBeDefined();
+    expect(resolveSlashCommandAvailability(advisor!, '')).toBe('always');
+    expect(resolveSlashCommandAvailability(advisor!, 'status')).toBe('always');
+    expect(resolveSlashCommandAvailability(advisor!, 'on')).toBe('idle-only');
+    expect(resolveSlashCommandAvailability(advisor!, 'off')).toBe('idle-only');
+  });
+
 
   it('marks plan clear as idle-only while normal plan toggles are always available', () => {
     const plan = findBuiltInSlashCommand('plan');

apps/pythinker-code/test/tui/components/chrome/transcript-container.test.ts

@@ -42,15 +42,15 @@ describe('TranscriptContainer', () => {
 
   it('preserves ANSI blank rows and does not invent gaps around ephemeral children', () => {
     const container = new TranscriptContainer(1, 1);
-    const first = new StubLines(['', '\u001b[48;5;1m  \u001b[0m', 'first', '']);
+    const first = new StubLines(['', '\u001B[48;5;1m  \u001B[0m', 'first', '']);
     const status = new StubLines(['status']);
     const second = new StubLines(['', 'second']);
 
     container.addTranscriptChild(first, durable);
     container.addTranscriptChild(status, ephemeral);
     container.addTranscriptChild(second, durable);
     expect(container.render(20)).toEqual([
-      ' \u001b[48;5;1m  \u001b[0m',
+      ' \u001B[48;5;1m  \u001B[0m',
       ' first',
       ' status',
       ' second',

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

@@ -9,6 +9,7 @@ import {
 } from '#/tui/components/messages/dynamic-workflow-mission-control';
 import {
   BRAILLE_SPINNER_FRAMES,
+  DYNAMIC_WORKFLOW_RENDERING,
   BRAILLE_SPINNER_INTERVAL_MS,
 } from '#/tui/constant/rendering';
 import { currentTheme, darkColors } from '#/tui/theme';
@@ -674,12 +675,8 @@ describe('DynamicWorkflowMissionControlComponent', () => {
       component.registerSubagent({ agentId: 'agent-1' });
       component.markStarted('agent-1');
 
-      for (const [time, glyph] of [
-        [0, BRAILLE_SPINNER_FRAMES[0]],
-        [300, BRAILLE_SPINNER_FRAMES[1]],
-        [600, BRAILLE_SPINNER_FRAMES[2]],
-        [900, BRAILLE_SPINNER_FRAMES[3]],
-      ] as const) {
+      for (const [index, glyph] of BRAILLE_SPINNER_FRAMES.slice(0, 4).entries()) {
+        const time = index * DYNAMIC_WORKFLOW_RENDERING.progressFrameMs;
         vi.setSystemTime(time);
         const line = component.render(100).find((candidate) => strip(candidate).includes('001'));
         expect(line).toContain(chalk.hex(darkColors.primary)(glyph));

packages/agent-core/src/agent/compaction/micro.ts

@@ -94,15 +94,18 @@ export class MicroCompaction {
     }
   }
 
-  compact(messages: readonly ContextMessage[]): readonly ContextMessage[] {
+  compact(
+    messages: readonly ContextMessage[],
+    offset = 0,
+  ): readonly ContextMessage[] {
     if (!this.agent.experimentalFlags.enabled('micro_compaction')) return messages;
 
     const config = this.config;
     const result: ContextMessage[] = [];
     let i = 0;
     for (const msg of messages) {
       if (
-        i < this.cutoff &&
+        i + offset < this.cutoff &&
         msg.role === 'tool' &&
         msg.toolCallId !== undefined &&
         estimateTokensForContentParts(msg.content) >= config.minContentTokens

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

@@ -290,8 +290,8 @@ export class ContextMemory {
     return this._historyRevision;
   }
 
-  project(messages: readonly ContextMessage[]): Message[] {
-    return project(this.agent.microCompaction.compact(messages));
+  project(messages: readonly ContextMessage[], offset = 0): Message[] {
+    return project(this.agent.microCompaction.compact(messages, offset));
   }
 
   get messages(): Message[] {

packages/agent-core/src/session/advisor-config.ts

@@ -3,6 +3,7 @@ import { homedir } from 'node:os';
 import path from 'node:path';
 import { load as loadYaml } from 'js-yaml';
 import { isPlainRecord } from '../agent/turn/canonical-args';
+import { findProjectRoot } from '../skill/scanner';
 
 export interface AdvisorConfigEntry {
   readonly name: string;
@@ -57,8 +58,8 @@ interface AdvisorConfigDocumentEntry {
 export function slugifyAdvisorName(name: string): string {
   const slug = name
     .toLowerCase()
-    .replace(/[^a-z0-9]+/gu, '-')
-    .replace(/^-+|-+$/gu, '');
+    .replaceAll(/[^a-z0-9]+/gu, '-')
+    .replaceAll(/^-+|-+$/gu, '');
   return slug.length === 0 ? 'advisor' : slug;
 }
 
@@ -189,41 +190,55 @@ async function collectConfigCandidates(
     }
   }
 
+  const projectRoot = await findProjectRoot(resolvedCwd);
   const projectDirs: string[] = [];
   let current = resolvedCwd;
   while (true) {
     projectDirs.push(current);
+    if (current === projectRoot) break;
     const parent = path.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   projectDirs.reverse();
   for (const [depth, directory] of projectDirs.entries()) {
     for (const fileName of fileNames) {
-      candidates.push({ path: path.join(directory, fileName), user: false, depth });
-      candidates.push({ path: path.join(directory, '.omp', fileName), user: false, depth });
+      candidates.push(
+        { path: path.join(directory, fileName), user: false, depth },
+        { path: path.join(directory, '.omp', fileName), user: false, depth },
+      );
     }
   }
 
   const unique = new Map<string, (typeof candidates)[number]>();
   for (const candidate of candidates) unique.set(path.resolve(candidate.path), candidate);
+  const results = await Promise.all(
+    [...unique.values()].map(async (candidate) => {
+      try {
+        const content = await readFile(candidate.path, 'utf8');
+        return { candidate, content };
+      } catch (error) {
+        if (isMissingFile(error)) return undefined;
+        return { candidate, error };
+      }
+    }),
+  );
   const readable: ConfigCandidate[] = [];
-  for (const candidate of unique.values()) {
-    try {
-      const content = await readFile(candidate.path, 'utf8');
-      readable.push({
-        ...candidate,
-        path: path.resolve(candidate.path),
-        fileName: path.basename(candidate.path),
-        content,
-      });
-    } catch (error) {
-      if (isMissingFile(error)) continue;
+  for (const result of results) {
+    if (result === undefined) continue;
+    if ('error' in result) {
       onWarning('Advisor config could not be read', {
-        path: candidate.path,
-        error: error instanceof Error ? error.message : String(error),
+        path: result.candidate.path,
+        error: result.error instanceof Error ? result.error.message : String(result.error),
       });
+      continue;
     }
+    readable.push({
+      ...result.candidate,
+      path: path.resolve(result.candidate.path),
+      fileName: path.basename(result.candidate.path),
+      content: result.content,
+    });
   }
   readable.sort((left, right) => {
     if (left.user !== right.user) return left.user ? -1 : 1;