chore: land SmartPerfetto local follow-ups

Author: Gracker

AGENTS.md

@@ -68,6 +68,11 @@ logic, use Plan -> independent read-only review -> Revise -> Execute.
   Codex read-only review.
 - If the primary agent is Codex, do not call Codex to review itself. Prefer a
   read-only reviewer sub-agent/tool.
+- In ZCode/OpenCode, invoke the `codex` MCP tool for this gate. It exposes
+  `codex` (start a read-only review session; pass a review prompt with
+  `sandbox: "read-only"` and `approval-policy: "never"`) and `codex-reply`
+  (continue a session by `threadId`). Registered as `mcp.codex` in
+  `~/.zcode/v2/config.json`, backed by `codex mcp-server`.
 - If no stable reviewer is available, or the reviewer times out twice, use a
   structured self-review plus post-diff review, note the fallback, and rely on
   the relevant verification tier from `.claude/rules/testing.md`.

CLAUDE.md

@@ -68,6 +68,11 @@ logic, use Plan -> independent read-only review -> Revise -> Execute.
   Codex read-only review.
 - If the primary agent is Codex, do not call Codex to review itself. Prefer a
   read-only reviewer sub-agent/tool.
+- In ZCode/OpenCode, invoke the `codex` MCP tool for this gate. It exposes
+  `codex` (start a read-only review session; pass a review prompt with
+  `sandbox: "read-only"` and `approval-policy: "never"`) and `codex-reply`
+  (continue a session by `threadId`). Registered as `mcp.codex` in
+  `~/.zcode/v2/config.json`, backed by `codex mcp-server`.
 - If no stable reviewer is available, or the reviewer times out twice, use a
   structured self-review plus post-diff review, note the fallback, and rely on
   the relevant verification tier from `.claude/rules/testing.md`.

backend/scripts/checkTypesSync.ts

@@ -179,6 +179,7 @@ interface AnalysisQualitySyncExpectation {
   analysisCompletedHasIdentityResolutions: boolean;
   analysisCompletedHasTerminationReason: boolean;
   analysisCompletedHasTerminationMessage: boolean;
+  analysisCompletedHasTerminalRunStatus: boolean;
   claimReferencesHaveArtifactIds: boolean;
 }
 
@@ -248,6 +249,7 @@ function extractAnalysisQualityExpectations(content: string): AnalysisQualitySyn
     analysisCompletedHasIdentityResolutions: /\bidentityResolutions\s*\?:\s*IdentityResolutionV1\[\]\s*;/.test(analysisCompletedBlock),
     analysisCompletedHasTerminationReason: /\bterminationReason\s*\?:\s*string\s*;/.test(analysisCompletedBlock),
     analysisCompletedHasTerminationMessage: /\bterminationMessage\s*\?:\s*string\s*;/.test(analysisCompletedBlock),
+    analysisCompletedHasTerminalRunStatus: /\bterminalRunStatus\s*\?:\s*'completed'\s*\|\s*'quota_exceeded'\s*;/.test(analysisCompletedBlock),
     claimReferencesHaveArtifactIds:
       /\bartifactId\s*\?:\s*string\s*;/.test(claimRefBlock) &&
       /\bsourceArtifactId\s*\?:\s*string\s*;/.test(claimRefBlock),

backend/scripts/generateFrontendTypes.ts

@@ -643,6 +643,7 @@ export interface AnalysisCompletedEvent {
     partial?: boolean;
     terminationReason?: string;
     terminationMessage?: string;
+    terminalRunStatus?: 'completed' | 'quota_exceeded';
     findings: DiagnosticFinding[];
     suggestions: string[];
   };

backend/src/agent/core/executors/__tests__/hypothesisExecutor.test.ts

