@skj1724/oh-my-opencode 3.19.3 → 3.19.4

package/dist/cli/index.js

@@ -6117,6 +6117,53 @@ var init_model_resolver = __esm(() => {
   init_model_availability();
 });
 
+// src/shared/perf-timer.ts
+class PerfTimer {
+  marks = new Map;
+  spans = [];
+  mark(name) {
+    this.marks.set(name, performance.now());
+  }
+  measure(name, startMark, endMark) {
+    const start = this.marks.get(startMark);
+    if (start === undefined)
+      return 0;
+    const end = endMark ? this.marks.get(endMark) ?? performance.now() : performance.now();
+    const duration = end - start;
+    this.spans.push({ name, durationMs: duration, start, end });
+    return duration;
+  }
+  getReport() {
+    return [...this.spans];
+  }
+  reset() {
+    this.marks.clear();
+    this.spans = [];
+  }
+  static formatDuration(start, end, options) {
+    const ms = (end ?? new Date).getTime() - start.getTime();
+    const absMs = Math.abs(ms);
+    const totalSeconds = absMs / 1000;
+    const seconds = Math.floor(totalSeconds);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const precision = options?.precision ?? "full";
+    if (hours > 0) {
+      if (precision === "compact") {
+        return `${hours}h ${minutes % 60}m`;
+      }
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    if (seconds === 0 && absMs > 0) {
+      return `${(absMs / 1000).toFixed(1)}s`;
+    }
+    return `${seconds}s`;
+  }
+}
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_frontmatter();
@@ -8375,7 +8422,7 @@ var import_picocolors2 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "@skj1724/oh-my-opencode",
-  version: "3.19.3",
+  version: "3.19.4",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "dist/index.js",
   types: "dist/index.d.ts",

package/dist/features/background-agent/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./types";
 export { BackgroundManager } from "./manager";
 export { ConcurrencyManager } from "./concurrency";
+export { PerformanceAggregator } from "./perf-aggregator";

package/dist/features/background-agent/manager.d.ts

@@ -25,6 +25,7 @@ export declare class BackgroundManager {
     private concurrencyManager;
     private shutdownTriggered;
     private config?;
+    private perfAggregator;
     private queuesByKey;
     private processingKeys;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig);
@@ -89,7 +90,6 @@ export declare class BackgroundManager {
      */
     private tryCompleteTask;
     private notifyParentSession;
-    private formatDuration;
     private hasRunningTasks;
     private pruneStaleTasksAndNotifications;
     private checkAndInterruptStaleTasks;

package/dist/features/background-agent/perf-aggregator.d.ts

@@ -0,0 +1,26 @@
+import type { BackgroundTask } from "./types";
+export interface AgentStat {
+    count: number;
+    avgMs: number;
+    p50Ms: number;
+    p95Ms: number;
+    totalMs: number;
+}
+export interface AggregatedReport {
+    totalTasks: number;
+    tasksByAgent: Map<string, AgentStat>;
+    totalToolCalls: number;
+    queueWaitStats: {
+        avgMs: number;
+        p50Ms: number;
+        p95Ms: number;
+        maxMs: number;
+    };
+}
+export declare class PerformanceAggregator {
+    private tasks;
+    recordTaskCompletion(task: BackgroundTask): void;
+    getReport(): AggregatedReport;
+    reset(): void;
+    get taskCount(): number;
+}

package/dist/features/background-agent/types.d.ts

@@ -1,10 +1,25 @@
 export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled";
+export interface PhaseTiming {
+    /** queuedAt -> startedAt in ms */
+    queueWaitMs: number;
+    /** startedAt -> completedAt in ms */
+    totalRunMs: number;
+    /** startedAt -> first assistant message in ms */
+    firstResponseMs?: number;
+    /** startedAt -> last message in ms */
+    lastResponseMs?: number;
+    /** Total tool call count */
+    toolCallCount: number;
+    /** toolCallCount / totalRunMs * 60000 (calls per minute) */
+    toolCallRate?: number;
+}
 export interface TaskProgress {
     toolCalls: number;
     lastTool?: string;
     lastUpdate: Date;
     lastMessage?: string;
     lastMessageAt?: Date;
+    phaseTiming?: PhaseTiming;
 }
 export interface BackgroundTask {
     id: string;

package/dist/index.js

@@ -4781,7 +4781,7 @@ var init_agent_tool_restrictions = __esm(() => {
 });
 
 // src/shared/model-requirements.ts
-var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
+var AGENT_MODEL_REQUIREMENTS;
 var init_model_requirements = __esm(() => {
   AGENT_MODEL_REQUIREMENTS = {
     sisyphus: {
@@ -4850,58 +4850,6 @@ var init_model_requirements = __esm(() => {
       ]
     }
   };
-  CATEGORY_MODEL_REQUIREMENTS = {
-    "visual-engineering": {
-      fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" }
-      ]
-    },
-    ultrabrain: {
-      fallbackChain: [
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "xhigh" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    },
-    artistry: {
-      fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
-      ]
-    },
-    quick: {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
-      ]
-    },
-    "unspecified-low": {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "medium" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }
-      ]
-    },
-    "unspecified-high": {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    },
-    writing: {
-      fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
-        { providers: ["zai-coding-plan"], model: "glm-4.7" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
-      ]
-    }
-  };
 });
 
 // src/shared/model-availability.ts
