@hasna/assistants 0.6.61 → 0.6.62

package/dist/index.js

@@ -54941,31 +54941,1136 @@ var init_aggregator = __esm(() => {
   };
 });
 
+// packages/core/src/swarm/critic.ts
+class SwarmCritic {
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CRITIC_CONFIG, ...config };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  async review(params) {
+    if (!this.config.enabled) {
+      return this.createPassingReview("Critic disabled");
+    }
+    const startTime = Date.now();
+    const prompt = this.buildCriticPrompt(params);
+    const result = await this.runCriticAgent({
+      prompt,
+      subagentManager: params.subagentManager,
+      sessionId: params.sessionId,
+      cwd: params.cwd,
+      depth: params.depth
+    });
+    const review = this.parseCriticOutput(result, startTime);
+    const staticIssues = this.runStaticChecks(params.aggregatedResult, params.tasks);
+    review.issues.push(...staticIssues);
+    this.recalculateScores(review);
+    return review;
+  }
+  runStaticChecks(result, tasks) {
+    const issues = [];
+    let issueId = 0;
+    if (result.metadata.confidence < 0.5) {
+      issues.push({
+        id: `static-${issueId++}`,
+        category: "quality",
+        severity: "medium",
+        title: "Low confidence score",
+        description: `Aggregated result has low confidence (${(result.metadata.confidence * 100).toFixed(1)}%)`,
+        autoFixable: false
+      });
+    }
+    if (result.metadata.failedTasks > 0) {
+      const failRate = result.metadata.failedTasks / (result.metadata.contributingTasks + result.metadata.failedTasks);
+      if (failRate > 0.3) {
+        issues.push({
+          id: `static-${issueId++}`,
+          category: "incomplete",
+          severity: failRate > 0.5 ? "high" : "medium",
+          title: "High task failure rate",
+          description: `${result.metadata.failedTasks} tasks failed (${(failRate * 100).toFixed(1)}% failure rate)`,
+          autoFixable: false
+        });
+      }
+    }
+    if (result.metadata.conflictCount > 0) {
+      issues.push({
+        id: `static-${issueId++}`,
+        category: "conflict",
+        severity: result.metadata.conflictCount > 3 ? "high" : "medium",
+        title: "Conflicts detected",
+        description: `${result.metadata.conflictCount} conflicts were detected and resolved. Manual review recommended.`,
+        autoFixable: false
+      });
+    }
+    if (!result.content || result.content.length < 50) {
+      issues.push({
+        id: `static-${issueId++}`,
+        category: "incomplete",
+        severity: "critical",
+        title: "Empty or minimal result",
+        description: "The aggregated result is empty or very short",
+        autoFixable: false
+      });
+    }
+    if (this.config.checkSecurity) {
+      const securityIssues = this.checkSecurityPatterns(result.content);
+      issues.push(...securityIssues.map((i) => ({
+        ...i,
+        id: `static-${issueId++}`
+      })));
+    }
+    const coveredTaskIds = new Set(result.sections.flatMap((s) => s.sources));
+    const uncoveredTasks = tasks.filter((t) => !coveredTaskIds.has(t.id));
+    if (uncoveredTasks.length > 0) {
+      issues.push({
+        id: `static-${issueId++}`,
+        category: "missing_step",
+        severity: uncoveredTasks.length > 2 ? "high" : "medium",
+        title: "Tasks not covered in result",
+        description: `${uncoveredTasks.length} tasks have no corresponding content in the result`,
+        relatedTasks: uncoveredTasks.map((t) => t.id),
+        autoFixable: false
+      });
+    }
+    return issues;
+  }
+  hasBlockingIssues(review) {
+    const blockingThreshold = SEVERITY_WEIGHTS[this.config.blockingSeverity];
+    for (const issue of review.issues) {
+      if (SEVERITY_WEIGHTS[issue.severity] >= blockingThreshold) {
+        return true;
+      }
+      if (this.config.blockingCategories.includes(issue.category)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  generateFollowUps(review) {
+    const followUps = [];
+    let actionId = 0;
+    for (const issue of review.issues) {
+      if (issue.severity === "info")
+        continue;
+      const action = {
+        id: `followup-${actionId++}`,
+        type: issue.autoFixable ? "revision" : "manual",
+        description: issue.suggestedFix || `Address: ${issue.title}`,
+        priority: this.severityToPriority(issue.severity),
+        relatedIssues: [issue.id],
+        required: SEVERITY_WEIGHTS[issue.severity] >= SEVERITY_WEIGHTS["high"]
+      };
+      if (issue.autoFixable || issue.category === "missing_step") {
+        action.type = "task";
+        action.taskDefinition = {
+          description: `Fix: ${issue.title}
+
+${issue.description}
+
+Suggested fix: ${issue.suggestedFix || "Address the issue"}`,
+          role: "worker",
+          priority: action.priority
+        };
+      }
+      followUps.push(action);
+    }
+    return followUps;
+  }
+  buildCriticPrompt(params) {
+    const taskSummary = params.tasks.map((t) => `- [${t.id}] ${t.description}`).join(`
+`);
+    let prompt = `# Critic Review Task
+
+## Original Goal
+${params.goal}
+
+## Tasks Executed
+${taskSummary}
+
+## Aggregated Result
+${params.aggregatedResult.content}
+
+## Metadata
+- Contributing tasks: ${params.aggregatedResult.metadata.contributingTasks}
+- Failed tasks: ${params.aggregatedResult.metadata.failedTasks}
+- Confidence: ${(params.aggregatedResult.metadata.confidence * 100).toFixed(1)}%
+- Conflicts: ${params.aggregatedResult.metadata.conflictCount}
+
+## Review Instructions
+
+Analyze the result and provide your assessment as JSON with:
+- "approved": boolean - whether the result meets quality standards
+- "qualityScore": number (0-1) - overall quality assessment
+- "issues": array of issues found, each with:
+  - "category": one of "conflict", "missing_step", "unsafe_action", "incomplete", "quality", "consistency", "security", "performance", "correctness"
+  - "severity": one of "critical", "high", "medium", "low", "info"
+  - "title": brief issue title
+  - "description": detailed description
+  - "suggestedFix": suggested resolution (optional)
+- "summary": brief summary of findings
+- "feedback": detailed feedback for improvement
+
+Check for:
+`;
+    if (this.config.checkSecurity) {
+      prompt += `- Security issues (credentials, unsafe operations)
+`;
+    }
+    if (this.config.checkPerformance) {
+      prompt += `- Performance concerns
+`;
+    }
+    if (this.config.checkConsistency) {
+      prompt += `- Consistency with the original goal
+`;
+    }
+    prompt += `- Completeness of the response
+- Correctness of information
+- Missing steps or tasks
+- Conflicting information
+
+`;
+    if (this.config.customPrompt) {
+      prompt += `
+## Additional Instructions
+${this.config.customPrompt}
+`;
+    }
+    return prompt;
+  }
+  async runCriticAgent(params) {
+    const systemPrompt = ROLE_SYSTEM_PROMPTS.critic;
+    const config = {
+      task: `${systemPrompt}
+
+---
+
+${params.prompt}`,
+      tools: this.config.criticTools,
+      maxTurns: this.config.maxTurns,
+      parentSessionId: params.sessionId,
+      depth: params.depth + 1,
+      cwd: params.cwd
+    };
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Critic timeout")), this.config.timeoutMs);
+    });
+    try {
+      return await Promise.race([
+        params.subagentManager.spawn(config),
+        timeoutPromise
+      ]);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        toolCalls: 0,
+        turns: 0
+      };
+    }
+  }
+  parseCriticOutput(result, startTime) {
+    const durationMs = Date.now() - startTime;
+    if (!result.success || !result.result) {
+      return {
+        approved: false,
+        qualityScore: 0,
+        confidence: 0,
+        issues: [{
+          id: "parse-error",
+          category: "quality",
+          severity: "high",
+          title: "Critic review failed",
+          description: result.error || "No result from critic agent",
+          autoFixable: false
+        }],
+        followUps: [],
+        summary: "Critic review failed",
+        feedback: result.error || "No output from critic",
+        reviewedAt: Date.now(),
+        durationMs
+      };
+    }
+    try {
+      const jsonMatch = result.result.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        throw new Error("No JSON found in critic output");
+      }
+      const parsed = JSON.parse(jsonMatch[0]);
+      return {
+        approved: parsed.approved ?? false,
+        qualityScore: parsed.qualityScore ?? 0.5,
+        confidence: 0.8,
+        issues: (parsed.issues || []).map((issue, index) => ({
+          id: `critic-${index}`,
+          category: issue.category || "quality",
+          severity: issue.severity || "medium",
+          title: issue.title || "Unknown issue",
+          description: issue.description || "",
+          suggestedFix: issue.suggestedFix,
+          autoFixable: !!issue.suggestedFix
+        })),
+        followUps: [],
+        summary: parsed.summary || "",
+        feedback: parsed.feedback || "",
+        reviewedAt: Date.now(),
+        durationMs
+      };
+    } catch (error) {
+      const approved = result.result.toLowerCase().includes("approved") && !result.result.toLowerCase().includes("not approved");
+      return {
+        approved,
+        qualityScore: approved ? 0.7 : 0.3,
+        confidence: 0.5,
+        issues: [],
+        followUps: [],
+        summary: result.result.slice(0, 200),
+        feedback: result.result,
+        reviewedAt: Date.now(),
+        durationMs
+      };
+    }
+  }
+  checkSecurityPatterns(content) {
+    const issues = [];
+    const credentialPatterns = [
+      /api[_-]?key\s*[=:]\s*['"][^'"]+['"]/i,
+      /password\s*[=:]\s*['"][^'"]+['"]/i,
+      /secret\s*[=:]\s*['"][^'"]+['"]/i,
+      /token\s*[=:]\s*['"][^'"]+['"]/i
+    ];
+    for (const pattern of credentialPatterns) {
+      if (pattern.test(content)) {
+        issues.push({
+          category: "security",
+          severity: "critical",
+          title: "Potential credential exposure",
+          description: "Content may contain hardcoded credentials",
+          suggestedFix: "Remove or mask sensitive values",
+          autoFixable: false
+        });
+        break;
+      }
+    }
+    const unsafePatterns = [
+      { pattern: /rm\s+-rf\s+[/*]/, title: "Dangerous file deletion" },
+      { pattern: /drop\s+database/i, title: "Database deletion" },
+      { pattern: /truncate\s+table/i, title: "Table truncation" },
+      { pattern: /--force/, title: "Force flag usage" }
+    ];
+    for (const { pattern, title } of unsafePatterns) {
+      if (pattern.test(content)) {
+        issues.push({
+          category: "unsafe_action",
+          severity: "high",
+          title,
+          description: `Found potentially unsafe operation: ${pattern.source}`,
+          autoFixable: false
+        });
+      }
+    }
+    return issues;
+  }
+  recalculateScores(review) {
+    if (review.issues.length === 0) {
+      review.qualityScore = Math.max(review.qualityScore, 0.8);
+      return;
+    }
+    let totalPenalty = 0;
+    for (const issue of review.issues) {
+      totalPenalty += SEVERITY_WEIGHTS[issue.severity];
+    }
+    const penalty = Math.min(totalPenalty * 0.15, 0.8);
+    review.qualityScore = Math.max(0, review.qualityScore - penalty);
+    if (this.hasBlockingIssues(review)) {
+      review.approved = false;
+    }
+    review.followUps = this.generateFollowUps(review);
+  }
+  severityToPriority(severity) {
+    switch (severity) {
+      case "critical":
+        return 1;
+      case "high":
+        return 2;
+      case "medium":
+        return 3;
+      case "low":
+        return 4;
+      case "info":
+        return 5;
+      default:
+        return 3;
+    }
+  }
+  createPassingReview(reason) {
+    return {
+      approved: true,
+      qualityScore: 1,
+      confidence: 1,
+      issues: [],
+      followUps: [],
+      summary: reason,
+      feedback: "",
+      reviewedAt: Date.now(),
+      durationMs: 0
+    };
+  }
+}
+function createSwarmCritic(config) {
+  return new SwarmCritic(config);
+}
+var DEFAULT_CRITIC_CONFIG, SEVERITY_WEIGHTS;
+var init_critic = __esm(() => {
+  init_types3();
+  DEFAULT_CRITIC_CONFIG = {
+    enabled: true,
+    blockingSeverity: "high",
+    maxIssues: 10,
+    blockingCategories: ["unsafe_action", "security", "correctness"],
+    checkSecurity: true,
+    checkPerformance: true,
+    checkConsistency: true,
+    maxTurns: 10,
+    criticTools: ["read", "grep", "glob"],
+    timeoutMs: 60000
+  };
+  SEVERITY_WEIGHTS = {
+    critical: 1,
+    high: 0.7,
+    medium: 0.4,
+    low: 0.2,
+    info: 0.05
+  };
+});
+
+// packages/core/src/swarm/postback.ts
+class SwarmPostback {
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_POSTBACK_CONFIG, ...config };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  createPostback(params) {
+    const { swarmId, sessionId, goal, plan, result, aggregatedResult, criticReview } = params;
+    const taskOutcomes = this.extractTaskOutcomes(plan.tasks, result);
+    const artifacts = this.extractArtifacts(result, taskOutcomes);
+    const structuredData = {
+      summary: this.generateSummary(result, criticReview),
+      goal,
+      success: result.success,
+      qualityScore: criticReview?.qualityScore ?? (result.success ? 0.8 : 0.3),
+      taskOutcomes,
+      artifacts: artifacts.slice(0, this.config.maxArtifacts),
+      issues: criticReview?.issues || [],
+      followUps: criticReview?.followUps || [],
+      metrics: result.metrics,
+      metadata: aggregatedResult?.metadata || this.createDefaultMetadata(result),
+      durationMs: result.durationMs
+    };
+    const content = this.formatContent(structuredData);
+    return {
+      id: `postback-${swarmId}`,
+      format: this.config.format,
+      content,
+      structuredData: this.config.format === "structured" ? structuredData : undefined,
+      timestamp: Date.now(),
+      swarmId,
+      sessionId
+    };
+  }
+  formatAsMarkdown(data) {
+    if (this.config.customTemplate) {
+      return this.applyTemplate(this.config.customTemplate, data);
+    }
+    const parts = [];
+    const statusIcon = data.success ? "\u2705" : "\u274C";
+    parts.push(`## ${statusIcon} Swarm Execution Complete`);
+    parts.push("");
+    parts.push(`**Goal:** ${data.goal}`);
+    parts.push("");
+    parts.push(data.summary);
+    parts.push("");
+    if (this.config.includeMetrics) {
+      parts.push("### Metrics");
+      parts.push(`- Tasks: ${data.metrics.completedTasks}/${data.metrics.totalTasks} completed`);
+      if (data.metrics.failedTasks > 0) {
+        parts.push(`- Failed: ${data.metrics.failedTasks}`);
+      }
+      parts.push(`- Tool calls: ${data.metrics.toolCalls}`);
+      if (this.config.showDuration) {
+        parts.push(`- Duration: ${this.formatDuration(data.durationMs)}`);
+      }
+      parts.push(`- Quality: ${(data.qualityScore * 100).toFixed(0)}%`);
+      parts.push("");
+    }
+    if (this.config.includeTaskDetails && data.taskOutcomes.length > 0) {
+      parts.push("### Task Outcomes");
+      for (const outcome of data.taskOutcomes) {
+        const statusEmoji = this.getStatusEmoji(outcome.status);
+        parts.push(`${statusEmoji} **${outcome.description}**`);
+        if (outcome.summary) {
+          parts.push(`   ${outcome.summary}`);
+        }
+        if (outcome.error) {
+          parts.push(`   \u26A0\uFE0F Error: ${outcome.error}`);
+        }
+      }
+      parts.push("");
+    }
+    if (this.config.includeArtifacts && data.artifacts.length > 0) {
+      parts.push("### Artifacts");
+      for (const artifact of data.artifacts) {
+        if (artifact.type === "code" && this.config.showCodeBlocks) {
+          parts.push(`**${artifact.name}** (${artifact.language || "code"})`);
+          parts.push("```" + (artifact.language || ""));
+          parts.push(this.truncate(artifact.content));
+          parts.push("```");
+        } else if (artifact.type === "file") {
+          parts.push(`\uD83D\uDCC4 **${artifact.name}**: \`${artifact.path}\``);
+        } else if (artifact.type === "link") {
+          parts.push(`\uD83D\uDD17 **${artifact.name}**: ${artifact.url}`);
+        } else {
+          parts.push(`- **${artifact.name}**: ${this.truncate(artifact.content)}`);
+        }
+      }
+      parts.push("");
+    }
+    if (this.config.includeIssues && data.issues.length > 0) {
+      parts.push("### Issues Found");
+      for (const issue of data.issues) {
+        const severityEmoji = this.getSeverityEmoji(issue.severity);
+        parts.push(`${severityEmoji} **${issue.title}** (${issue.severity})`);
+        parts.push(`   ${issue.description}`);
+        if (issue.suggestedFix) {
+          parts.push(`   \uD83D\uDCA1 Fix: ${issue.suggestedFix}`);
+        }
+      }
+      parts.push("");
+    }
+    if (this.config.includeFollowUps && data.followUps.length > 0) {
+      const required = data.followUps.filter((f) => f.required);
+      if (required.length > 0) {
+        parts.push("### Required Follow-ups");
+        for (const followUp of required) {
+          parts.push(`- [ ] ${followUp.description}`);
+        }
+        parts.push("");
+      }
+    }
+    return parts.join(`
+`).slice(0, this.config.maxContentLength);
+  }
+  formatAsJson(data) {
+    return JSON.stringify(data, null, 2);
+  }
+  formatAsPlain(data) {
+    const parts = [];
+    parts.push(`SWARM EXECUTION ${data.success ? "COMPLETE" : "FAILED"}`);
+    parts.push(`Goal: ${data.goal}`);
+    parts.push("");
+    parts.push(data.summary);
+    parts.push("");
+    if (this.config.includeMetrics) {
+      parts.push(`Tasks: ${data.metrics.completedTasks}/${data.metrics.totalTasks}`);
+      parts.push(`Duration: ${this.formatDuration(data.durationMs)}`);
+      parts.push("");
+    }
+    if (this.config.includeTaskDetails) {
+      parts.push("TASKS:");
+      for (const outcome of data.taskOutcomes) {
+        parts.push(`[${outcome.status.toUpperCase()}] ${outcome.description}`);
+      }
+      parts.push("");
+    }
+    if (this.config.includeIssues && data.issues.length > 0) {
+      parts.push("ISSUES:");
+      for (const issue of data.issues) {
+        parts.push(`[${issue.severity.toUpperCase()}] ${issue.title}`);
+      }
+    }
+    return parts.join(`
+`).slice(0, this.config.maxContentLength);
+  }
+  createInboxMessage(postback) {
+    return {
+      type: "swarm_result",
+      title: `Swarm completed: ${postback.structuredData?.goal || "Unknown"}`,
+      content: postback.content,
+      metadata: {
+        swarmId: postback.swarmId,
+        sessionId: postback.sessionId,
+        success: postback.structuredData?.success,
+        qualityScore: postback.structuredData?.qualityScore,
+        taskCount: postback.structuredData?.taskOutcomes.length,
+        artifactCount: postback.structuredData?.artifacts.length,
+        issueCount: postback.structuredData?.issues.length,
+        durationMs: postback.structuredData?.durationMs
+      }
+    };
+  }
+  extractTaskOutcomes(tasks, result) {
+    const outcomes = [];
+    for (const task of tasks) {
+      const taskResult = result.taskResults[task.id];
+      const outcome = {
+        taskId: task.id,
+        description: task.description,
+        role: task.role,
+        status: this.mapTaskStatus(task.status, taskResult),
+        summary: taskResult?.result ? this.truncate(taskResult.result) : undefined,
+        result: taskResult?.result,
+        error: taskResult?.error,
+        durationMs: task.completedAt && task.startedAt ? task.completedAt - task.startedAt : undefined,
+        artifacts: this.extractArtifactsFromResult(task.id, taskResult)
+      };
+      outcomes.push(outcome);
+    }
+    return outcomes;
+  }
+  extractArtifacts(result, outcomes) {
+    const artifacts = [];
+    for (const outcome of outcomes) {
+      artifacts.push(...outcome.artifacts);
+    }
+    return artifacts;
+  }
+  extractArtifactsFromResult(taskId, result) {
+    if (!result?.result)
+      return [];
+    const artifacts = [];
+    let artifactId = 0;
+    const codeBlockPattern = /```(\w+)?\n([\s\S]*?)```/g;
+    let match;
+    while ((match = codeBlockPattern.exec(result.result)) !== null) {
+      const language = match[1] || "text";
+      const content = match[2].trim();
+      if (content.length > 20) {
+        artifacts.push({
+          id: `${taskId}-code-${artifactId++}`,
+          type: "code",
+          name: `Code block ${artifactId}`,
+          content,
+          sourceTaskId: taskId,
+          language,
+          size: content.length
+        });
+      }
+    }
+    const filePattern = /(?:created?|wrote?|saved?|output|file).*?[`"']([^`"'\s]+\.\w+)[`"']/gi;
+    while ((match = filePattern.exec(result.result)) !== null) {
+      artifacts.push({
+        id: `${taskId}-file-${artifactId++}`,
+        type: "file",
+        name: match[1].split("/").pop() || match[1],
+        content: "",
+        path: match[1],
+        sourceTaskId: taskId
+      });
+    }
+    const urlPattern = /https?:\/\/[^\s<>"']+/g;
+    while ((match = urlPattern.exec(result.result)) !== null) {
+      artifacts.push({
+        id: `${taskId}-link-${artifactId++}`,
+        type: "link",
+        name: "Link",
+        content: match[0],
+        url: match[0],
+        sourceTaskId: taskId
+      });
+    }
+    return artifacts;
+  }
+  mapTaskStatus(taskStatus, result) {
+    if (taskStatus === "completed" && result?.success)
+      return "completed";
+    if (taskStatus === "completed" && !result?.success)
+      return "partial";
+    if (taskStatus === "failed")
+      return "failed";
+    if (taskStatus === "blocked" || taskStatus === "cancelled")
+      return "skipped";
+    return "partial";
+  }
+  generateSummary(result, criticReview) {
+    const parts = [];
+    if (result.success) {
+      parts.push(`Successfully completed ${result.metrics.completedTasks} tasks.`);
+    } else {
+      parts.push(`Execution encountered issues: ${result.error || "Unknown error"}`);
+    }
+    if (criticReview) {
+      if (criticReview.approved) {
+        parts.push("Critic review passed.");
+      } else {
+        parts.push(`Critic found ${criticReview.issues.length} issues.`);
+      }
+    }
+    if (result.result) {
+      parts.push("");
+      parts.push(this.truncate(result.result, 300));
+    }
+    return parts.join(" ");
+  }
+  createDefaultMetadata(result) {
+    return {
+      confidence: result.success ? 0.7 : 0.3,
+      coverage: result.metrics.completedTasks / Math.max(result.metrics.totalTasks, 1),
+      contributingTasks: result.metrics.completedTasks,
+      failedTasks: result.metrics.failedTasks,
+      conflictCount: 0,
+      deduplicationCount: 0,
+      sectionCount: Object.keys(result.taskResults).length,
+      totalLength: result.result?.length || 0,
+      strategy: "merge",
+      conflictResolution: "highest_conf",
+      aggregatedAt: Date.now()
+    };
+  }
+  formatContent(data) {
+    switch (this.config.format) {
+      case "markdown":
+        return this.formatAsMarkdown(data);
+      case "json":
+        return this.formatAsJson(data);
+      case "plain":
+        return this.formatAsPlain(data);
+      case "structured":
+        return this.formatAsMarkdown(data);
+      default:
+        return this.formatAsMarkdown(data);
+    }
+  }
+  applyTemplate(template, data) {
+    return template.replace(/\{\{goal\}\}/g, data.goal).replace(/\{\{summary\}\}/g, data.summary).replace(/\{\{success\}\}/g, String(data.success)).replace(/\{\{qualityScore\}\}/g, String(data.qualityScore)).replace(/\{\{taskCount\}\}/g, String(data.taskOutcomes.length)).replace(/\{\{completedTasks\}\}/g, String(data.metrics.completedTasks)).replace(/\{\{failedTasks\}\}/g, String(data.metrics.failedTasks)).replace(/\{\{duration\}\}/g, this.formatDuration(data.durationMs)).replace(/\{\{issueCount\}\}/g, String(data.issues.length));
+  }
+  truncate(text, maxLength) {
+    const limit = maxLength || this.config.truncationLength;
+    if (!this.config.truncateResults || text.length <= limit) {
+      return text;
+    }
+    return text.slice(0, limit) + "...";
+  }
+  formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    if (ms < 60000)
+      return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.round(ms % 60000 / 1000);
+    return `${minutes}m ${seconds}s`;
+  }
+  getStatusEmoji(status) {
+    switch (status) {
+      case "completed":
+        return "\u2705";
+      case "failed":
+        return "\u274C";
+      case "partial":
+        return "\u26A0\uFE0F";
+      case "skipped":
+        return "\u23ED\uFE0F";
+      default:
+        return "\u2022";
+    }
+  }
+  getSeverityEmoji(severity) {
+    switch (severity) {
+      case "critical":
+        return "\uD83D\uDD34";
+      case "high":
+        return "\uD83D\uDFE0";
+      case "medium":
+        return "\uD83D\uDFE1";
+      case "low":
+        return "\uD83D\uDFE2";
+      case "info":
+        return "\u2139\uFE0F";
+      default:
+        return "\u2022";
+    }
+  }
+}
+function createSwarmPostback(config) {
+  return new SwarmPostback(config);
+}
+var DEFAULT_POSTBACK_CONFIG;
+var init_postback = __esm(() => {
+  DEFAULT_POSTBACK_CONFIG = {
+    format: "markdown",
+    includeTaskDetails: true,
+    includeArtifacts: true,
+    includeMetrics: true,
+    includeIssues: true,
+    includeFollowUps: true,
+    maxContentLength: 1e4,
+    maxArtifacts: 20,
+    truncateResults: true,
+    truncationLength: 500,
+    showCodeBlocks: true,
+    showDuration: true
+  };
+});
+
+// packages/core/src/swarm/status.ts
+class SwarmStatusProvider {
+  config;
+  swarmId;
+  sessionId;
+  state = null;
+  tasks = new Map;
+  agents = new Map;
+  logs = new Map;
+  listeners = new Set;
+  startTime = 0;
+  completedTimes = [];
+  constructor(swarmId, sessionId, config) {
+    this.config = { ...DEFAULT_STATUS_CONFIG, ...config };
+    this.swarmId = swarmId;
+    this.sessionId = sessionId;
+    this.startTime = Date.now();
+  }
+  getSwarmId() {
+    return this.swarmId;
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(type, data) {
+    const event = {
+      type,
+      swarmId: this.swarmId,
+      data,
+      timestamp: Date.now()
+    };
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  updateFromState(state) {
+    this.state = state;
+    if (state.plan) {
+      for (const task of state.plan.tasks) {
+        this.updateTask(task);
+      }
+    }
+    this.emit("progress", this.getProgress());
+  }
+  updateTask(task) {
+    const isDispatchTask = "attempts" in task;
+    const taskStatus = {
+      id: isDispatchTask ? task.id : task.id,
+      description: isDispatchTask ? task.task.description : task.description,
+      role: isDispatchTask ? task.task.role : task.role,
+      status: this.mapStatus(isDispatchTask ? task.status : task.status),
+      progress: this.calculateTaskProgress(task),
+      agentId: isDispatchTask ? task.agentId : task.assignedAgentId,
+      durationMs: this.calculateDuration(task),
+      error: isDispatchTask ? task.error : task.result?.error,
+      dependsOn: isDispatchTask ? task.task.dependsOn : task.dependsOn,
+      blockedBy: [],
+      attempt: isDispatchTask ? task.attempts : 1,
+      maxAttempts: 3
+    };
+    const prevStatus = this.tasks.get(taskStatus.id);
+    this.tasks.set(taskStatus.id, taskStatus);
+    if (prevStatus?.status !== "completed" && taskStatus.status === "completed") {
+      if (taskStatus.durationMs) {
+        this.completedTimes.push(taskStatus.durationMs);
+      }
+    }
+    this.emit("task_update", taskStatus);
+  }
+  updateAgent(agent) {
+    this.agents.set(agent.id, agent);
+    this.emit("agent_update", agent);
+  }
+  addLog(taskId, level, message, data) {
+    if (!this.logs.has(taskId)) {
+      this.logs.set(taskId, []);
+    }
+    const logs = this.logs.get(taskId);
+    logs.push({
+      timestamp: Date.now(),
+      level,
+      message,
+      data
+    });
+    while (logs.length > this.config.maxLogEntries) {
+      logs.shift();
+    }
+  }
+  getSummary() {
+    const elapsedMs = Date.now() - this.startTime;
+    const progress = this.getProgress();
+    return {
+      swarmId: this.swarmId,
+      sessionId: this.sessionId,
+      phase: this.state?.status || "idle",
+      phaseDescription: this.getPhaseDescription(this.state?.status || "idle"),
+      progress,
+      activeAgents: Array.from(this.agents.values()).filter((a) => a.state === "running"),
+      tasks: Array.from(this.tasks.values()),
+      metrics: this.state?.metrics || this.getDefaultMetrics(),
+      startedAt: this.startTime,
+      elapsedMs,
+      estimatedRemainingMs: this.config.estimateRemaining ? this.estimateRemaining(progress, elapsedMs) : undefined,
+      errors: this.state?.errors || [],
+      warnings: [],
+      updatedAt: Date.now()
+    };
+  }
+  getTaskDetail(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task)
+      return null;
+    return {
+      taskId,
+      task,
+      logs: this.logs.get(taskId) || [],
+      result: this.state?.taskResults.get(taskId)?.result,
+      retryHistory: []
+    };
+  }
+  getProgress() {
+    if (this.tasks.size === 0)
+      return 0;
+    const completed = Array.from(this.tasks.values()).filter((t) => t.status === "completed").length;
+    return Math.round(completed / this.tasks.size * 100);
+  }
+  formatProgress(style = "bar", width = 20) {
+    const progress = this.getProgress();
+    switch (style) {
+      case "percent":
+        return `${progress}%`;
+      case "fraction": {
+        const completed = Array.from(this.tasks.values()).filter((t) => t.status === "completed").length;
+        return `${completed}/${this.tasks.size}`;
+      }
+      case "spinner": {
+        const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+        const index = Math.floor(Date.now() / 100) % frames.length;
+        return frames[index];
+      }
+      case "bar":
+      default: {
+        const filled = Math.round(progress / 100 * width);
+        const empty = width - filled;
+        const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+        return `[${bar}] ${progress}%`;
+      }
+    }
+  }
+  formatForTerminal() {
+    const summary = this.getSummary();
+    const lines = [];
+    lines.push(`\uD83D\uDC1D Swarm: ${summary.phase}`);
+    lines.push(this.formatProgress("bar", 30));
+    lines.push("");
+    if (summary.activeAgents.length > 0) {
+      lines.push("Active Agents:");
+      for (const agent of summary.activeAgents) {
+        const taskInfo = agent.currentTask ? ` \u2192 ${agent.currentTask.description.slice(0, 30)}...` : "";
+        lines.push(`  ${agent.name}${taskInfo}`);
+      }
+      lines.push("");
+    }
+    const completed = summary.tasks.filter((t) => t.status === "completed").length;
+    const running = summary.tasks.filter((t) => t.status === "running").length;
+    const pending = summary.tasks.filter((t) => t.status === "pending" || t.status === "waiting").length;
+    const failed = summary.tasks.filter((t) => t.status === "failed").length;
+    lines.push(`Tasks: \u2705 ${completed} | \u23F3 ${running} | \uD83D\uDCCB ${pending} | \u274C ${failed}`);
+    const elapsed = this.formatDuration(summary.elapsedMs);
+    if (summary.estimatedRemainingMs !== undefined) {
+      const remaining = this.formatDuration(summary.estimatedRemainingMs);
+      lines.push(`Time: ${elapsed} elapsed, ~${remaining} remaining`);
+    } else {
+      lines.push(`Time: ${elapsed}`);
+    }
+    if (summary.errors.length > 0) {
+      lines.push("");
+      lines.push("Errors:");
+      for (const error of summary.errors.slice(-3)) {
+        lines.push(`  \u274C ${error}`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  toJSON() {
+    return this.getSummary();
+  }
+  mapStatus(status) {
+    switch (status) {
+      case "pending":
+      case "queued":
+        return "pending";
+      case "waiting_deps":
+        return "waiting";
+      case "running":
+      case "dispatching":
+        return "running";
+      case "completed":
+        return "completed";
+      case "failed":
+      case "timeout":
+        return "failed";
+      case "cancelled":
+      case "blocked":
+        return "cancelled";
+      default:
+        return "pending";
+    }
+  }
+  calculateTaskProgress(task) {
+    const isDispatchTask = "attempts" in task;
+    const status = isDispatchTask ? task.status : task.status;
+    switch (status) {
+      case "completed":
+        return 100;
+      case "running":
+      case "dispatching":
+        return 50;
+      case "waiting_deps":
+        return 10;
+      case "failed":
+      case "timeout":
+      case "cancelled":
+        return 0;
+      default:
+        return 0;
+    }
+  }
+  calculateDuration(task) {
+    const isDispatchTask = "queuedAt" in task;
+    if (isDispatchTask) {
+      const dt = task;
+      if (dt.durationMs)
+        return dt.durationMs;
+      if (dt.startedAt)
+        return Date.now() - dt.startedAt;
+      return;
+    }
+    const st = task;
+    if (st.completedAt && st.startedAt) {
+      return st.completedAt - st.startedAt;
+    }
+    if (st.startedAt) {
+      return Date.now() - st.startedAt;
+    }
+    return;
+  }
+  estimateRemaining(progress, elapsedMs) {
+    if (progress === 0 || progress >= 100)
+      return;
+    if (this.completedTimes.length < 2)
+      return;
+    const avgTime = this.completedTimes.reduce((a, b) => a + b, 0) / this.completedTimes.length;
+    const remaining = this.tasks.size - Array.from(this.tasks.values()).filter((t) => t.status === "completed").length;
+    return Math.round(avgTime * remaining);
+  }
+  getPhaseDescription(phase) {
+    switch (phase) {
+      case "idle":
+        return "Initializing...";
+      case "planning":
+        return "Creating execution plan...";
+      case "executing":
+        return "Executing tasks...";
+      case "reviewing":
+        return "Running critic review...";
+      case "aggregating":
+        return "Aggregating results...";
+      case "completed":
+        return "Completed";
+      case "failed":
+        return "Failed";
+      case "cancelled":
+        return "Cancelled";
+      default:
+        return phase;
+    }
+  }
+  getDefaultMetrics() {
+    return {
+      totalTasks: this.tasks.size,
+      completedTasks: Array.from(this.tasks.values()).filter((t) => t.status === "completed").length,
+      failedTasks: Array.from(this.tasks.values()).filter((t) => t.status === "failed").length,
+      runningTasks: Array.from(this.tasks.values()).filter((t) => t.status === "running").length,
+      tokensUsed: 0,
+      llmCalls: 0,
+      toolCalls: 0,
+      replans: 0
+    };
+  }
+  formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    if (ms < 60000)
+      return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.round(ms % 60000 / 1000);
+    return `${minutes}m ${seconds}s`;
+  }
+}
+function createSwarmStatusProvider(swarmId, sessionId, config) {
+  return new SwarmStatusProvider(swarmId, sessionId, config);
+}
+var DEFAULT_STATUS_CONFIG;
+var init_status = __esm(() => {
+  DEFAULT_STATUS_CONFIG = {
+    updateInterval: 500,
+    maxLogEntries: 100,
+    trackTaskProgress: true,
+    estimateRemaining: true
+  };
+});
+
 // packages/core/src/swarm/index.ts
 var exports_swarm = {};
 __export(exports_swarm, {
   quickAggregate: () => quickAggregate,
+  createSwarmStatusProvider: () => createSwarmStatusProvider,
+  createSwarmPostback: () => createSwarmPostback,
   createSwarmMemoryTools: () => createSwarmMemoryTools,
   createSwarmDispatcher: () => createSwarmDispatcher,
+  createSwarmCritic: () => createSwarmCritic,
   createSwarmAggregator: () => createSwarmAggregator,
   createSwarmAgentSelector: () => createSwarmAgentSelector,
   aggregateTaskResults: () => aggregateTaskResults,
   TaskGraphScheduler: () => TaskGraphScheduler,
   TaskGraphBuilder: () => TaskGraphBuilder,
   TaskGraph: () => TaskGraph,
+  SwarmStatusProvider: () => SwarmStatusProvider,
   SwarmResultsAggregator: () => SwarmResultsAggregator,
+  SwarmPostback: () => SwarmPostback,
   SwarmPolicyEnforcer: () => SwarmPolicyEnforcer,
   SwarmMemory: () => SwarmMemory,
   SwarmDispatcher: () => SwarmDispatcher,
   SwarmDecisionPolicy: () => SwarmDecisionPolicy,
+  SwarmCritic: () => SwarmCritic,
   SwarmCoordinator: () => SwarmCoordinator,
   SwarmAgentSelector: () => SwarmAgentSelector,
   ROLE_SYSTEM_PROMPTS: () => ROLE_SYSTEM_PROMPTS,
   DEFAULT_SWARM_CONFIG: () => DEFAULT_SWARM_CONFIG,
+  DEFAULT_STATUS_CONFIG: () => DEFAULT_STATUS_CONFIG,
   DEFAULT_SELECTOR_CONFIG: () => DEFAULT_SELECTOR_CONFIG,
   DEFAULT_SCHEDULER_OPTIONS: () => DEFAULT_SCHEDULER_OPTIONS,
+  DEFAULT_POSTBACK_CONFIG: () => DEFAULT_POSTBACK_CONFIG,
   DEFAULT_DISPATCHER_CONFIG: () => DEFAULT_DISPATCHER_CONFIG,
   DEFAULT_DECISION_POLICY: () => DEFAULT_DECISION_POLICY,
+  DEFAULT_CRITIC_CONFIG: () => DEFAULT_CRITIC_CONFIG,
   DEFAULT_BUILDER_OPTIONS: () => DEFAULT_BUILDER_OPTIONS,
   DEFAULT_AGGREGATOR_CONFIG: () => DEFAULT_AGGREGATOR_CONFIG
 });
@@ -54979,6 +56084,9 @@ var init_swarm = __esm(() => {
   init_agent_selector();
   init_dispatcher();
   init_aggregator();
+  init_critic();
+  init_postback();
+  init_status();
   init_types3();
 });
 
@@ -133994,6 +135102,30 @@ import { homedir as homedir13, platform as platform2, release, arch as arch2 } f
 init_src2();
 await init_config();
 import { existsSync as existsSync12, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
+
+// packages/core/src/scheduler/format.ts
+function formatRelativeTime(timestamp, now2 = Date.now()) {
+  if (!timestamp)
+    return "n/a";
+  const diff = timestamp - now2;
+  const absDiff = Math.abs(diff);
+  const isPast = diff < 0;
+  const seconds = Math.floor(absDiff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  let timeStr;
+  if (days > 0) {
+    timeStr = `${days}d ${hours % 24}h`;
+  } else if (hours > 0) {
+    timeStr = `${hours}h ${minutes % 60}m`;
+  } else if (minutes > 0) {
+    timeStr = `${minutes}m ${seconds % 60}s`;
+  } else {
+    timeStr = `${seconds}s`;
+  }
+  return isPast ? `${timeStr} ago` : `in ${timeStr}`;
+}
 // packages/core/src/jobs/job-manager.ts
 init_src2();
 
@@ -134893,7 +136025,7 @@ async function cancelRecurringTask(cwd, id) {
   return task;
 }
 // packages/core/src/commands/builtin.ts
-var VERSION = "0.6.61";
+var VERSION = "0.6.62";
 function resolveAuthTimeout(resolve5) {
   resolve5({ exitCode: 1, stdout: { toString: () => "{}" } });
 }
@@ -140918,30 +142050,60 @@ Importing ${validMemories.length} valid entries (skipping ${errors.length} inval
   schedulesCommand() {
     return {
       name: "schedules",
-      description: "List scheduled commands",
+      description: "Browse and manage scheduled commands",
       builtin: true,
       selfHandled: true,
       content: "",
-      handler: async (_args, context) => {
-        const schedules = await listSchedules(context.cwd);
-        if (schedules.length === 0) {
-          context.emit("text", `No schedules found.
-`);
+      handler: async (args, context) => {
+        const trimmed = args.trim().toLowerCase();
+        if (!trimmed || trimmed === "ui") {
           context.emit("done");
-          return { handled: true };
+          return { handled: true, showPanel: "schedules" };
         }
-        const escapeCell = (value) => value.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
-        let output = `
+        if (trimmed === "list" || trimmed === "--list") {
+          const schedules = await listSchedules(context.cwd);
+          if (schedules.length === 0) {
+            context.emit("text", `No schedules found.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const escapeCell = (value) => value.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
+          let output = `
 | ID | Status | Next Run | Command |
 `;
-        output += `|----|--------|----------|---------|
+          output += `|----|--------|----------|---------|
 `;
-        for (const schedule of schedules.sort((a, b) => (a.nextRunAt || 0) - (b.nextRunAt || 0))) {
-          const next = schedule.nextRunAt ? new Date(schedule.nextRunAt).toISOString() : "n/a";
-          output += `| ${schedule.id} | ${schedule.status} | ${next} | ${escapeCell(schedule.command)} |
+          for (const schedule of schedules.sort((a, b) => (a.nextRunAt || 0) - (b.nextRunAt || 0))) {
+            const next = formatRelativeTime(schedule.nextRunAt);
+            const cmd = escapeCell(schedule.command.slice(0, 40) + (schedule.command.length > 40 ? "..." : ""));
+            output += `| ${schedule.id.slice(0, 8)} | ${schedule.status} | ${next} | ${cmd} |
 `;
+          }
+          context.emit("text", output);
+          context.emit("done");
+          return { handled: true };
         }
-        context.emit("text", output);
+        context.emit("text", `
+**Schedules** - Manage scheduled commands
+
+`);
+        context.emit("text", `Usage:
+`);
+        context.emit("text", `  /schedules           Open interactive panel
+`);
+        context.emit("text", `  /schedules ui        Open interactive panel
+`);
+        context.emit("text", `  /schedules list      Show text table (scripting)
+`);
+        context.emit("text", `  /schedule <time> <cmd>  Create a schedule
+`);
+        context.emit("text", `  /unschedule <id>     Delete a schedule
+`);
+        context.emit("text", `  /pause <id>          Pause a schedule
+`);
+        context.emit("text", `  /resume <id>         Resume a schedule
+`);
         context.emit("done");
         return { handled: true };
       }
@@ -173433,7 +174595,7 @@ var import_react25 = __toESM(require_react(), 1);
 // node_modules/.pnpm/ink@6.6.0_@types+react@19.2.10_react-devtools-core@6.1.5_react@19.2.4/node_modules/ink/build/hooks/use-is-screen-reader-enabled.js
 var import_react26 = __toESM(require_react(), 1);
 // packages/terminal/src/components/App.tsx
-var import_react45 = __toESM(require_react(), 1);
+var import_react46 = __toESM(require_react(), 1);
 init_src2();
 
 // packages/terminal/src/components/Input.tsx
@@ -178923,31 +180085,113 @@ function TasksPanel({
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      tasks2.length > 0 && selectedIndex < tasks2.length && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
-        marginTop: 1,
-        flexDirection: "column",
-        children: [
-          /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
-            dimColor: true,
-            wrap: "wrap",
-            children: tasks2[selectedIndex].description
-          }, undefined, false, undefined, this),
-          tasks2[selectedIndex].error && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
-            color: "red",
-            children: [
-              "Error: ",
-              tasks2[selectedIndex].error
-            ]
-          }, undefined, true, undefined, this),
-          tasks2[selectedIndex].result && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
-            color: "green",
-            children: [
-              "Result: ",
-              tasks2[selectedIndex].result
-            ]
-          }, undefined, true, undefined, this)
-        ]
-      }, undefined, true, undefined, this),
+      tasks2.length > 0 && selectedIndex < tasks2.length && (() => {
+        const task = tasks2[selectedIndex];
+        const formatTime = (ts2) => ts2 ? new Date(ts2).toLocaleString() : "n/a";
+        const getElapsed = () => {
+          if (task.status !== "in_progress" || !task.startedAt)
+            return null;
+          const elapsed2 = Date.now() - task.startedAt;
+          const secs = Math.floor(elapsed2 / 1000);
+          const mins = Math.floor(secs / 60);
+          const hrs = Math.floor(mins / 60);
+          if (hrs > 0)
+            return `${hrs}h ${mins % 60}m elapsed`;
+          if (mins > 0)
+            return `${mins}m ${secs % 60}s elapsed`;
+          return `${secs}s elapsed`;
+        };
+        const elapsed = getElapsed();
+        return /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
+          marginTop: 1,
+          flexDirection: "column",
+          borderStyle: "single",
+          borderColor: "gray",
+          paddingX: 1,
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              bold: true,
+              wrap: "wrap",
+              children: task.description
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
+              marginTop: 0,
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+                  dimColor: true,
+                  children: [
+                    "Created: ",
+                    formatTime(task.createdAt)
+                  ]
+                }, undefined, true, undefined, this),
+                elapsed && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+                  color: "yellow",
+                  children: [
+                    " | ",
+                    elapsed
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            task.startedAt && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              dimColor: true,
+              children: [
+                "Started: ",
+                formatTime(task.startedAt)
+              ]
+            }, undefined, true, undefined, this),
+            task.completedAt && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              dimColor: true,
+              children: [
+                "Completed: ",
+                formatTime(task.completedAt)
+              ]
+            }, undefined, true, undefined, this),
+            task.blockedBy && task.blockedBy.length > 0 && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              dimColor: true,
+              children: [
+                "Blocked by: ",
+                task.blockedBy.map((id) => getTaskLabel(id)).join(", ")
+              ]
+            }, undefined, true, undefined, this),
+            task.blocks && task.blocks.length > 0 && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              dimColor: true,
+              children: [
+                "Blocks: ",
+                task.blocks.map((id) => getTaskLabel(id)).join(", ")
+              ]
+            }, undefined, true, undefined, this),
+            task.assignee && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              dimColor: true,
+              children: [
+                "Assignee: ",
+                task.assignee
+              ]
+            }, undefined, true, undefined, this),
+            task.projectId && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              dimColor: true,
+              children: [
+                "Project: ",
+                task.projectId
+              ]
+            }, undefined, true, undefined, this),
+            task.error && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              color: "red",
+              children: [
+                "Error: ",
+                task.error
+              ]
+            }, undefined, true, undefined, this),
+            task.result && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
+              color: "green",
+              children: [
+                "Result: ",
+                task.result
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this);
+      })(),
       /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
         marginTop: 1,
         children: /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Text3, {
@@ -182101,7 +183345,7 @@ function getVisibleRange2(selectedIndex, totalItems, maxVisible = MAX_VISIBLE_IT
     }
   };
 }
-function formatRelativeTime(isoDate) {
+function formatRelativeTime2(isoDate) {
   const date = new Date(isoDate);
   const now2 = new Date;
   const diffMs = now2.getTime() - date.getTime();
@@ -182491,7 +183735,7 @@ function MessagesPanel({
                   children: "Received: "
                 }, undefined, false, undefined, this),
                 /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text3, {
-                  children: formatRelativeTime(detailMessage.createdAt)
+                  children: formatRelativeTime2(detailMessage.createdAt)
                 }, undefined, false, undefined, this),
                 /* @__PURE__ */ jsx_dev_runtime19.jsxDEV(Text3, {
                   dimColor: true,
@@ -182623,7 +183867,7 @@ function MessagesPanel({
                   dimColor: true,
                   children: [
                     " ",
-                    formatRelativeTime(msg.createdAt)
+                    formatRelativeTime2(msg.createdAt)
                   ]
                 }, undefined, true, undefined, this)
               ]
@@ -184675,8 +185919,566 @@ function AgentsPanel({
   }, undefined, true, undefined, this);
 }
 
-// packages/terminal/src/components/App.tsx
+// packages/terminal/src/components/SchedulesPanel.tsx
+var import_react45 = __toESM(require_react(), 1);
 var jsx_dev_runtime23 = __toESM(require_jsx_dev_runtime(), 1);
+var STATUS_ICONS2 = {
+  active: "\u25CF",
+  paused: "\u25D0",
+  completed: "\u2713",
+  error: "\u2717"
+};
+var STATUS_COLORS2 = {
+  active: "green",
+  paused: "yellow",
+  completed: "gray",
+  error: "red"
+};
+var KIND_LABELS = {
+  once: "One-time",
+  cron: "Cron",
+  random: "Random",
+  interval: "Interval"
+};
+function formatRelativeTime3(timestamp) {
+  if (!timestamp)
+    return "n/a";
+  const now2 = Date.now();
+  const diff2 = timestamp - now2;
+  const absDiff = Math.abs(diff2);
+  const isPast = diff2 < 0;
+  const seconds = Math.floor(absDiff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  let timeStr;
+  if (days > 0) {
+    timeStr = `${days}d ${hours % 24}h`;
+  } else if (hours > 0) {
+    timeStr = `${hours}h ${minutes % 60}m`;
+  } else if (minutes > 0) {
+    timeStr = `${minutes}m`;
+  } else {
+    timeStr = `${seconds}s`;
+  }
+  return isPast ? `${timeStr} ago` : `in ${timeStr}`;
+}
+function formatAbsoluteTime2(timestamp) {
+  if (!timestamp)
+    return "n/a";
+  return new Date(timestamp).toLocaleString();
+}
+function getScheduleDescription(schedule) {
+  const { kind: kind2, cron, at: at4, interval, unit, minInterval, maxInterval } = schedule.schedule;
+  switch (kind2) {
+    case "once":
+      return at4 ? `At ${at4}` : "One-time";
+    case "cron":
+      return cron || "Cron schedule";
+    case "interval":
+      return `Every ${interval} ${unit || "minutes"}`;
+    case "random":
+      return `Random ${minInterval}-${maxInterval} ${unit || "minutes"}`;
+    default:
+      return kind2;
+  }
+}
+function SchedulesPanel({
+  schedules,
+  onPause,
+  onResume,
+  onDelete,
+  onRun,
+  onRefresh,
+  onClose
+}) {
+  const [selectedIndex, setSelectedIndex] = import_react45.useState(0);
+  const [mode, setMode] = import_react45.useState("list");
+  const [isSubmitting, setIsSubmitting] = import_react45.useState(false);
+  const sortedSchedules = [...schedules].sort((a5, b8) => {
+    if (a5.status === "active" && b8.status !== "active")
+      return -1;
+    if (b8.status === "active" && a5.status !== "active")
+      return 1;
+    const aNext = a5.nextRunAt || Infinity;
+    const bNext = b8.nextRunAt || Infinity;
+    return aNext - bNext;
+  });
+  import_react45.useEffect(() => {
+    setSelectedIndex((prev) => Math.min(prev, Math.max(0, sortedSchedules.length - 1)));
+  }, [sortedSchedules.length]);
+  const selectedSchedule = sortedSchedules[selectedIndex];
+  use_input_default((input, key) => {
+    if (mode === "delete-confirm") {
+      if (input === "y" || input === "Y") {
+        if (selectedSchedule) {
+          setIsSubmitting(true);
+          onDelete(selectedSchedule.id).finally(() => {
+            setIsSubmitting(false);
+            setMode("list");
+          });
+        }
+        return;
+      }
+      if (input === "n" || input === "N" || key.escape) {
+        setMode("list");
+        return;
+      }
+      return;
+    }
+    if (mode === "detail") {
+      if (key.escape || input === "q") {
+        setMode("list");
+        return;
+      }
+      if (input === "p" || input === "P") {
+        if (selectedSchedule && selectedSchedule.status === "active") {
+          setIsSubmitting(true);
+          onPause(selectedSchedule.id).finally(() => setIsSubmitting(false));
+        }
+        return;
+      }
+      if (input === "r" || input === "R") {
+        if (selectedSchedule && selectedSchedule.status === "paused") {
+          setIsSubmitting(true);
+          onResume(selectedSchedule.id).finally(() => setIsSubmitting(false));
+        } else if (selectedSchedule) {
+          setIsSubmitting(true);
+          onRun(selectedSchedule.id).finally(() => setIsSubmitting(false));
+        }
+        return;
+      }
+      if (input === "d" || input === "D") {
+        setMode("delete-confirm");
+        return;
+      }
+      return;
+    }
+    if (key.escape || input === "q") {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      if (sortedSchedules.length > 0) {
+        setMode("detail");
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => prev === 0 ? sortedSchedules.length - 1 : prev - 1);
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => prev === sortedSchedules.length - 1 ? 0 : prev + 1);
+      return;
+    }
+    if (input === "p" || input === "P") {
+      if (selectedSchedule && selectedSchedule.status === "active") {
+        setIsSubmitting(true);
+        onPause(selectedSchedule.id).finally(() => setIsSubmitting(false));
+      }
+      return;
+    }
+    if (input === "r" || input === "R") {
+      if (selectedSchedule) {
+        setIsSubmitting(true);
+        if (selectedSchedule.status === "paused") {
+          onResume(selectedSchedule.id).finally(() => setIsSubmitting(false));
+        } else {
+          onRun(selectedSchedule.id).finally(() => setIsSubmitting(false));
+        }
+      }
+      return;
+    }
+    if (input === "d" || input === "D") {
+      if (selectedSchedule) {
+        setMode("delete-confirm");
+      }
+      return;
+    }
+    if (input === "f" || input === "F") {
+      setIsSubmitting(true);
+      onRefresh().finally(() => setIsSubmitting(false));
+      return;
+    }
+    const num = parseInt(input, 10);
+    if (!isNaN(num) && num >= 1 && num <= sortedSchedules.length) {
+      setSelectedIndex(num - 1);
+      return;
+    }
+  });
+  if (mode === "delete-confirm") {
+    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+      flexDirection: "column",
+      paddingY: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          marginBottom: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            bold: true,
+            color: "red",
+            children: "Delete Schedule"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          marginBottom: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            children: [
+              'Delete schedule: "',
+              selectedSchedule?.command.slice(0, 50),
+              (selectedSchedule?.command.length || 0) > 50 ? "..." : "",
+              '"?'
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            children: [
+              "Press ",
+              /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                color: "green",
+                bold: true,
+                children: "y"
+              }, undefined, false, undefined, this),
+              " to confirm or",
+              " ",
+              /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                color: "red",
+                bold: true,
+                children: "n"
+              }, undefined, false, undefined, this),
+              " to cancel"
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  if (mode === "detail" && selectedSchedule) {
+    const s6 = selectedSchedule;
+    const statusIcon = STATUS_ICONS2[s6.status];
+    const statusColor = STATUS_COLORS2[s6.status];
+    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+      flexDirection: "column",
+      paddingY: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          marginBottom: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            bold: true,
+            color: "cyan",
+            children: "Schedule Details"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "gray",
+          paddingX: 1,
+          paddingY: 0,
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "ID: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  children: s6.id
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Status: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  color: statusColor,
+                  children: [
+                    statusIcon,
+                    " ",
+                    s6.status
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Type: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  children: KIND_LABELS[s6.schedule.kind] || s6.schedule.kind
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Schedule: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  children: getScheduleDescription(s6)
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            s6.description && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Description: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  children: s6.description
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              marginTop: 1,
+              children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                bold: true,
+                children: "Command: "
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              marginLeft: 2,
+              children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                wrap: "wrap",
+                color: "cyan",
+                children: s6.command
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            s6.message && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(jsx_dev_runtime23.Fragment, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+                  marginTop: 1,
+                  children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                    bold: true,
+                    children: "Message: "
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+                  marginLeft: 2,
+                  children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                    wrap: "wrap",
+                    children: s6.message
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              marginTop: 1,
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Next Run: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  color: s6.status === "active" ? "green" : undefined,
+                  children: [
+                    formatAbsoluteTime2(s6.nextRunAt),
+                    " (",
+                    formatRelativeTime3(s6.nextRunAt),
+                    ")"
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Last Run: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  children: formatAbsoluteTime2(s6.lastRunAt)
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            s6.lastResult && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Last Result: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  color: s6.lastResult.ok ? "green" : "red",
+                  children: s6.lastResult.ok ? "Success" : `Error: ${s6.lastResult.error}`
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  bold: true,
+                  children: "Created: "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  children: [
+                    formatAbsoluteTime2(s6.createdAt),
+                    " by ",
+                    s6.createdBy
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            dimColor: true,
+            children: [
+              s6.status === "active" ? "[p]ause" : s6.status === "paused" ? "[r]esume" : "",
+              " ",
+              "[r]un now | [d]elete | Esc back"
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this),
+        isSubmitting && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            color: "yellow",
+            children: "Processing..."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  const activeCount = schedules.filter((s6) => s6.status === "active").length;
+  const pausedCount = schedules.filter((s6) => s6.status === "paused").length;
+  const completedCount = schedules.filter((s6) => s6.status === "completed").length;
+  const errorCount = schedules.filter((s6) => s6.status === "error").length;
+  return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    flexDirection: "column",
+    paddingY: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+        marginBottom: 1,
+        justifyContent: "space-between",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+            children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+              bold: true,
+              children: "Schedules"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            dimColor: true,
+            children: "[p]ause [r]esume [d]elete [f]refresh"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+          dimColor: true,
+          children: [
+            activeCount,
+            " active, ",
+            pausedCount,
+            " paused, ",
+            completedCount,
+            " done, ",
+            errorCount,
+            " errors"
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "gray",
+        paddingX: 1,
+        children: sortedSchedules.length === 0 ? /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          paddingY: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            dimColor: true,
+            children: "No schedules. Use /schedule to create one."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this) : sortedSchedules.map((schedule, index) => {
+          const isSelected = index === selectedIndex;
+          const statusIcon = STATUS_ICONS2[schedule.status];
+          const statusColor = STATUS_COLORS2[schedule.status];
+          const nextRun = formatRelativeTime3(schedule.nextRunAt);
+          const command = schedule.command.slice(0, 35) + (schedule.command.length > 35 ? "..." : "");
+          const kindLabel = KIND_LABELS[schedule.schedule.kind] || schedule.schedule.kind;
+          return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+            paddingY: 0,
+            children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+              inverse: isSelected,
+              dimColor: !isSelected && schedule.status === "completed",
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                  color: statusColor,
+                  children: statusIcon
+                }, undefined, false, undefined, this),
+                " ",
+                index + 1,
+                ". ",
+                command.padEnd(37),
+                " ",
+                kindLabel.padEnd(10),
+                " ",
+                nextRun
+              ]
+            }, undefined, true, undefined, this)
+          }, schedule.id, false, undefined, this);
+        })
+      }, undefined, false, undefined, this),
+      sortedSchedules.length > 0 && selectedSchedule && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            dimColor: true,
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                bold: true,
+                children: "Command:"
+              }, undefined, false, undefined, this),
+              " ",
+              selectedSchedule.command
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            dimColor: true,
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+                bold: true,
+                children: "Schedule:"
+              }, undefined, false, undefined, this),
+              " ",
+              getScheduleDescription(selectedSchedule)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+          dimColor: true,
+          children: "Enter view | \u2191/\u2193 navigate | Esc close"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      isSubmitting && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+          color: "yellow",
+          children: "Processing..."
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// packages/terminal/src/components/App.tsx
+var jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
 var SHOW_ERROR_CODES = process.env.ASSISTANTS_DEBUG === "1";
 function formatElapsedDuration(ms2) {
   const totalSeconds = Math.max(0, Math.floor(ms2 / 1000));
@@ -184708,84 +186510,86 @@ function App2({ cwd: cwd2, version: version3 }) {
   const { stdout } = use_stdout_default();
   const rows = stdout?.rows ?? 24;
   const columns = stdout?.columns ?? 80;
-  const [registry3] = import_react45.useState(() => new SessionRegistry);
-  const registryRef = import_react45.useRef(registry3);
-  const [activeSessionId, setActiveSessionId] = import_react45.useState(null);
-  const [isInitializing, setIsInitializing] = import_react45.useState(true);
-  const [showSessionSelector, setShowSessionSelector] = import_react45.useState(false);
-  const [recoverableSessions, setRecoverableSessions] = import_react45.useState([]);
-  const [showRecoveryPanel, setShowRecoveryPanel] = import_react45.useState(false);
-  const [showConnectorsPanel, setShowConnectorsPanel] = import_react45.useState(false);
-  const [connectorsPanelInitial, setConnectorsPanelInitial] = import_react45.useState();
-  const [connectors, setConnectors] = import_react45.useState([]);
-  const connectorBridgeRef = import_react45.useRef(null);
-  const [showTasksPanel, setShowTasksPanel] = import_react45.useState(false);
-  const [tasksList, setTasksList] = import_react45.useState([]);
-  const [tasksPaused, setTasksPaused] = import_react45.useState(false);
-  const [showAssistantsPanel, setShowAssistantsPanel] = import_react45.useState(false);
-  const [assistantsRefreshKey, setAssistantsRefreshKey] = import_react45.useState(0);
-  const [assistantError, setAssistantError] = import_react45.useState(null);
-  const [showHooksPanel, setShowHooksPanel] = import_react45.useState(false);
-  const [hooksConfig, setHooksConfig] = import_react45.useState({});
-  const hookStoreRef = import_react45.useRef(null);
-  const [showGuardrailsPanel, setShowGuardrailsPanel] = import_react45.useState(false);
-  const [guardrailsConfig, setGuardrailsConfig] = import_react45.useState(null);
-  const [guardrailsPolicies, setGuardrailsPolicies] = import_react45.useState([]);
-  const guardrailsStoreRef = import_react45.useRef(null);
-  const [showBudgetPanel, setShowBudgetPanel] = import_react45.useState(false);
-  const [budgetConfig, setBudgetConfig] = import_react45.useState(null);
-  const [sessionBudgetStatus, setSessionBudgetStatus] = import_react45.useState(null);
-  const [swarmBudgetStatus, setSwarmBudgetStatus] = import_react45.useState(null);
-  const budgetTrackerRef = import_react45.useRef(null);
-  const [showAgentsPanel, setShowAgentsPanel] = import_react45.useState(false);
-  const [agentsList, setAgentsList] = import_react45.useState([]);
-  const [registryStats, setRegistryStats] = import_react45.useState(null);
-  const [showConfigPanel, setShowConfigPanel] = import_react45.useState(false);
-  const [currentConfig, setCurrentConfig] = import_react45.useState(null);
-  const [userConfig, setUserConfig] = import_react45.useState(null);
-  const [projectConfig, setProjectConfig] = import_react45.useState(null);
-  const [localConfig, setLocalConfig] = import_react45.useState(null);
-  const [showMessagesPanel, setShowMessagesPanel] = import_react45.useState(false);
-  const [messagesPanelError, setMessagesPanelError] = import_react45.useState(null);
-  const [messagesList, setMessagesList] = import_react45.useState([]);
-  const sessionUIStates = import_react45.useRef(new Map);
-  const [messages2, setMessages] = import_react45.useState([]);
-  const [currentResponse, setCurrentResponse] = import_react45.useState("");
-  const [currentToolCall, setCurrentToolCall] = import_react45.useState();
-  const [isProcessing, setIsProcessing] = import_react45.useState(false);
-  const [error2, setError] = import_react45.useState(null);
-  const [messageQueue, setMessageQueue] = import_react45.useState([]);
-  const [inlinePending, setInlinePending] = import_react45.useState([]);
-  const [activityLog, setActivityLog] = import_react45.useState([]);
-  const [tokenUsage, setTokenUsage] = import_react45.useState();
-  const [energyState, setEnergyState] = import_react45.useState();
-  const [voiceState, setVoiceState] = import_react45.useState();
-  const [heartbeatState, setHeartbeatState] = import_react45.useState();
-  const [identityInfo, setIdentityInfo] = import_react45.useState();
-  const [verboseTools, setVerboseTools] = import_react45.useState(false);
-  const [askUserState, setAskUserState] = import_react45.useState(null);
-  const [processingStartTime, setProcessingStartTime] = import_react45.useState();
-  const [currentTurnTokens, setCurrentTurnTokens] = import_react45.useState(0);
-  const [lastWorkedFor, setLastWorkedFor] = import_react45.useState();
-  const [skills, setSkills] = import_react45.useState([]);
-  const [commands3, setCommands] = import_react45.useState([]);
-  const lastCtrlCRef = import_react45.useRef(0);
-  const [showExitHint, setShowExitHint] = import_react45.useState(false);
-  const responseRef = import_react45.useRef("");
-  const toolCallsRef = import_react45.useRef([]);
-  const toolResultsRef = import_react45.useRef([]);
-  const activityLogRef = import_react45.useRef([]);
-  const skipNextDoneRef = import_react45.useRef(false);
-  const isProcessingRef = import_react45.useRef(isProcessing);
-  const processingStartTimeRef = import_react45.useRef(processingStartTime);
-  const pendingSendsRef = import_react45.useRef([]);
-  const askUserStateRef = import_react45.useRef(new Map);
-  const [queueFlushTrigger, setQueueFlushTrigger] = import_react45.useState(0);
-  const clearPendingSend = import_react45.useCallback((id, sessionId) => {
+  const [registry3] = import_react46.useState(() => new SessionRegistry);
+  const registryRef = import_react46.useRef(registry3);
+  const [activeSessionId, setActiveSessionId] = import_react46.useState(null);
+  const [isInitializing, setIsInitializing] = import_react46.useState(true);
+  const [showSessionSelector, setShowSessionSelector] = import_react46.useState(false);
+  const [recoverableSessions, setRecoverableSessions] = import_react46.useState([]);
+  const [showRecoveryPanel, setShowRecoveryPanel] = import_react46.useState(false);
+  const [showConnectorsPanel, setShowConnectorsPanel] = import_react46.useState(false);
+  const [connectorsPanelInitial, setConnectorsPanelInitial] = import_react46.useState();
+  const [connectors, setConnectors] = import_react46.useState([]);
+  const connectorBridgeRef = import_react46.useRef(null);
+  const [showTasksPanel, setShowTasksPanel] = import_react46.useState(false);
+  const [tasksList, setTasksList] = import_react46.useState([]);
+  const [tasksPaused, setTasksPaused] = import_react46.useState(false);
+  const [showSchedulesPanel, setShowSchedulesPanel] = import_react46.useState(false);
+  const [schedulesList, setSchedulesList] = import_react46.useState([]);
+  const [showAssistantsPanel, setShowAssistantsPanel] = import_react46.useState(false);
+  const [assistantsRefreshKey, setAssistantsRefreshKey] = import_react46.useState(0);
+  const [assistantError, setAssistantError] = import_react46.useState(null);
+  const [showHooksPanel, setShowHooksPanel] = import_react46.useState(false);
+  const [hooksConfig, setHooksConfig] = import_react46.useState({});
+  const hookStoreRef = import_react46.useRef(null);
+  const [showGuardrailsPanel, setShowGuardrailsPanel] = import_react46.useState(false);
+  const [guardrailsConfig, setGuardrailsConfig] = import_react46.useState(null);
+  const [guardrailsPolicies, setGuardrailsPolicies] = import_react46.useState([]);
+  const guardrailsStoreRef = import_react46.useRef(null);
+  const [showBudgetPanel, setShowBudgetPanel] = import_react46.useState(false);
+  const [budgetConfig, setBudgetConfig] = import_react46.useState(null);
+  const [sessionBudgetStatus, setSessionBudgetStatus] = import_react46.useState(null);
+  const [swarmBudgetStatus, setSwarmBudgetStatus] = import_react46.useState(null);
+  const budgetTrackerRef = import_react46.useRef(null);
+  const [showAgentsPanel, setShowAgentsPanel] = import_react46.useState(false);
+  const [agentsList, setAgentsList] = import_react46.useState([]);
+  const [registryStats, setRegistryStats] = import_react46.useState(null);
+  const [showConfigPanel, setShowConfigPanel] = import_react46.useState(false);
+  const [currentConfig, setCurrentConfig] = import_react46.useState(null);
+  const [userConfig, setUserConfig] = import_react46.useState(null);
+  const [projectConfig, setProjectConfig] = import_react46.useState(null);
+  const [localConfig, setLocalConfig] = import_react46.useState(null);
+  const [showMessagesPanel, setShowMessagesPanel] = import_react46.useState(false);
+  const [messagesPanelError, setMessagesPanelError] = import_react46.useState(null);
+  const [messagesList, setMessagesList] = import_react46.useState([]);
+  const sessionUIStates = import_react46.useRef(new Map);
+  const [messages2, setMessages] = import_react46.useState([]);
+  const [currentResponse, setCurrentResponse] = import_react46.useState("");
+  const [currentToolCall, setCurrentToolCall] = import_react46.useState();
+  const [isProcessing, setIsProcessing] = import_react46.useState(false);
+  const [error2, setError] = import_react46.useState(null);
+  const [messageQueue, setMessageQueue] = import_react46.useState([]);
+  const [inlinePending, setInlinePending] = import_react46.useState([]);
+  const [activityLog, setActivityLog] = import_react46.useState([]);
+  const [tokenUsage, setTokenUsage] = import_react46.useState();
+  const [energyState, setEnergyState] = import_react46.useState();
+  const [voiceState, setVoiceState] = import_react46.useState();
+  const [heartbeatState, setHeartbeatState] = import_react46.useState();
+  const [identityInfo, setIdentityInfo] = import_react46.useState();
+  const [verboseTools, setVerboseTools] = import_react46.useState(false);
+  const [askUserState, setAskUserState] = import_react46.useState(null);
+  const [processingStartTime, setProcessingStartTime] = import_react46.useState();
+  const [currentTurnTokens, setCurrentTurnTokens] = import_react46.useState(0);
+  const [lastWorkedFor, setLastWorkedFor] = import_react46.useState();
+  const [skills, setSkills] = import_react46.useState([]);
+  const [commands3, setCommands] = import_react46.useState([]);
+  const lastCtrlCRef = import_react46.useRef(0);
+  const [showExitHint, setShowExitHint] = import_react46.useState(false);
+  const responseRef = import_react46.useRef("");
+  const toolCallsRef = import_react46.useRef([]);
+  const toolResultsRef = import_react46.useRef([]);
+  const activityLogRef = import_react46.useRef([]);
+  const skipNextDoneRef = import_react46.useRef(false);
+  const isProcessingRef = import_react46.useRef(isProcessing);
+  const processingStartTimeRef = import_react46.useRef(processingStartTime);
+  const pendingSendsRef = import_react46.useRef([]);
+  const askUserStateRef = import_react46.useRef(new Map);
+  const [queueFlushTrigger, setQueueFlushTrigger] = import_react46.useState(0);
+  const clearPendingSend = import_react46.useCallback((id, sessionId) => {
     pendingSendsRef.current = pendingSendsRef.current.filter((entry) => entry.id !== id || entry.sessionId !== sessionId);
     setInlinePending((prev) => prev.filter((msg) => msg.id !== id));
   }, []);
-  const beginAskUser = import_react45.useCallback((sessionId, request2) => {
+  const beginAskUser = import_react46.useCallback((sessionId, request2) => {
     return new Promise((resolve5, reject) => {
       if (askUserStateRef.current.has(sessionId)) {
         reject(new Error("Another interview is already in progress for this session."));
@@ -184805,7 +186609,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       }
     });
   }, [activeSessionId]);
-  const cancelAskUser = import_react45.useCallback((reason, sessionId) => {
+  const cancelAskUser = import_react46.useCallback((reason, sessionId) => {
     const activeId = sessionId ?? activeSessionId;
     if (!activeId)
       return;
@@ -184818,7 +186622,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     }
     current.reject(new Error(reason));
   }, [activeSessionId]);
-  const submitAskAnswer = import_react45.useCallback((answer) => {
+  const submitAskAnswer = import_react46.useCallback((answer) => {
     setAskUserState((prev) => {
       if (!prev)
         return prev;
@@ -184839,24 +186643,24 @@ function App2({ cwd: cwd2, version: version3 }) {
       return nextState;
     });
   }, []);
-  const turnIdRef = import_react45.useRef(0);
-  const initStateRef = import_react45.useRef("idle");
-  const isMountedRef = import_react45.useRef(true);
-  const handlersRegisteredRef = import_react45.useRef(false);
-  import_react45.useEffect(() => {
+  const turnIdRef = import_react46.useRef(0);
+  const initStateRef = import_react46.useRef("idle");
+  const isMountedRef = import_react46.useRef(true);
+  const handlersRegisteredRef = import_react46.useRef(false);
+  import_react46.useEffect(() => {
     isProcessingRef.current = isProcessing;
   }, [isProcessing]);
-  import_react45.useEffect(() => {
+  import_react46.useEffect(() => {
     processingStartTimeRef.current = processingStartTime;
   }, [processingStartTime]);
-  import_react45.useEffect(() => {
+  import_react46.useEffect(() => {
     if (isProcessing && !processingStartTime) {
       const now2 = Date.now();
       setProcessingStartTime(now2);
       processingStartTimeRef.current = now2;
     }
   }, [isProcessing, processingStartTime]);
-  const buildFullResponse = import_react45.useCallback(() => {
+  const buildFullResponse = import_react46.useCallback(() => {
     const parts = activityLogRef.current.filter((entry) => entry.type === "text" && entry.content).map((entry) => entry.content);
     if (responseRef.current.trim()) {
       parts.push(responseRef.current);
@@ -184864,7 +186668,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     return parts.join(`
 `).trim();
   }, []);
-  const loadSessionMetadata = import_react45.useCallback(async (session) => {
+  const loadSessionMetadata = import_react46.useCallback(async (session) => {
     try {
       const [loadedSkills, loadedCommands] = await Promise.all([
         session.client.getSkills(),
@@ -184883,7 +186687,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       setError(err instanceof Error ? err.message : String(err));
     }
   }, []);
-  const finalizeResponse2 = import_react45.useCallback((status) => {
+  const finalizeResponse2 = import_react46.useCallback((status) => {
     const baseContent = buildFullResponse();
     const hasContent = baseContent.length > 0;
     const activityToolCalls = activityLogRef.current.filter((entry) => entry.type === "tool_call" && entry.toolCall).map((entry) => entry.toolCall);
@@ -184939,7 +186743,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     ]);
     return true;
   }, [buildFullResponse]);
-  const resetTurnState = import_react45.useCallback(() => {
+  const resetTurnState = import_react46.useCallback(() => {
     setCurrentResponse("");
     responseRef.current = "";
     toolCallsRef.current = [];
@@ -184950,7 +186754,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     setProcessingStartTime(undefined);
     setCurrentTurnTokens(0);
   }, []);
-  const saveCurrentSessionState = import_react45.useCallback(() => {
+  const saveCurrentSessionState = import_react46.useCallback(() => {
     if (activeSessionId) {
       sessionUIStates.current.set(activeSessionId, {
         messages: messages2,
@@ -184970,7 +186774,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       });
     }
   }, [activeSessionId, messages2, tokenUsage, energyState, voiceState, heartbeatState, identityInfo, processingStartTime, currentTurnTokens, error2, lastWorkedFor]);
-  const loadSessionState = import_react45.useCallback((sessionId) => {
+  const loadSessionState = import_react46.useCallback((sessionId) => {
     const state = sessionUIStates.current.get(sessionId);
     const askState = askUserStateRef.current.get(sessionId) || null;
     if (state) {
@@ -185013,7 +186817,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       setAskUserState(askState);
     }
   }, []);
-  const handleChunk = import_react45.useCallback((chunk) => {
+  const handleChunk = import_react46.useCallback((chunk) => {
     const isStartChunk = chunk.type === "text" || chunk.type === "tool_use";
     const isTerminalChunk = chunk.type === "error" || chunk.type === "done";
     if (!isProcessingRef.current && (isStartChunk || isTerminalChunk)) {
@@ -185158,6 +186962,11 @@ function App2({ cwd: cwd2, version: version3 }) {
             setShowTasksPanel(true);
           });
         });
+      } else if (chunk.panel === "schedules") {
+        listSchedules(cwd2).then((schedules) => {
+          setSchedulesList(schedules);
+          setShowSchedulesPanel(true);
+        });
       } else if (chunk.panel === "assistants") {
         setShowAssistantsPanel(true);
       } else if (chunk.panel === "hooks") {
@@ -185227,7 +187036,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       }
     }
   }, [registry3, exit, finalizeResponse2, resetTurnState, cwd2, activeSessionId]);
-  const loadConfigFiles = import_react45.useCallback(async () => {
+  const loadConfigFiles = import_react46.useCallback(async () => {
     try {
       const config = await loadConfig(cwd2);
       setCurrentConfig(config);
@@ -185260,7 +187069,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       console.error("Failed to load config:", err);
     }
   }, [cwd2]);
-  const createSessionFromRecovery = import_react45.useCallback(async (recoverSession) => {
+  const createSessionFromRecovery = import_react46.useCallback(async (recoverSession) => {
     if (!handlersRegisteredRef.current) {
       handlersRegisteredRef.current = true;
       registry3.onChunk(handleChunk);
@@ -185313,7 +187122,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     initStateRef.current = "done";
     setIsInitializing(false);
   }, [cwd2, registry3, handleChunk, finalizeResponse2, resetTurnState, loadSessionMetadata, beginAskUser]);
-  const handleRecover = import_react45.useCallback((session) => {
+  const handleRecover = import_react46.useCallback((session) => {
     setShowRecoveryPanel(false);
     for (const s6 of recoverableSessions) {
       if (s6.sessionId !== session.sessionId) {
@@ -185325,7 +187134,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       setIsInitializing(false);
     });
   }, [recoverableSessions, createSessionFromRecovery]);
-  const handleStartFresh = import_react45.useCallback(() => {
+  const handleStartFresh = import_react46.useCallback(() => {
     for (const session of recoverableSessions) {
       clearRecoveryState(session.sessionId);
     }
@@ -185336,7 +187145,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       setIsInitializing(false);
     });
   }, [recoverableSessions, createSessionFromRecovery]);
-  import_react45.useEffect(() => {
+  import_react46.useEffect(() => {
     if (initStateRef.current === "done")
       return;
     if (initStateRef.current === "pending")
@@ -185368,14 +187177,14 @@ function App2({ cwd: cwd2, version: version3 }) {
       cancelled = true;
     };
   }, [cwd2, registry3, showRecoveryPanel, recoverableSessions, createSessionFromRecovery]);
-  import_react45.useEffect(() => {
+  import_react46.useEffect(() => {
     isMountedRef.current = true;
     return () => {
       isMountedRef.current = false;
       registry3.closeAll();
     };
   }, [registry3]);
-  const processQueue = import_react45.useCallback(async () => {
+  const processQueue = import_react46.useCallback(async () => {
     const activeSession2 = registryRef.current.getActiveSession();
     if (!activeSession2 || !activeSessionId)
       return;
@@ -185435,7 +187244,7 @@ function App2({ cwd: cwd2, version: version3 }) {
   }, [activeSessionId, clearPendingSend]);
   const activeQueue = activeSessionId ? messageQueue.filter((msg) => msg.sessionId === activeSessionId) : [];
   const activeInline = activeSessionId ? inlinePending.filter((msg) => msg.sessionId === activeSessionId) : [];
-  const queuedMessageIds = import_react45.useMemo(() => new Set(activeQueue.filter((msg) => msg.mode === "queued").map((msg) => msg.id)), [activeQueue]);
+  const queuedMessageIds = import_react46.useMemo(() => new Set(activeQueue.filter((msg) => msg.mode === "queued").map((msg) => msg.id)), [activeQueue]);
   const sessions = registry3.listSessions();
   const activeSession = registry3.getActiveSession();
   const sessionIndex = activeSessionId ? registry3.getSessionIndex(activeSessionId) : 0;
@@ -185445,7 +187254,7 @@ function App2({ cwd: cwd2, version: version3 }) {
   const inlineCount = activeInline.length;
   const activeAskQuestion = askUserState && askUserState.sessionId === activeSessionId ? askUserState.request.questions[askUserState.index] : undefined;
   const askPlaceholder = activeAskQuestion?.placeholder || activeAskQuestion?.question || "Answer the question...";
-  const hasPendingTools = import_react45.useMemo(() => {
+  const hasPendingTools = import_react46.useMemo(() => {
     const toolResultIds = new Set;
     for (const entry of activityLog) {
       if (entry.type === "tool_result" && entry.toolResult) {
@@ -185465,10 +187274,10 @@ function App2({ cwd: cwd2, version: version3 }) {
   const showWelcome = messages2.length === 0 && !isProcessing;
   const renderWidth = columns ? Math.max(1, columns - 2) : undefined;
   const wrapChars = renderWidth ?? MESSAGE_WRAP_CHARS;
-  const displayMessages = import_react45.useMemo(() => buildDisplayMessages(messages2, MESSAGE_CHUNK_LINES, wrapChars, { maxWidth: renderWidth }), [messages2, wrapChars, renderWidth]);
+  const displayMessages = import_react46.useMemo(() => buildDisplayMessages(messages2, MESSAGE_CHUNK_LINES, wrapChars, { maxWidth: renderWidth }), [messages2, wrapChars, renderWidth]);
   const reservedLines = 12;
   const dynamicBudget = Math.max(6, rows - reservedLines);
-  const streamingTrim = import_react45.useMemo(() => {
+  const streamingTrim = import_react46.useMemo(() => {
     if (!isProcessing || !currentResponse.trim()) {
       return { messages: [], trimmed: false };
     }
@@ -185483,17 +187292,17 @@ function App2({ cwd: cwd2, version: version3 }) {
   }, [currentResponse, isProcessing, wrapChars, renderWidth, dynamicBudget]);
   const streamingMessages = streamingTrim.messages;
   const streamingTrimmed = streamingTrim.trimmed;
-  const streamingLineCount = import_react45.useMemo(() => estimateDisplayMessagesLines(streamingMessages, renderWidth), [streamingMessages, renderWidth]);
-  const activityTrim = import_react45.useMemo(() => {
+  const streamingLineCount = import_react46.useMemo(() => estimateDisplayMessagesLines(streamingMessages, renderWidth), [streamingMessages, renderWidth]);
+  const activityTrim = import_react46.useMemo(() => {
     const activityBudget = Math.max(4, dynamicBudget - streamingLineCount);
     return trimActivityLogByLines(activityLog, wrapChars, renderWidth, activityBudget);
   }, [activityLog, wrapChars, renderWidth, dynamicBudget, streamingLineCount]);
-  import_react45.useEffect(() => {
+  import_react46.useEffect(() => {
     if (!isBusy && activeQueue.length > 0 && activeInline.length === 0) {
       processQueue();
     }
   }, [isBusy, activeQueue.length, activeInline.length, processQueue, queueFlushTrigger]);
-  const handleSessionSwitch = import_react45.useCallback(async (sessionId) => {
+  const handleSessionSwitch = import_react46.useCallback(async (sessionId) => {
     setShowSessionSelector(false);
     if (sessionId === activeSessionId) {
       return;
@@ -185513,7 +187322,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     await registry3.switchSession(sessionId);
     setActiveSessionId(sessionId);
   }, [activeSessionId, registry3, saveCurrentSessionState, loadSessionState]);
-  const handleNewSession = import_react45.useCallback(async () => {
+  const handleNewSession = import_react46.useCallback(async () => {
     setShowSessionSelector(false);
     try {
       saveCurrentSessionState();
@@ -185598,7 +187407,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       }
     }
   }, { isActive: !showSessionSelector });
-  const handleSubmit = import_react45.useCallback(async (input, mode = "normal") => {
+  const handleSubmit = import_react46.useCallback(async (input, mode = "normal") => {
     if (activeSessionId && askUserStateRef.current.has(activeSessionId)) {
       submitAskAnswer(input.trim());
       return;
@@ -185791,19 +187600,19 @@ function App2({ cwd: cwd2, version: version3 }) {
     clearPendingSend
   ]);
   if (isInitializing && !showRecoveryPanel) {
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Spinner2, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Spinner2, {
         label: "Initializing..."
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
   if (showRecoveryPanel && recoverableSessions.length > 0) {
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(RecoveryPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(RecoveryPanel, {
         sessions: recoverableSessions,
         onRecover: handleRecover,
         onStartFresh: handleStartFresh
@@ -185811,10 +187620,10 @@ function App2({ cwd: cwd2, version: version3 }) {
     }, undefined, false, undefined, this);
   }
   if (showSessionSelector) {
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(SessionSelector, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(SessionSelector, {
         sessions,
         activeSessionId,
         onSelect: handleSessionSwitch,
@@ -185836,10 +187645,10 @@ function App2({ cwd: cwd2, version: version3 }) {
       }
       return connectorBridgeRef.current.getCommandHelp(connector, command);
     };
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(ConnectorsPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ConnectorsPanel, {
         connectors,
         initialConnector: connectorsPanelInitial,
         onCheckAuth: handleCheckAuth,
@@ -185888,10 +187697,10 @@ When done, report the result.`);
       await updateTask(cwd2, id, { priority });
       setTasksList(await getTasks(cwd2));
     };
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(TasksPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(TasksPanel, {
         tasks: tasksList,
         paused: tasksPaused,
         onAdd: handleTasksAdd,
@@ -185905,6 +187714,54 @@ When done, report the result.`);
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
+  if (showSchedulesPanel) {
+    const handleSchedulePause = async (id) => {
+      await updateSchedule(cwd2, id, (schedule) => ({
+        ...schedule,
+        status: "paused",
+        updatedAt: Date.now()
+      }));
+      setSchedulesList(await listSchedules(cwd2));
+    };
+    const handleScheduleResume = async (id) => {
+      await updateSchedule(cwd2, id, (schedule) => {
+        const nextRun = computeNextRun(schedule, Date.now());
+        return {
+          ...schedule,
+          status: "active",
+          updatedAt: Date.now(),
+          nextRunAt: nextRun
+        };
+      });
+      setSchedulesList(await listSchedules(cwd2));
+    };
+    const handleScheduleDelete = async (id) => {
+      await deleteSchedule(cwd2, id);
+      setSchedulesList(await listSchedules(cwd2));
+    };
+    const handleScheduleRun = async (id) => {
+      const schedule = schedulesList.find((s6) => s6.id === id);
+      if (schedule && activeSession) {
+        await activeSession.client.send(schedule.command);
+      }
+    };
+    const handleScheduleRefresh = async () => {
+      setSchedulesList(await listSchedules(cwd2));
+    };
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
+      flexDirection: "column",
+      padding: 1,
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(SchedulesPanel, {
+        schedules: schedulesList,
+        onPause: handleSchedulePause,
+        onResume: handleScheduleResume,
+        onDelete: handleScheduleDelete,
+        onRun: handleScheduleRun,
+        onRefresh: handleScheduleRefresh,
+        onClose: () => setShowSchedulesPanel(false)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
   if (showAssistantsPanel) {
     const assistantManager = activeSession?.client.getAssistantManager?.();
     const assistantsList = assistantManager?.listAssistants() ?? [];
@@ -185965,10 +187822,10 @@ When done, report the result.`);
         throw err;
       }
     };
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(AssistantsPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(AssistantsPanel, {
         assistants: assistantsList,
         activeAssistantId,
         onSelect: handleAssistantSelect,
@@ -186013,10 +187870,10 @@ When done, report the result.`);
       nativeHookRegistry.setEnabled(hookId, enabled);
     };
     const nativeHooks = nativeHookRegistry.listFlat();
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(HooksPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(HooksPanel, {
         hooks: hooksConfig,
         nativeHooks,
         onToggle: handleHookToggle,
@@ -186060,10 +187917,10 @@ When done, report the result.`);
       setGuardrailsConfig(config);
       setGuardrailsPolicies(policies);
     };
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(GuardrailsPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(GuardrailsPanel, {
         config: guardrailsConfig,
         policies: guardrailsPolicies,
         onToggleEnabled: handleToggleEnabled,
@@ -186112,10 +187969,10 @@ When done, report the result.`);
       setSessionBudgetStatus(sessionStatus);
       setSwarmBudgetStatus(swarmStatus);
     };
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(BudgetPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(BudgetPanel, {
         config: budgetConfig,
         sessionStatus: sessionBudgetStatus,
         swarmStatus: swarmBudgetStatus,
@@ -186134,10 +187991,10 @@ When done, report the result.`);
       setAgentsList(agents);
       setRegistryStats(stats);
     };
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(AgentsPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(AgentsPanel, {
         agents: agentsList,
         stats: registryStats,
         onRefresh: handleAgentsRefresh,
@@ -186170,10 +188027,10 @@ When done, report the result.`);
       await writeFile13(configPath, JSON.stringify(newConfig, null, 2));
       await loadConfigFiles();
     };
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(ConfigPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ConfigPanel, {
         config: currentConfig,
         userConfig,
         projectConfig,
@@ -186258,37 +188115,37 @@ ${msg.body || msg.preview}`);
       });
     };
     if (!messagesManager) {
-      return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+      return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
         flexDirection: "column",
         padding: 1,
         children: [
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
             marginBottom: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
               bold: true,
               color: "cyan",
               children: "Messages"
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
             flexDirection: "column",
             borderStyle: "round",
             borderColor: "gray",
             paddingX: 1,
             paddingY: 1,
             children: [
-              /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+              /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
                 children: "Messages are not enabled."
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+              /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
                 dimColor: true,
                 children: "Configure messages in config.json to enable."
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
             marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
               dimColor: true,
               children: "q quit"
             }, undefined, false, undefined, this)
@@ -186296,10 +188153,10 @@ ${msg.body || msg.preview}`);
         ]
       }, undefined, true, undefined, this);
     }
-    return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(MessagesPanel, {
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(MessagesPanel, {
         messages: messagesList,
         onRead: handleMessagesRead,
         onDelete: handleMessagesDelete,
@@ -186315,18 +188172,18 @@ ${msg.body || msg.preview}`);
     return { toolCall: e6.toolCall, result };
   });
   const isThinking = isProcessing && !currentResponse && !currentToolCall && toolCallEntries.length === 0;
-  return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
     flexDirection: "column",
     padding: 1,
     children: [
-      showWelcome && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(WelcomeBanner, {
+      showWelcome && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(WelcomeBanner, {
         version: version3 ?? "unknown",
         model: activeSession?.client.getModel() ?? "unknown",
         directory: activeSession?.cwd || cwd2
       }, undefined, false, undefined, this),
-      backgroundProcessingCount > 0 && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+      backgroundProcessingCount > 0 && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
         marginBottom: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+        children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
           color: "yellow",
           children: [
             backgroundProcessingCount,
@@ -186336,9 +188193,9 @@ ${msg.body || msg.preview}`);
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Static, {
+      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Static, {
         items: displayMessages,
-        children: (message) => /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Messages5, {
+        children: (message) => /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Messages5, {
           messages: [message],
           currentResponse: undefined,
           streamingMessages: [],
@@ -186349,23 +188206,23 @@ ${msg.body || msg.preview}`);
           verboseTools
         }, message.id, false, undefined, this)
       }, undefined, false, undefined, this),
-      isProcessing && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(jsx_dev_runtime23.Fragment, {
+      isProcessing && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(jsx_dev_runtime24.Fragment, {
         children: [
-          streamingTrimmed && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          streamingTrimmed && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
             marginBottom: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
               dimColor: true,
               children: "\u22EF showing latest output"
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          activityTrim.trimmed && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+          activityTrim.trimmed && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
             marginBottom: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+            children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
               dimColor: true,
               children: "\u22EF showing latest activity"
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Messages5, {
+          /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Messages5, {
             messages: [],
             currentResponse: undefined,
             streamingMessages,
@@ -186377,31 +188234,31 @@ ${msg.body || msg.preview}`);
           }, "streaming", false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(QueueIndicator, {
+      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(QueueIndicator, {
         messages: [...activeInline, ...activeQueue],
         maxPreview: MAX_QUEUED_PREVIEW
       }, undefined, false, undefined, this),
-      askUserState && activeAskQuestion && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(AskUserPanel, {
+      askUserState && activeAskQuestion && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(AskUserPanel, {
         sessionId: askUserState.sessionId,
         request: askUserState.request,
         question: activeAskQuestion,
         index: askUserState.index,
         total: askUserState.request.questions.length
       }, undefined, false, undefined, this),
-      error2 && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(ErrorBanner, {
+      error2 && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ErrorBanner, {
         error: error2,
         showErrorCodes: SHOW_ERROR_CODES
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(ProcessingIndicator, {
+      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ProcessingIndicator, {
         isProcessing,
         startTime: processingStartTime,
         tokenCount: currentTurnTokens,
         isThinking
       }, undefined, false, undefined, this),
-      !isProcessing && lastWorkedFor && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+      !isProcessing && lastWorkedFor && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
         marginBottom: 0,
         marginLeft: 2,
-        children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+        children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
           color: "gray",
           children: [
             "\u273B Worked for ",
@@ -186409,15 +188266,15 @@ ${msg.body || msg.preview}`);
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      showExitHint && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+      showExitHint && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
         marginLeft: 2,
         marginBottom: 0,
-        children: /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text3, {
+        children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text3, {
           color: "yellow",
           children: "(Press Ctrl+C again to exit)"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Input, {
+      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Input, {
         onSubmit: handleSubmit,
         isProcessing: isBusy,
         queueLength: activeQueue.length + inlineCount,
@@ -186427,7 +188284,7 @@ ${msg.body || msg.preview}`);
         askPlaceholder,
         allowBlankAnswer: activeAskQuestion?.required === false
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Status, {
+      /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Status, {
         isProcessing: isBusy,
         cwd: activeSession?.cwd || cwd2,
         queueLength: activeQueue.length + inlineCount,
@@ -186868,9 +188725,9 @@ Interactive Mode:
 }
 
 // packages/terminal/src/index.tsx
-var jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime25 = __toESM(require_jsx_dev_runtime(), 1);
 setRuntime(bunRuntime);
-var VERSION4 = "0.6.61";
+var VERSION4 = "0.6.62";
 var SYNC_START = "\x1B[?2026h";
 var SYNC_END = "\x1B[?2026l";
 function enableSynchronizedOutput() {
@@ -186993,7 +188850,7 @@ if (options.print !== null) {
 } else {
   const useSyncOutput = process.env.ASSISTANTS_NO_SYNC !== "1";
   const disableSyncOutput = useSyncOutput ? enableSynchronizedOutput() : () => {};
-  const { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime24.jsxDEV(App2, {
+  const { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime25.jsxDEV(App2, {
     cwd: options.cwd,
     version: VERSION4
   }, undefined, false, undefined, this), {
@@ -187010,4 +188867,4 @@ export {
   main
 };
 
-//# debugId=BCC7A4D6FC1A376064756E2164756E21
+//# debugId=A9B10BFA70C2B51164756E2164756E21