@@ -281,7 +281,7 @@ describe('HypothesisExecutor', () => {
 
       expect(result.rounds).toBe(1);
       expect(result.findings).toHaveLength(1);
-      expect(result.stopReason).toBeNull();
+      expect(result.stopReason).toBe('Strategy concluded');
       expect(services.circuitBreaker.canExecute).toHaveBeenCalled();
       expect(services.circuitBreaker.recordIteration).toHaveBeenCalledWith('hypothesis_loop');
       expect(services.messageBus.dispatchTasksParallel).toHaveBeenCalled();
@@ -457,6 +457,47 @@ describe('HypothesisExecutor', () => {
       expect(services.messageBus.updateHypothesis).toHaveBeenCalled();
     });
 
+    it('records a stop reason when the strategy planner concludes', async () => {
+      const ctx = createMockExecutionContext();
+      strategyPlanner.planNextIteration.mockResolvedValue({
+        strategy: 'conclude',
+        confidence: 0.8,
+        reasoning: 'Sufficient findings collected',
+      });
+
+      const result = await executor.execute(ctx, emitter);
+
+      expect(result.stopReason).toBe('Strategy concluded');
+      expect(emittedUpdates).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          type: 'progress',
+          content: expect.objectContaining({
+            phase: 'early_stop',
+            reason: 'Strategy concluded',
+          }),
+        }),
+      ]));
+    });
+
+    it('does not replace an existing focused time range with the global trace range during deep_dive', async () => {
+      const ctx = createMockExecutionContext({
+        options: {
+          traceProcessorService: {},
+          packageName: 'com.example.app',
+          timeRange: { start: '0', end: '9999' },
+        },
+      });
+      ctx.sharedContext.focusedTimeRange = { start: '1000', end: '2000' };
+
+      strategyPlanner.planNextIteration
+        .mockResolvedValueOnce({ strategy: 'deep_dive', confidence: 0.6, reasoning: 'Need deeper', focusArea: 'cpu' })
+        .mockResolvedValueOnce({ strategy: 'conclude', confidence: 0.8, reasoning: 'Done' });
+
+      await executor.execute(ctx, emitter);
+
+      expect(ctx.sharedContext.focusedTimeRange).toEqual({ start: '1000', end: '2000' });
+    });
+
     it('handles pivot strategy', async () => {
       const ctx = createMockExecutionContext();
 
@@ -599,8 +640,8 @@ describe('HypothesisExecutor', () => {
 
       const result = await executor.execute(ctx, emitter);
 
-      // Should complete without early stop due to noProgress (we reset the counter)
-      expect(result.stopReason).toBeNull();
+      // Should complete by strategy conclusion, not no-progress early stop.
+      expect(result.stopReason).toBe('Strategy concluded');
       expect(result.rounds).toBe(4);
       // Verify we accumulated findings from both rounds where we had findings
       expect(result.findings.length).toBeGreaterThanOrEqual(2);
@@ -626,7 +667,7 @@ describe('HypothesisExecutor', () => {
 
       const result = await executor.execute(ctx, emitter);
 
-      expect(result.stopReason).toBeNull();
+      expect(result.stopReason).toBe('Strategy concluded');
       expect(result.rounds).toBe(1);
       expect(emittedUpdates.some(
         update => update.type === 'progress' && String(update.content.phase || '').includes('intervention')

backend/src/agent/core/executors/hypothesisExecutor.ts

@@ -306,7 +306,13 @@ export class HypothesisExecutor implements AnalysisExecutor {
       });
 
       if (lastStrategy.strategy === 'conclude') {
-        emitter.log('Strategy: conclude - ending analysis');
+        stopReason = 'Strategy concluded';
+        emitter.log(`Strategy: conclude - ${stopReason}`);
+        emitter.emitUpdate('progress', {
+          phase: 'early_stop',
+          reason: stopReason,
+          message: `提前终止: ${stopReason}`,
+        });
         break;
       }
 
@@ -339,7 +345,11 @@ export class HypothesisExecutor implements AnalysisExecutor {
       // Handle deep_dive
       if (lastStrategy.strategy === 'deep_dive' && lastStrategy.focusArea) {
         emitter.log(`Strategy: deep_dive - focusing on ${lastStrategy.focusArea}`);
-        ctx.sharedContext.focusedTimeRange = ctx.options.timeRange;
+        const focusedTimeRange = ctx.sharedContext.focusedTimeRange
+          ?? this.getFocusedTimeRangeFromUserFocus(topFocuses);
+        if (focusedTimeRange) {
+          ctx.sharedContext.focusedTimeRange = focusedTimeRange;
+        }
 
         const deepDiveHypothesis = createHypothesis(
           `深入分析 ${lastStrategy.focusArea} 领域`, 0.6
@@ -501,6 +511,17 @@ export class HypothesisExecutor implements AnalysisExecutor {
     return `用户当前关注点:\n${descriptions.join('\n')}`;
   }
 
+  private getFocusedTimeRangeFromUserFocus(
+    topFocuses: UserFocus[]
+  ): SharedAgentContext['focusedTimeRange'] | undefined {
+    const focus = topFocuses.find(item => item.type === 'timeRange' && item.target.timeRange);
+    if (!focus?.target.timeRange) return undefined;
+    return {
+      start: String(focus.target.timeRange.start),
+      end: String(focus.target.timeRange.end),
+    };
+  }
+
   /**
    * Calculate how well findings align with user focus (v2.0)
    */

backend/src/agent/core/orchestratorTypes.ts

@@ -185,7 +185,7 @@ export interface IOrchestrator {
    * @deprecated P1-7: Dead code — sessionMap is loaded from `claude_session_map.json` at construction.
    * Kept for backward compatibility but never called from route layer.
    */
-  restoreSessionMapping?(sessionId: string, sdkSessionId: string): void;
+  restoreSessionMapping?(sessionId: string, sdkSessionId: string, referenceTraceId?: string): void;
   /** Restore a cached architecture result from persistence (agentv3). */
   restoreArchitectureCache?(traceId: string, architecture: any): void;
   /** Get cached architecture for persistence (agentv3). */

backend/src/agent/fork/__tests__/mergeStrategies.test.ts

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import { createMergeStrategyRegistry } from '../mergeStrategies';
+import type { Finding, StageResult, SubAgentContext } from '../../types';
+
+function finding(id: string, title: string): Finding {
+  return {
+    id,
+    severity: 'warning',
+    title,
+    description: `${title} description`,
+    source: 'test',
+  };
+}
+
+function stage(stageId: string, findings: Finding[]): StageResult {
+  return {
+    stageId,
+    success: true,
+    findings,
+    startTime: 1,
+    endTime: 2,
+    retryCount: 0,
+  };
+}
+
+function context(previousResults: StageResult[]): SubAgentContext {
+  return {
+    sessionId: 'session-test',
+    traceId: 'trace-test',
+    intent: {
+      primaryGoal: 'test merge findings',
+      aspects: [],
+      expectedOutputType: 'diagnosis',
+      complexity: 'moderate',
+      followUpType: 'initial',
+    },
+    previousResults,
+  };
+}
+
+describe('MergeStrategyRegistry', () => {
+  it('keeps child findings discoverable when using merge_findings', () => {
+    const registry = createMergeStrategyRegistry();
+    const parentFinding = finding('parent-finding', 'Parent finding');
+    const childFinding = finding('child-finding', 'Child finding');
+
+    const { mergedContext, result } = registry.merge(
+      context([stage('parent-stage', [parentFinding])]),
+      context([stage('child-stage', [childFinding])]),
+      {
+        strategy: 'merge_findings',
+        conflictResolution: 'keep_both',
+        childSessionId: 'child-session',
+        deleteAfterMerge: false,
+      },
+    );
+
+    const mergedFindings = (mergedContext.previousResults || [])
+      .flatMap(stageResult => stageResult.findings);
+
+    expect(result.mergedFindingsCount).toBe(1);
+    expect(mergedFindings).toEqual(expect.arrayContaining([
+      expect.objectContaining({ id: 'parent-finding' }),
+      expect.objectContaining({ id: 'child-finding' }),
+    ]));
+  });
+});

backend/src/agent/fork/mergeStrategies.ts

@@ -523,11 +523,14 @@ export class MergeStrategyRegistry {
 
     // 合并发现
     const findingsData = strategy.mergeFindings(parentFindings, childFindings, options);
+    const mergedResults = options.strategy === 'merge_findings'
+      ? this.injectMergedFindingsResult(resultData.mergedResults, parentFindings, findingsData, options)
+      : resultData.mergedResults;
 
     // 构建合并后的上下文
     const mergedContext: SubAgentContext = {
       ...parentContext,
-      previousResults: resultData.mergedResults,
+      previousResults: mergedResults,
     };
 
     return {
@@ -553,6 +556,65 @@ export class MergeStrategyRegistry {
     }
     return findings;
   }
+
+  private injectMergedFindingsResult(
+    parentResults: StageResult[],
+    parentFindings: Finding[],
+    findingsData: MergeFindingsData,
+    options: MergeOptions
+  ): StageResult[] {
+    const parentFindingCounts = this.countFindings(parentFindings);
+    const newFindings = findingsData.mergedFindings.filter(finding => {
+      const key = this.getFindingIdentity(finding);
+      const count = parentFindingCounts.get(key) ?? 0;
+      if (count > 0) {
+        parentFindingCounts.set(key, count - 1);
+        return false;
+      }
+      return true;
+    });
+    if (newFindings.length === 0) return parentResults;
+
+    const mergedAt = Date.now();
+    return [
+      ...parentResults,
+      {
+        stageId: `merge_findings:${options.childSessionId.slice(0, 8)}`,
+        success: true,
+        findings: newFindings,
+        data: {
+          _mergeInfo: {
+            findingsOnly: true,
+            sourceSession: options.childSessionId,
+            mergedAt,
+          },
+        },
+        startTime: mergedAt,
+        endTime: mergedAt,
+        retryCount: 0,
+      },
+    ];
+  }
+
+  private countFindings(findings: Finding[]): Map<string, number> {
+    const counts = new Map<string, number>();
+    for (const finding of findings) {
+      const key = this.getFindingIdentity(finding);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+  }
+
+  private getFindingIdentity(finding: Finding): string {
+    return JSON.stringify({
+      id: finding.id,
+      category: finding.category,
+      type: finding.type,
+      severity: finding.severity,
+      title: finding.title,
+      description: finding.description,
+    });
+  }
 }
 
 // =============================================================================
@@ -578,4 +640,4 @@ export function createMergeStrategyRegistry(): MergeStrategyRegistry {
   return new MergeStrategyRegistry();
 }
 
-export default MergeStrategyRegistry;
+export default MergeStrategyRegistry;

backend/src/agentOpenAI/__tests__/openAiRuntime.test.ts

@@ -1337,4 +1337,13 @@ describe('OpenAIRuntime previous response recovery', () => {
     }));
     expect(runtime.getSdkSessionId('s1', 'trace-b')).toBe('resp_compare_old');
   });
+
+  it('restores explicit OpenAI session mappings under the comparison key', () => {
+    const runtime = new OpenAIRuntime({} as any) as any;
+
+    runtime.restoreSessionMapping('s1', 'resp_compare_restored', 'trace-b');
+
+    expect(runtime.getSdkSessionId('s1')).toBeUndefined();
+    expect(runtime.getSdkSessionId('s1', 'trace-b')).toBe('resp_compare_restored');
+  });
 });