@@ -5038,6 +4986,53 @@ var init_model_resolver = __esm(() => {
   init_model_availability();
 });
 
+// src/shared/perf-timer.ts
+class PerfTimer {
+  marks = new Map;
+  spans = [];
+  mark(name) {
+    this.marks.set(name, performance.now());
+  }
+  measure(name, startMark, endMark) {
+    const start = this.marks.get(startMark);
+    if (start === undefined)
+      return 0;
+    const end = endMark ? this.marks.get(endMark) ?? performance.now() : performance.now();
+    const duration = end - start;
+    this.spans.push({ name, durationMs: duration, start, end });
+    return duration;
+  }
+  getReport() {
+    return [...this.spans];
+  }
+  reset() {
+    this.marks.clear();
+    this.spans = [];
+  }
+  static formatDuration(start, end, options) {
+    const ms = (end ?? new Date).getTime() - start.getTime();
+    const absMs = Math.abs(ms);
+    const totalSeconds = absMs / 1000;
+    const seconds = Math.floor(totalSeconds);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const precision = options?.precision ?? "full";
+    if (hours > 0) {
+      if (precision === "compact") {
+        return `${hours}h ${minutes % 60}m`;
+      }
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    if (seconds === 0 && absMs > 0) {
+      return `${(absMs / 1000).toFixed(1)}s`;
+    }
+    return `${seconds}s`;
+  }
+}
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_frontmatter();
@@ -19819,7 +19814,9 @@ var KEYWORD_DETECTORS = [
 \u5982\u679C\u590D\u6742\uFF08\u67B6\u6784\u3001\u591A\u7CFB\u7EDF\u30012 \u6B21\u4EE5\u4E0A\u5931\u8D25\u540E\u7684\u8C03\u8BD5\uFF09\uFF1A
 - \u54A8\u8BE2 oracle \u83B7\u53D6\u6218\u7565\u6307\u5BFC
 
-\u7EFC\u5408\u53D1\u73B0\u540E\u518D\u7EE7\u7EED\u3002`
+\u7EFC\u5408\u53D1\u73B0\u540E\u518D\u7EE7\u7EED\u3002
+**\u4E2D\u6587\u8BED\u5883\u601D\u8003\u56DE\u590D**
+`
   }
 ];
 
@@ -41888,19 +41885,6 @@ var BACKGROUND_CANCEL_DESCRIPTION = `\u53D6\u6D88\u6B63\u5728\u8FD0\u884C\u7684\
 // src/tools/background-task/tools.ts
 init_logger();
 init_session_cursor();
-function formatDuration(start, end) {
-  const duration3 = (end ?? new Date).getTime() - start.getTime();
-  const seconds = Math.floor(duration3 / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  if (hours > 0) {
-    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-  } else if (minutes > 0) {
-    return `${minutes}m ${seconds % 60}s`;
-  } else {
-    return `${seconds}s`;
-  }
-}
 function delay(ms) {
   return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
@@ -41912,9 +41896,9 @@ function truncateText(text, maxLength) {
 function formatTaskStatus(task) {
   let duration3;
   if (task.status === "pending" && task.queuedAt) {
-    duration3 = formatDuration(task.queuedAt, undefined);
+    duration3 = PerfTimer.formatDuration(task.queuedAt, undefined);
   } else if (task.startedAt) {
-    duration3 = formatDuration(task.startedAt, task.completedAt);
+    duration3 = PerfTimer.formatDuration(task.startedAt, task.completedAt);
   } else {
     duration3 = "N/A";
   }
@@ -41951,6 +41935,18 @@ ${truncated}
 > **Failed**: The task encountered an error. Check the last message for details.`;
   }
   const durationLabel = task.status === "pending" ? "Queued for" : "Duration";
+  let perfBlock = "";
+  if (task.progress?.phaseTiming) {
+    const pt = task.progress.phaseTiming;
+    const queueWait = PerfTimer.formatDuration(new Date(0), new Date(pt.queueWaitMs));
+    perfBlock = `
+
+### Performance
+| Metric | Value |
+|--------|-------|
+| Queue wait | ${queueWait} |
+| Tool calls | ${pt.toolCallCount} |`;
+  }
   return `# Task Status
 
 | Field | Value |
@@ -41966,7 +41962,8 @@ ${statusNote}
 
 \`\`\`
 ${promptPreview}
-\`\`\`${lastMessageSection}`;
+\`\`\`${lastMessageSection}${perfBlock}
+}`;
 }
 async function formatTaskResult(task, client2) {
   if (!task.sessionID) {
@@ -41980,12 +41977,25 @@ async function formatTaskResult(task, client2) {
   }
   const messages = messagesResult.data ?? messagesResult;
   if (!Array.isArray(messages) || messages.length === 0) {
+    const duration4 = PerfTimer.formatDuration(task.startedAt ?? new Date, task.completedAt);
+    let perfBlock2 = "";
+    if (task.progress?.phaseTiming) {
+      const pt = task.progress.phaseTiming;
+      const queueWait = PerfTimer.formatDuration(new Date(0), new Date(pt.queueWaitMs));
+      perfBlock2 = `
+
+### Performance
+| Metric | Value |
+|--------|-------|
+| Queue wait | ${queueWait} |
+| Tool calls | ${pt.toolCallCount} |`;
+    }
     return `Task Result
 
 Task ID: ${task.id}
 Description: ${task.description}
-Duration: ${formatDuration(task.startedAt ?? new Date, task.completedAt)}
-Session ID: ${task.sessionID}
+Duration: ${duration4}
+Session ID: ${task.sessionID}${perfBlock2}
 
 ---
 
@@ -41993,12 +42003,25 @@ Session ID: ${task.sessionID}
   }
   const relevantMessages = messages.filter((m) => m.info?.role === "assistant" || m.info?.role === "tool");
   if (relevantMessages.length === 0) {
+    const duration4 = PerfTimer.formatDuration(task.startedAt ?? new Date, task.completedAt);
+    let perfBlock2 = "";
+    if (task.progress?.phaseTiming) {
+      const pt = task.progress.phaseTiming;
+      const queueWait = PerfTimer.formatDuration(new Date(0), new Date(pt.queueWaitMs));
+      perfBlock2 = `
+
+### Performance
+| Metric | Value |
+|--------|-------|
+| Queue wait | ${queueWait} |
+| Tool calls | ${pt.toolCallCount} |`;
+    }
     return `Task Result
 
 Task ID: ${task.id}
 Description: ${task.description}
-Duration: ${formatDuration(task.startedAt ?? new Date, task.completedAt)}
-Session ID: ${task.sessionID}
+Duration: ${duration4}
+Session ID: ${task.sessionID}${perfBlock2}
 
 ---
 
@@ -42011,13 +42034,25 @@ Session ID: ${task.sessionID}
   });
   const newMessages = consumeNewMessages(task.sessionID, sortedMessages);
   if (newMessages.length === 0) {
-    const duration4 = formatDuration(task.startedAt ?? new Date, task.completedAt);
+    const duration4 = PerfTimer.formatDuration(task.startedAt ?? new Date, task.completedAt);
+    let perfBlock2 = "";
+    if (task.progress?.phaseTiming) {
+      const pt = task.progress.phaseTiming;
+      const queueWait = PerfTimer.formatDuration(new Date(0), new Date(pt.queueWaitMs));
+      perfBlock2 = `
+
+### Performance
+| Metric | Value |
+|--------|-------|
+| Queue wait | ${queueWait} |
+| Tool calls | ${pt.toolCallCount} |`;
+    }
     return `Task Result
 
 Task ID: ${task.id}
 Description: ${task.description}
 Duration: ${duration4}
-Session ID: ${task.sessionID}
+Session ID: ${task.sessionID}${perfBlock2}
 
 ---
 
@@ -42045,13 +42080,25 @@ Session ID: ${task.sessionID}
   const textContent = extractedContent.filter((text) => text.length > 0).join(`
 
 `);
-  const duration3 = formatDuration(task.startedAt ?? new Date, task.completedAt);
+  const duration3 = PerfTimer.formatDuration(task.startedAt ?? new Date, task.completedAt);
+  let perfBlock = "";
+  if (task.progress?.phaseTiming) {
+    const pt = task.progress.phaseTiming;
+    const queueWait = PerfTimer.formatDuration(new Date(0), new Date(pt.queueWaitMs));
+    perfBlock = `
+
+### Performance
+| Metric | Value |
+|--------|-------|
+| Queue wait | ${queueWait} |
+| Tool calls | ${pt.toolCallCount} |`;
+  }
   return `Task Result
 
 Task ID: ${task.id}
 Description: ${task.description}
 Duration: ${duration3}
-Session ID: ${task.sessionID}
+Session ID: ${task.sessionID}${perfBlock}
 
 ---
 
@@ -42687,14 +42734,7 @@ class TaskToastManager {
     return Array.from(this.tasks.values()).filter((t) => t.status === "queued").sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
   }
   formatDuration(startedAt) {
-    const seconds = Math.floor((Date.now() - startedAt.getTime()) / 1000);
-    if (seconds < 60)
-      return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-      return `${minutes}m ${seconds % 60}s`;
-    const hours = Math.floor(minutes / 60);
-    return `${hours}h ${minutes % 60}m`;
+    return PerfTimer.formatDuration(startedAt, undefined, { precision: "compact" });
   }
   getConcurrencyInfo() {
     if (!this.concurrencyManager)
@@ -42798,9 +42838,6 @@ function initTaskToastManager(client2, concurrencyManager) {
 }
 // src/tools/delegate-task/tools.ts
 init_shared();
-init_model_availability();
-init_model_resolver();
-init_model_requirements();
 var SISYPHUS_JUNIOR_AGENT = "sisyphus-junior";
 function parseModelString(model) {
   const parts = model.split("/");
@@ -42822,17 +42859,6 @@ function getMessageDir9(sessionID) {
   }
   return null;
 }
-function formatDuration2(start, end) {
-  const duration3 = (end ?? new Date).getTime() - start.getTime();
-  const seconds = Math.floor(duration3 / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  if (hours > 0)
-    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-  if (minutes > 0)
-    return `${minutes}m ${seconds % 60}s`;
-  return `${seconds}s`;
-}
 function formatDetailedError(error45, ctx) {
   const message = error45 instanceof Error ? error45.message : String(error45);
   const stack = error45 instanceof Error ? error45.stack : undefined;
@@ -43145,7 +43171,7 @@ Session ID: ${args.session_id}`;
         const textParts = lastMessage?.parts?.filter((p) => p.type === "text" || p.type === "reasoning") ?? [];
         const textContent = textParts.map((p) => p.text ?? "").filter(Boolean).join(`
 `);
-        const duration3 = formatDuration2(startTime);
+        const duration3 = PerfTimer.formatDuration(startTime);
         return `\u4EFB\u52A1\u5DF2\u7EE7\u7EED\u5E76\u5728 ${duration3} \u5185\u5B8C\u6210\u3002
 
 Session ID: ${args.session_id}
@@ -43186,195 +43212,21 @@ ${textContent || "(\u65E0\u6587\u672C\u8F93\u51FA)"}
 
 ` + "\uFF08\u66FF\u6362\u4E3A\u4F60\u504F\u597D\u7684 provider/model\uFF09";
         }
-        const availableModels = await fetchAvailableModels(client2);
         const resolved = resolveCategoryConfig(args.category, {
           userCategories,
           inheritedModel,
           systemDefaultModel
         });
         if (!resolved) {
-          return `\u672A\u77E5\u7684\u5206\u7C7B\uFF1A"${args.category}"\u3002\u53EF\u7528\u7684\u5206\u7C7B\uFF1A${Object.keys({ ...DEFAULT_CATEGORIES, ...userCategories }).join(", ")}`;
-        }
-        const requirement = CATEGORY_MODEL_REQUIREMENTS[args.category];
-        let actualModel;
-        if (!requirement) {
-          actualModel = resolved.model;
-          modelInfo = { model: actualModel, type: "system-default", source: "system-default" };
-        } else {
-          const { model: resolvedModel, source, variant: resolvedVariant } = resolveModelWithFallback({
-            userModel: userCategories?.[args.category]?.model ?? sisyphusJuniorModel,
-            fallbackChain: requirement.fallbackChain,
-            availableModels,
-            systemDefaultModel
-          });
-          actualModel = resolvedModel;
-          if (!parseModelString(actualModel)) {
-            return `\u65E0\u6548\u7684\u6A21\u578B\u683C\u5F0F"${actualModel}"\u3002\u671F\u671B"provider/model"\u683C\u5F0F\uFF08\u4F8B\u5982 "anthropic/claude-sonnet-4-5"\uFF09\u3002`;
-          }
-          let type2;
-          switch (source) {
-            case "override":
-              type2 = "user-defined";
-              break;
-            case "provider-fallback":
-              type2 = "category-default";
-              break;
-            case "system-default":
-              type2 = "system-default";
-              break;
-          }
-          modelInfo = { model: actualModel, type: type2, source };
-          const parsedModel = parseModelString(actualModel);
-          const variantToUse = userCategories?.[args.category]?.variant ?? resolvedVariant;
-          categoryModel = parsedModel ? variantToUse ? { ...parsedModel, variant: variantToUse } : parsedModel : undefined;
+          return `\u672A\u77E5\u7684\u5206\u7C7B\uFF1A${args.category}\u3002\u53EF\u7528\u7684\u5206\u7C7B\uFF1A${categoryExamples}`;
         }
         agentToUse = SISYPHUS_JUNIOR_AGENT;
-        if (!categoryModel) {
-          const parsedModel = parseModelString(actualModel);
-          categoryModel = parsedModel ?? undefined;
-        }
-        categoryPromptAppend = resolved.promptAppend || undefined;
-        const isUnstableAgent = resolved.config.is_unstable_agent === true || actualModel.toLowerCase().includes("gemini");
-        const isRunInBackgroundExplicitlyFalse = args.run_in_background === false || args.run_in_background === "false";
-        log("[delegate_task] unstable agent detection", {
-          category: args.category,
-          actualModel,
-          isUnstableAgent,
-          run_in_background_value: args.run_in_background,
-          run_in_background_type: typeof args.run_in_background,
-          isRunInBackgroundExplicitlyFalse,
-          willForceBackground: isUnstableAgent && isRunInBackgroundExplicitlyFalse
-        });
-        if (isUnstableAgent && isRunInBackgroundExplicitlyFalse) {
-          const systemContent2 = buildSystemContent({ skillContent, categoryPromptAppend });
-          try {
-            const task = await manager.launch({
-              description: args.description,
-              prompt: args.prompt,
-              agent: agentToUse,
-              parentSessionID: ctx.sessionID,
-              parentMessageID: ctx.messageID,
-              parentModel,
-              parentAgent,
-              model: categoryModel,
-              skills: args.load_skills.length > 0 ? args.load_skills : undefined,
-              skillContent: systemContent2
-            });
-            const WAIT_FOR_SESSION_INTERVAL_MS = 100;
-            const WAIT_FOR_SESSION_TIMEOUT_MS = 30000;
-            const waitStart = Date.now();
-            while (!task.sessionID && Date.now() - waitStart < WAIT_FOR_SESSION_TIMEOUT_MS) {
-              if (ctx.abort?.aborted) {
-                return `\u7B49\u5F85 session \u542F\u52A8\u65F6\u88AB\u4E2D\u6B62\u3002
-
-Task ID: ${task.id}`;
-              }
-              await new Promise((resolve10) => setTimeout(resolve10, WAIT_FOR_SESSION_INTERVAL_MS));
-            }
-            const sessionID = task.sessionID;
-            if (!sessionID) {
-              return formatDetailedError(new Error(`\u4EFB\u52A1\u5728\u8D85\u65F6\uFF0830\u79D2\uFF09\u5185\u672A\u80FD\u542F\u52A8\u3002Task ID: ${task.id}\uFF0CStatus: ${task.status}`), {
-                operation: "\u542F\u52A8\u53D7\u76D1\u63A7\u7684\u540E\u53F0\u4EFB\u52A1",
-                args,
-                agent: agentToUse,
-                category: args.category
-              });
-            }
-            ctx.metadata?.({
-              title: args.description,
-              metadata: {
-                prompt: args.prompt,
-                agent: agentToUse,
-                category: args.category,
-                load_skills: args.load_skills,
-                description: args.description,
-                run_in_background: args.run_in_background,
-                sessionId: sessionID,
-                command: args.command
-              }
-            });
-            const startTime = new Date;
-            const POLL_INTERVAL_MS = 500;
-            const MAX_POLL_TIME_MS = 10 * 60 * 1000;
-            const MIN_STABILITY_TIME_MS = 1e4;
-            const STABILITY_POLLS_REQUIRED = 3;
-            const pollStart = Date.now();
-            let lastMsgCount = 0;
-            let stablePolls = 0;
-            while (Date.now() - pollStart < MAX_POLL_TIME_MS) {
-              if (ctx.abort?.aborted) {
-                return `\u4EFB\u52A1\u5DF2\u4E2D\u6B62\uFF08\u6B63\u5728\u540E\u53F0\u6A21\u5F0F\u8FD0\u884C\uFF09\u3002
-
-Session ID: ${sessionID}`;
-              }
-              await new Promise((resolve10) => setTimeout(resolve10, POLL_INTERVAL_MS));
-              const statusResult = await client2.session.status();
-              const allStatuses = statusResult.data ?? {};
-              const sessionStatus = allStatuses[sessionID];
-              if (sessionStatus && sessionStatus.type !== "idle") {
-                stablePolls = 0;
-                lastMsgCount = 0;
-                continue;
-              }
-              if (Date.now() - pollStart < MIN_STABILITY_TIME_MS)
-                continue;
-              const messagesCheck = await client2.session.messages({ path: { id: sessionID } });
-              const msgs = messagesCheck.data ?? messagesCheck;
-              const currentMsgCount = msgs.length;
-              if (currentMsgCount === lastMsgCount) {
-                stablePolls++;
-                if (stablePolls >= STABILITY_POLLS_REQUIRED)
-                  break;
-              } else {
-                stablePolls = 0;
-                lastMsgCount = currentMsgCount;
-              }
-            }
-            const messagesResult = await client2.session.messages({ path: { id: sessionID } });
-            const messages = messagesResult.data ?? messagesResult;
-            const assistantMessages = messages.filter((m) => m.info?.role === "assistant").sort((a, b) => (b.info?.time?.created ?? 0) - (a.info?.time?.created ?? 0));
-            const lastMessage = assistantMessages[0];
-            if (!lastMessage) {
-              return `\u672A\u627E\u5230 assistant \u7684\u54CD\u5E94\uFF08\u4EFB\u52A1\u5728\u540E\u53F0\u6A21\u5F0F\u8FD0\u884C\uFF09\u3002
-
-Session ID: ${sessionID}`;
-            }
-            const textParts = lastMessage?.parts?.filter((p) => p.type === "text" || p.type === "reasoning") ?? [];
-            const textContent = textParts.map((p) => p.text ?? "").filter(Boolean).join(`
-`);
-            const duration3 = formatDuration2(startTime);
-            return `\u53D7\u76D1\u63A7\u4EFB\u52A1\u6210\u529F\u5B8C\u6210
-
-\u91CD\u8981\u63D0\u793A\uFF1A\u6B64\u6A21\u578B\uFF08${actualModel}\uFF09\u88AB\u6807\u8BB0\u4E3A\u4E0D\u7A33\u5B9A/\u5B9E\u9A8C\u6027\u3002
-\u4F60\u7684 run_in_background=false \u5DF2\u81EA\u52A8\u8F6C\u6362\u4E3A\u540E\u53F0\u6A21\u5F0F\u4EE5\u8FDB\u884C\u53EF\u9760\u6027\u76D1\u63A7\u3002
-
-\u8017\u65F6\uFF1A${duration3}
-Agent: ${agentToUse}${args.category ? ` (category: ${args.category})` : ""}
-Session ID: ${sessionID}
-
-\u76D1\u63A7\u8BF4\u660E\uFF1A
-- \u4EFB\u52A1\u5DF2\u88AB\u76D1\u63A7\u5E76\u6210\u529F\u5B8C\u6210
-- \u5982\u679C\u4F60\u53D1\u73B0\u6B64 agent \u5728\u540E\u7EED\u8C03\u7528\u4E2D\u884C\u4E3A\u5F02\u5E38\uFF0C\u8BF7\u4E3B\u52A8\u76D1\u63A7\u5176\u8FDB\u5EA6
-- \u5982 agent \u4F3C\u4E4E\u5361\u4F4F\u6216\u4EA7\u751F\u5783\u573E\u8F93\u51FA\uFF0C\u4F7F\u7528 background_cancel(task_id="...") \u4E2D\u6B62
-- \u770B\u5230\u6B64\u6D88\u606F\u65F6\u4E0D\u8981\u81EA\u52A8\u91CD\u8BD5 \u2014 \u4EFB\u52A1\u5DF2\u6210\u529F\u5B8C\u6210
-
----
-
-\u7ED3\u679C\uFF1A
-
-${textContent || "(\u65E0\u6587\u672C\u8F93\u51FA)"}
-
----
-\u7EE7\u7EED\u6B64 session\uFF1Asession_id="${sessionID}"`;
-          } catch (error45) {
-            return formatDetailedError(error45, {
-              operation: "\u542F\u52A8\u53D7\u76D1\u63A7\u7684\u540E\u53F0\u4EFB\u52A1",
-              args,
-              agent: agentToUse,
-              category: args.category
-            });
-          }
-        }
+        categoryModel = parseModelString(resolved.model);
+        categoryPromptAppend = resolved.promptAppend;
+        modelInfo = {
+          type: "category-default",
+          model: resolved.model
+        };
       } else {
         if (!args.subagent_type?.trim()) {
           return `Agent \u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A\u3002`;
@@ -43612,7 +43464,7 @@ Session ID: ${sessionID}`;
         const textParts = lastMessage?.parts?.filter((p) => p.type === "text" || p.type === "reasoning") ?? [];
         const textContent = textParts.map((p) => p.text ?? "").filter(Boolean).join(`
 `);
-        const duration3 = formatDuration2(startTime);
+        const duration3 = PerfTimer.formatDuration(startTime);
         if (toastManager) {
           toastManager.removeTask(taskId);
         }
@@ -43770,6 +43622,65 @@ class ConcurrencyManager {
   }
 }
 
+// src/features/background-agent/perf-aggregator.ts
+function percentile(sorted, p) {
+  if (sorted.length === 0)
+    return 0;
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, Math.min(index, sorted.length - 1))];
+}
+
+class PerformanceAggregator {
+  tasks = [];
+  recordTaskCompletion(task) {
+    if (!task.progress?.phaseTiming)
+      return;
+    this.tasks.push({
+      agent: task.agent,
+      toolCalls: task.progress.phaseTiming.toolCallCount,
+      phaseTiming: task.progress.phaseTiming
+    });
+  }
+  getReport() {
+    const byAgent = new Map;
+    const queueWaits = [];
+    let totalToolCalls = 0;
+    for (const t of this.tasks) {
+      const list = byAgent.get(t.agent) ?? [];
+      list.push(t.phaseTiming.totalRunMs);
+      byAgent.set(t.agent, list);
+      queueWaits.push(t.phaseTiming.queueWaitMs);
+      totalToolCalls += t.toolCalls;
+    }
+    const tasksByAgent = new Map;
+    for (const [agent, durations] of byAgent) {
+      const sorted = [...durations].sort((a, b) => a - b);
+      const totalMs = durations.reduce((s, d) => s + d, 0);
+      tasksByAgent.set(agent, {
+        count: durations.length,
+        avgMs: Math.round(totalMs / durations.length),
+        p50Ms: Math.round(percentile(sorted, 50)),
+        p95Ms: Math.round(percentile(sorted, 95)),
+        totalMs
+      });
+    }
+    const sortedQueue = [...queueWaits].sort((a, b) => a - b);
+    const queueWaitStats = {
+      avgMs: queueWaits.length > 0 ? Math.round(queueWaits.reduce((s, q) => s + q, 0) / queueWaits.length) : 0,
+      p50Ms: Math.round(percentile(sortedQueue, 50)),
+      p95Ms: Math.round(percentile(sortedQueue, 95)),
+      maxMs: queueWaits.length > 0 ? Math.max(...queueWaits) : 0
+    };
+    return { totalTasks: this.tasks.length, tasksByAgent, totalToolCalls, queueWaitStats };
+  }
+  reset() {
+    this.tasks = [];
+  }
+  get taskCount() {
+    return this.tasks.length;
+  }
+}
+
 // src/features/background-agent/manager.ts
 import { existsSync as existsSync46, readdirSync as readdirSync16 } from "fs";
 import { join as join55 } from "path";
@@ -43791,6 +43702,7 @@ class BackgroundManager {
   concurrencyManager;
   shutdownTriggered = false;
   config;
+  perfAggregator = new PerformanceAggregator;
   queuesByKey = new Map;
   processingKeys = new Set;
   constructor(ctx, config3) {
@@ -44096,6 +44008,9 @@ class BackgroundManager {
     existingTask.parentModel = input.parentModel;
     existingTask.parentAgent = input.parentAgent;
     existingTask.startedAt = new Date;
+    if (existingTask.progress) {
+      existingTask.progress.phaseTiming = undefined;
+    }
     existingTask.progress = {
       toolCalls: existingTask.progress?.toolCalls ?? 0,
       lastUpdate: new Date
@@ -44397,6 +44312,7 @@ class BackgroundManager {
       log("[background-agent] Task already completed, skipping:", { taskId: task.id, status: task.status, source });
       return false;
     }
+    const perfSnapshot = task.progress?.phaseTiming ? { ...task.progress.phaseTiming } : undefined;
     task.status = "completed";
     task.completedAt = new Date;
     if (task.concurrencyKey) {
@@ -44405,15 +44321,16 @@ class BackgroundManager {
     }
     this.markForNotification(task);
     try {
-      await this.notifyParentSession(task);
+      await this.notifyParentSession(task, perfSnapshot);
       log(`[background-agent] Task completed via ${source}:`, task.id);
     } catch (err) {
       log("[background-agent] Error in notifyParentSession:", { taskId: task.id, error: err });
     }
+    this.perfAggregator.recordTaskCompletion(task);
     return true;
   }
-  async notifyParentSession(task) {
-    const duration3 = this.formatDuration(task.startedAt ?? new Date, task.completedAt);
+  async notifyParentSession(task, perfSnapshot) {
+    const duration3 = PerfTimer.formatDuration(task.startedAt ?? new Date, task.completedAt);
     log("[background-agent] notifyParentSession called for task:", task.id);
     const toastManager = getTaskToastManager();
     if (toastManager) {
@@ -44435,6 +44352,16 @@ class BackgroundManager {
     const statusText = task.status === "completed" ? "COMPLETED" : "CANCELLED";
     const errorInfo = task.error ? `
 **Error:** ${task.error}` : "";
+    const fallbackTaskLine = "- `" + task.id + "`: " + task.description;
+    const perfSummary = (() => {
+      if (!perfSnapshot)
+        return "";
+      const completed = Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending");
+      const ms = completed.reduce((s, t) => s + (t.progress?.phaseTiming?.totalRunMs ?? 0), 0);
+      const avgSec = completed.length > 0 ? Math.round(ms / completed.length / 1000) : 0;
+      const toolTotal = completed.reduce((s, t) => s + (t.progress?.phaseTiming?.toolCallCount ?? 0), 0);
+      return "\u5E73\u5747\u8017\u65F6: " + avgSec + "s | \u603BTool: " + toolTotal;
+    })();
     let notification;
     if (allComplete) {
       const completedTasks = Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending").map((t) => `- \`${t.id}\`: ${t.description}`).join(`
@@ -44443,7 +44370,8 @@ class BackgroundManager {
 [\u6240\u6709\u540E\u53F0\u4EFB\u52A1\u5DF2\u5B8C\u6210]
 
 **\u5DF2\u5B8C\u6210\uFF1A**
-${completedTasks || `- \`${task.id}\`: ${task.description}`}
+${completedTasks || fallbackTaskLine}
+${perfSummary}
 
 \u4F7F\u7528 \`background_output(task_id="<id>")\` \u83B7\u53D6\u6BCF\u4E2A\u4EFB\u52A1\u7684\u7ED3\u679C\u3002
 </system-reminder>`;
@@ -44453,6 +44381,7 @@ ${completedTasks || `- \`${task.id}\`: ${task.description}`}
 **ID:** \`${task.id}\`
 **\u63CF\u8FF0\uFF1A** ${task.description}
 **\u8017\u65F6\uFF1A** ${duration3}${errorInfo}
+${perfSnapshot ? `| \u6392\u961F ${PerfTimer.formatDuration(new Date(0), new Date(perfSnapshot.queueWaitMs))} | Tool ${perfSnapshot.toolCallCount} \u6B21` : ""}
 
 **\u8FD8\u6709 ${remainingCount} \u4E2A\u4EFB\u52A1\u6B63\u5728\u8FDB\u884C\u4E2D\u3002** \u6240\u6709\u4EFB\u52A1\u5B8C\u6210\u540E\u4F60\u4F1A\u6536\u5230\u901A\u77E5\u3002
 \u4E0D\u8981\u8F6E\u8BE2\u2014\u2014\u7EE7\u7EED\u6709\u6548\u7387\u7684\u5DE5\u4F5C\u3002
@@ -44511,18 +44440,6 @@ ${completedTasks || `- \`${task.id}\`: ${task.description}`}
       }
     }, 5 * 60 * 1000);
   }
-  formatDuration(start, end) {
-    const duration3 = (end ?? new Date).getTime() - start.getTime();
-    const seconds = Math.floor(duration3 / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-    } else if (minutes > 0) {
-      return `${minutes}m ${seconds % 60}s`;
-    }
-    return `${seconds}s`;
-  }
   hasRunningTasks() {
     for (const task of this.tasks.values()) {
       if (task.status === "running")
@@ -44666,6 +44583,17 @@ ${completedTasks || `- \`${task.id}\`: ${task.description}`}
           if (!task.progress) {
             task.progress = { toolCalls: 0, lastUpdate: new Date };
           }
+          if (task.startedAt && !task.progress.phaseTiming) {
+            const now = Date.now();
+            task.progress.phaseTiming = {
+              queueWaitMs: task.queuedAt ? now - task.queuedAt.getTime() : 0,
+              totalRunMs: now - task.startedAt.getTime(),
+              toolCallCount: 0
+            };
+          }
+          if (task.progress.phaseTiming && task.progress.phaseTiming.firstResponseMs === undefined && assistantMsgs.length > 0) {
+            task.progress.phaseTiming.firstResponseMs = Date.now() - task.startedAt.getTime();
+          }
           task.progress.toolCalls = toolCalls;
           task.progress.lastTool = lastTool;
           task.progress.lastUpdate = new Date;
@@ -44718,6 +44646,10 @@ ${completedTasks || `- \`${task.id}\`: ${task.description}`}
     }
     if (!this.hasRunningTasks()) {
       this.stopPolling();
+      if (this.perfAggregator.taskCount >= 2) {
+        const report = this.perfAggregator.getReport();
+        log("[perf] Session report:", report);
+      }
     }
   }
   shutdown() {
@@ -44738,6 +44670,7 @@ ${completedTasks || `- \`${task.id}\`: ${task.description}`}
     this.pendingByParent.clear();
     this.queuesByKey.clear();
     this.processingKeys.clear();
+    this.perfAggregator.reset();
     this.unregisterProcessCleanup();
     log("[background-agent] Shutdown complete");
   }

package/dist/shared/index.d.ts

@@ -28,4 +28,5 @@ export * from "./agent-tool-restrictions";
 export * from "./model-requirements";
 export * from "./model-resolver";
 export * from "./model-availability";
+export * from "./perf-timer";
 export * from "./case-insensitive";

package/dist/shared/perf-timer.d.ts

@@ -0,0 +1,26 @@
+export interface SpanData {
+    name: string;
+    durationMs: number;
+    start: number;
+    end: number;
+}
+export interface FormatDurationOptions {
+    precision?: "full" | "compact";
+}
+export declare class PerfTimer {
+    private marks;
+    private spans;
+    mark(name: string): void;
+    measure(name: string, startMark: string, endMark?: string): number;
+    getReport(): SpanData[];
+    reset(): void;
+    /**
+     * Format a duration between two Date objects into a human-readable string.
+     *
+     * @param start - Start date
+     * @param end - End date (defaults to now if undefined)
+     * @param options - Formatting options
+     * @returns "Xs", "Xm Ys", "Xh Ym Ys" or "Xh Ym" (compact)
+     */
+    static formatDuration(start: Date, end?: Date, options?: FormatDurationOptions): string;
+}

package/dist/shared/perf-timer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skj1724/oh-my-opencode",
-  "version": "3.19.3",
+  "version": "3.19.4",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",