@supatest/cli 0.0.39 → 0.0.41

package/dist/index.js

@@ -233,7 +233,7 @@ You are the Supatest CLI Help Assistant. You help users understand and use the S
 - MCP (Model Context Protocol) server management
 - npm package information and npm link setup
 
-You provide clear, friendly, and accurate answers based on the comprehensive CLI documentation below. You can maintain conversation context across multiple messages, answer follow-up questions, and guide users toward the right features for their needs.
+You provide clear, friendly, and accurate answers based on the comprehensive CLI documentation below. You can maintain session context across multiple messages, answer follow-up questions, and guide users toward the right features for their needs.
 </role>
 
 <capabilities>
@@ -358,7 +358,7 @@ These work in interactive mode:
 - **ESC or Q** - Close overlays (help, menus, dialogs)
 
 ### Navigation
-- **Ctrl+M** - Cycle through available models
+- **Ctrl+Shift+M** - Cycle through available models
 - **Ctrl+P** - Cycle through LLM providers
 
 ### Input & Text Editing
@@ -585,7 +585,7 @@ Just ask: "Can you check the npm docs?" or "What's the latest version?"
 - The agent will handle framework-specific syntax
 
 ### Session Persistence
-- Your conversations are saved and can be resumed
+- Your sessions are saved and can be resumed
 - Use /resume to continue work from where you left off
 - Useful for long-running projects
 
@@ -596,7 +596,7 @@ Just ask: "Can you check the npm docs?" or "What's the latest version?"
 
 </cli-documentation>
 
-<conversation-guidelines>
+<session-guidelines>
 When answering questions:
 
 1. **Be direct**: Answer the question asked first, then offer related information
@@ -614,7 +614,7 @@ When users mix help with actual test building:
 - Answer their help question
 - Then ask if they want to start building tests or need more information
 
-</conversation-guidelines>
+</session-guidelines>
 
 <action-guide>
 ## How to Help Users with Actions
@@ -1155,7 +1155,7 @@ function getToolGroupCounts(tools) {
   );
   return Object.entries(groups).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count);
 }
-var AVAILABLE_MODELS, DATE_SUFFIX_REGEX, SMALL_COST_MULTIPLIER, MEDIUM_COST_MULTIPLIER, PREMIUM_COST_MULTIPLIER, SMALL_COST_LABEL, MEDIUM_COST_LABEL, PREMIUM_COST_LABEL, MODEL_TIERS, CONTEXT_WINDOWS, util, objectUtil, ZodParsedType, getParsedType, ZodIssueCode, ZodError, errorMap, overrideErrorMap, makeIssue, ParseStatus, INVALID, DIRTY, OK, isAborted, isDirty, isValid, isAsync, errorUtil, ParseInputLazyPath, handleResult, ZodType, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource, dateRegex, ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodArray, ZodObject, ZodUnion, getDiscriminator, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, ZodBranded, ZodPipeline, ZodReadonly, ZodFirstPartyTypeKind, stringType, numberType, booleanType, dateType, unknownType, arrayType, objectType, unionType, discriminatedUnionType, recordType, functionType, lazyType, literalType, enumType, promiseType, coerce, MAX_API_KEY_NAME_LENGTH, apiKeySchema, apiKeyUsageSchema, createApiKeyRequestSchema, apiKeyResponseSchema, apiKeyUsageSummarySchema, genericErrorSchema, validationErrorSchema, feedbackCategorySchema, FEEDBACK_CATEGORIES, createFeedbackSchema, feedbackResponseSchema, listFeedbackQuerySchema, feedbackListResponseSchema, healthMetricSchema, healthMetricDailyItemSchema, healthMetricsWithDailySchema, healthAnalyticsPeriodSchema, healthAnalyticsDailyItemSchema, healthAnalyticsResponseSchema, MAX_TIMEZONE_CHAR_LENGTH, organizationSchema, organizationSettingsSchema, textBlockSchema, toolUseBlockSchema, toolResultBlockSchema, thinkingBlockSchema, imageBlockSchema, contentBlockSchema, sessionSchema, createSessionRequestSchema, updateSessionRequestSchema, messageSchema, createMessageRequestSchema, cliEventSchema, createCLISessionRequestSchema, queryResultSchema, queryTurnSchema, queryContentSchema, queryUsageSchema, querySchema, runStatusSchema, testResultStatusSchema, testOutcomeSchema, attachmentKindSchema, stepCategorySchema, runSummarySchema, ciMetadataSchema, gitMetadataSchema, playwrightConfigSchema, errorInfoSchema, locationSchema, sourceSnippetSchema, runSchema, annotationSchema, testSchema, testResultSchema, baseStepSchema, stepSchema, attachmentSchema, listRunsQuerySchema, listTestsQuerySchema, runsListResponseSchema, runDetailResponseSchema, testsListResponseSchema, testDetailResponseSchema, testHistoryItemSchema, testHistoryResponseSchema, topOffenderSchema, topOffendersResponseSchema, trendPointSchema, trendsResponseSchema, errorCategorySchema, failureClusterSchema, newFailureSchema, runInsightsResponseSchema, FailureCategoryEnum, SelectorTypeEnum, FailureCategoryStatsSchema, FailureCategoriesResponseSchema, FailingSelectorStatsSchema, FailingSelectorsResponseSchema, newFailureItemSchema, newFailuresResponseSchema, flakyTestItemSchema, flakyTestsResponseSchema, slowestTestItemSchema, slowestTestsResponseSchema;
+var AVAILABLE_MODELS, DATE_SUFFIX_REGEX, SMALL_COST_MULTIPLIER, MEDIUM_COST_MULTIPLIER, PREMIUM_COST_MULTIPLIER, SMALL_COST_LABEL, MEDIUM_COST_LABEL, PREMIUM_COST_LABEL, MODEL_TIERS, CONTEXT_WINDOWS, util, objectUtil, ZodParsedType, getParsedType, ZodIssueCode, ZodError, errorMap, overrideErrorMap, makeIssue, ParseStatus, INVALID, DIRTY, OK, isAborted, isDirty, isValid, isAsync, errorUtil, ParseInputLazyPath, handleResult, ZodType, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource, dateRegex, ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodArray, ZodObject, ZodUnion, getDiscriminator, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, ZodBranded, ZodPipeline, ZodReadonly, ZodFirstPartyTypeKind, stringType, numberType, booleanType, dateType, unknownType, arrayType, objectType, unionType, discriminatedUnionType, recordType, functionType, lazyType, literalType, enumType, promiseType, coerce, MAX_API_KEY_NAME_LENGTH, apiKeySchema, apiKeyUsageSchema, createApiKeyRequestSchema, apiKeyResponseSchema, apiKeyUsageSummarySchema, genericErrorSchema, validationErrorSchema, feedbackCategorySchema, FEEDBACK_CATEGORIES, createFeedbackSchema, feedbackResponseSchema, listFeedbackQuerySchema, feedbackListResponseSchema, healthMetricSchema, healthMetricDailyItemSchema, healthMetricsWithDailySchema, healthAnalyticsPeriodSchema, healthAnalyticsDailyItemSchema, healthAnalyticsResponseSchema, MAX_TIMEZONE_CHAR_LENGTH, organizationSchema, organizationSettingsSchema, textBlockSchema, toolUseBlockSchema, toolResultBlockSchema, thinkingBlockSchema, imageBlockSchema, contentBlockSchema, sessionSchema, createSessionRequestSchema, updateSessionRequestSchema, messageSchema, createMessageRequestSchema, cliEventSchema, createCLISessionRequestSchema, queryResultSchema, queryTurnSchema, queryContentSchema, queryUsageSchema, querySchema, runStatusSchema, testResultStatusSchema, testOutcomeSchema, attachmentKindSchema, stepCategorySchema, runSummarySchema, ciMetadataSchema, gitMetadataSchema, playwrightConfigSchema, errorInfoSchema, locationSchema, sourceSnippetSchema, runSchema, annotationSchema, testSchema, testResultSchema, baseStepSchema, stepSchema, attachmentSchema, listRunsQuerySchema, listTestsQuerySchema, runsListResponseSchema, runDetailResponseSchema, testsListResponseSchema, testDetailResponseSchema, testHistoryItemSchema, testHistoryResponseSchema, topOffenderSchema, topOffendersResponseSchema, trendPointSchema, trendsResponseSchema, errorCategorySchema, failureClusterSchema, newFailureSchema, runInsightsResponseSchema, FailureCategoryEnum, SelectorTypeEnum, FailureCategoryStatsSchema, FailureCategoriesResponseSchema, FailingSelectorStatsSchema, FailingSelectorsResponseSchema, newFailureItemSchema, newFailuresResponseSchema, flakyTestItemSchema, flakyTestsResponseSchema, slowestTestItemSchema, slowestTestsResponseSchema, runSummaryEmailFailureSchema, runSummaryEmailReportSchema, sendRunReportRequestSchema, metricWithTrendSchema, weekOverWeekMetricsSchema, ciComputeTimeSchema, investigationCandidateSchema, failureCategoryBreakdownSchema, stabilityTrendSchema, folderStabilitySchema, managerReportSchema, managerReportQuerySchema, sendManagerReportRequestSchema, reportAttachmentLinkSchema, developerReportRegressionSchema, developerReportFlakyTestSchema, developerReportSlowTestSchema, developerRunSummaryReportSchema, executiveReportStatusSchema, executiveMetricSchema, executiveKeyMetricsSchema, executiveTrendPointSchema, executiveTrendsSchema, executiveFlakyOffenderSchema, executiveSlowestOffenderSchema, executiveTopOffendersSchema, executiveReportSchema, executiveReportQuerySchema, sendExecutiveReportRequestSchema, fixAssignmentStatusSchema, fixAssignmentSchema, testWithAssignmentSchema, listAssignmentsQuerySchema, listTestsWithAssignmentsQuerySchema, assignmentsListResponseSchema, assigneeInfoSchema, assigneesListResponseSchema, assignTestsRequestSchema, assignTestRequestSchema, reassignTestRequestSchema, completeAssignmentsRequestSchema, completeAssignmentRequestSchema, bulkReassignRequestSchema, assignmentResponseSchema, assignTestsResponseSchema, testsWithAssignmentsResponseSchema, bulkReassignResponseSchema, userAssignmentStatsSchema, SECONDS_PER_MINUTE, SECONDS_PER_HOUR, SECONDS_PER_DAY, SECONDS_PER_WEEK, SECONDS_PER_MONTH, SECONDS_PER_YEAR;
 var init_shared_es = __esm({
   "../shared/dist/shared.es.mjs"() {
     "use strict";
@@ -5103,7 +5103,7 @@ var init_shared_es = __esm({
       originMetadata: recordType(unknownType()).nullable().optional(),
       authMethod: enumType(["clerk", "cli-token", "api-key"]).default("clerk"),
       authId: stringType().nullable().optional(),
-      // Claude Agent SDK session ID for resuming conversations
+      // Claude Agent SDK session ID for resuming sessions
       // Sessions expire after ~30 days due to Anthropic's data retention policy
       providerSessionId: stringType().nullable().optional(),
       createdAt: dateType(),
@@ -5120,7 +5120,7 @@ var init_shared_es = __esm({
     });
     messageSchema = objectType({
       id: stringType().uuid(),
-      conversationId: stringType().uuid(),
+      sessionId: stringType().uuid(),
       role: enumType(["user", "assistant"]),
       content: arrayType(contentBlockSchema),
       createdAt: dateType()
@@ -5414,6 +5414,7 @@ var init_shared_es = __esm({
       limit: coerce.number().min(1).max(100).default(20),
       status: runStatusSchema.optional(),
       branch: stringType().optional(),
+      search: stringType().optional(),
       startDate: stringType().optional(),
       endDate: stringType().optional()
     });
@@ -5503,6 +5504,7 @@ var init_shared_es = __esm({
       "assertion",
       "element_not_found",
       "server_error",
+      "navigation",
       "other"
     ]);
     failureClusterSchema = objectType({
@@ -5524,14 +5526,7 @@ var init_shared_es = __esm({
       newFailures: arrayType(newFailureSchema),
       clusters: arrayType(failureClusterSchema)
     });
-    FailureCategoryEnum = enumType([
-      "timeout",
-      "element_not_found",
-      "assertion",
-      "network",
-      "navigation",
-      "other"
-    ]);
+    FailureCategoryEnum = errorCategorySchema;
     SelectorTypeEnum = enumType([
       "testid",
       "class",
@@ -5629,12 +5624,1021 @@ var init_shared_es = __esm({
         days: numberType()
       })
     });
+    runSummaryEmailFailureSchema = objectType({
+      testRunId: stringType(),
+      testId: stringType(),
+      title: stringType(),
+      file: stringType(),
+      errorMessage: stringType().nullable(),
+      errorStack: stringType().nullable()
+    });
+    runSummaryEmailReportSchema = objectType({
+      runId: stringType(),
+      readableId: stringType().optional(),
+      runDetailsUrl: stringType(),
+      startedAt: stringType(),
+      endedAt: stringType().optional(),
+      durationMs: numberType(),
+      branch: stringType().optional(),
+      commit: stringType().optional(),
+      commitMessage: stringType().optional(),
+      totalTests: numberType(),
+      passedTests: numberType(),
+      failedTests: numberType(),
+      flakyTests: numberType(),
+      skippedTests: numberType(),
+      passRate: numberType(),
+      topFailures: arrayType(runSummaryEmailFailureSchema)
+    });
+    sendRunReportRequestSchema = objectType({
+      runId: stringType(),
+      emails: arrayType(stringType().email())
+    });
+    metricWithTrendSchema = objectType({
+      current: numberType(),
+      previous: numberType(),
+      change: numberType(),
+      percentChange: numberType().nullable()
+    });
+    weekOverWeekMetricsSchema = objectType({
+      passRate: metricWithTrendSchema,
+      flakyTestCount: metricWithTrendSchema,
+      newFailures: metricWithTrendSchema,
+      totalRuns: metricWithTrendSchema
+    });
+    ciComputeTimeSchema = objectType({
+      failedRunsMs: numberType(),
+      retriedRunsMs: numberType(),
+      totalWastedMs: numberType(),
+      failedRunsHours: numberType(),
+      retriedRunsHours: numberType(),
+      totalWastedHours: numberType()
+    });
+    investigationCandidateSchema = objectType({
+      testId: stringType(),
+      testRunId: stringType(),
+      runId: stringType(),
+      file: stringType(),
+      title: stringType(),
+      flakeCount: numberType(),
+      passRate: numberType(),
+      avgDurationMs: numberType(),
+      ciTimeImpactMs: numberType(),
+      ciTimeImpactHours: numberType(),
+      category: FailureCategoryEnum.nullable(),
+      firstFlakyAt: stringType().nullable()
+    });
+    failureCategoryBreakdownSchema = objectType({
+      category: FailureCategoryEnum,
+      count: numberType(),
+      percentage: numberType()
+    });
+    stabilityTrendSchema = enumType([
+      "improving",
+      "degrading",
+      "stable"
+    ]);
+    folderStabilitySchema = objectType({
+      folder: stringType(),
+      passRate: numberType(),
+      previousPassRate: numberType(),
+      trend: stabilityTrendSchema,
+      testCount: numberType(),
+      failureCount: numberType()
+    });
+    managerReportSchema = objectType({
+      period: objectType({
+        start: stringType(),
+        end: stringType(),
+        days: numberType()
+      }),
+      weekOverWeek: weekOverWeekMetricsSchema,
+      ciComputeTime: ciComputeTimeSchema,
+      investigationCandidates: arrayType(investigationCandidateSchema),
+      failureCategories: arrayType(failureCategoryBreakdownSchema),
+      folderStability: arrayType(folderStabilitySchema)
+    });
+    managerReportQuerySchema = objectType({
+      startDate: stringType().regex(
+        /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?)?$/,
+        "startDate must be in format YYYY-MM-DD or ISO datetime"
+      ),
+      endDate: stringType().regex(
+        /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?)?$/,
+        "endDate must be in format YYYY-MM-DD or ISO datetime"
+      )
+    });
+    sendManagerReportRequestSchema = objectType({
+      startDate: stringType(),
+      endDate: stringType(),
+      emails: arrayType(stringType().email())
+    });
+    reportAttachmentLinkSchema = objectType({
+      name: stringType(),
+      kind: attachmentKindSchema,
+      url: stringType().optional()
+    });
+    developerReportRegressionSchema = objectType({
+      testRunId: stringType(),
+      testId: stringType(),
+      title: stringType(),
+      file: stringType(),
+      errorMessage: stringType().nullable(),
+      errorStack: stringType().nullable(),
+      aiSummary: stringType().nullable(),
+      attachments: arrayType(reportAttachmentLinkSchema),
+      lastStableRun: objectType({
+        runId: stringType(),
+        date: stringType(),
+        branch: stringType().optional()
+      }).nullable()
+    });
+    developerReportFlakyTestSchema = objectType({
+      testRunId: stringType(),
+      testId: stringType(),
+      title: stringType(),
+      file: stringType(),
+      passRate: numberType(),
+      category: errorCategorySchema.nullable(),
+      lastPassedRun: objectType({
+        runId: stringType(),
+        date: stringType()
+      }).nullable()
+    });
+    developerReportSlowTestSchema = objectType({
+      testRunId: stringType(),
+      testId: stringType(),
+      title: stringType(),
+      file: stringType(),
+      durationMs: numberType(),
+      historicalAvgMs: numberType(),
+      slowdownFactor: numberType()
+      // how many times slower than average
+    });
+    developerRunSummaryReportSchema = objectType({
+      runId: stringType(),
+      readableId: stringType().optional(),
+      runDetailsUrl: stringType(),
+      startedAt: stringType(),
+      endedAt: stringType().optional(),
+      durationMs: numberType(),
+      branch: stringType().optional(),
+      commit: stringType().optional(),
+      commitMessage: stringType().optional(),
+      // Summary counts
+      totalTests: numberType(),
+      passedTests: numberType(),
+      failedTests: numberType(),
+      flakyTests: numberType(),
+      skippedTests: numberType(),
+      passRate: numberType(),
+      // Sections
+      newRegressions: arrayType(developerReportRegressionSchema),
+      knownFlaky: arrayType(developerReportFlakyTestSchema),
+      slowTests: arrayType(developerReportSlowTestSchema)
+    });
+    executiveReportStatusSchema = enumType([
+      "healthy",
+      "needs_attention",
+      "critical"
+    ]);
+    executiveMetricSchema = objectType({
+      /** Current month's value */
+      value: numberType(),
+      /** Previous month's value */
+      previousValue: numberType(),
+      /** Percentage change from previous month (null if previous was 0) */
+      change: numberType().nullable()
+    });
+    executiveKeyMetricsSchema = objectType({
+      /** CI First-Try Pass Rate: COUNT(runs WHERE failed=0 AND flaky=0) / COUNT(runs) */
+      ciFirstTryPassRate: executiveMetricSchema,
+      /** Total Test Pass Rate from health analytics */
+      testPassRate: executiveMetricSchema,
+      /** Count of distinct tests with flaky outcomes */
+      flakyTestCount: executiveMetricSchema,
+      /** CI compute time lost on failed/retried runs in hours */
+      ciComputeLostHours: executiveMetricSchema
+    });
+    executiveTrendPointSchema = objectType({
+      date: stringType(),
+      value: numberType()
+    });
+    executiveTrendsSchema = objectType({
+      /** Daily pass rate values for sparkline */
+      dailyPassRate: arrayType(executiveTrendPointSchema),
+      /** Daily flaky count values for sparkline */
+      dailyFlakyCount: arrayType(executiveTrendPointSchema)
+    });
+    executiveFlakyOffenderSchema = objectType({
+      testId: stringType(),
+      title: stringType(),
+      file: stringType(),
+      /** Number of flaky occurrences */
+      flakyCount: numberType(),
+      /** CI time impact in hours */
+      ciTimeImpactHours: numberType()
+    });
+    executiveSlowestOffenderSchema = objectType({
+      testId: stringType(),
+      title: stringType(),
+      file: stringType(),
+      /** Average duration in milliseconds */
+      avgDurationMs: numberType(),
+      /** Trend percentage change from previous period (null if no previous data) */
+      trend: numberType().nullable()
+    });
+    executiveTopOffendersSchema = objectType({
+      /** Top 3 most flaky tests with CI time impact */
+      mostFlaky: arrayType(executiveFlakyOffenderSchema),
+      /** Top 3 slowest tests with trend */
+      slowest: arrayType(executiveSlowestOffenderSchema)
+    });
+    executiveReportSchema = objectType({
+      /** Month in format YYYY-MM */
+      month: stringType(),
+      /** When the report was generated */
+      generatedAt: stringType(),
+      /** URL to view full report in dashboard */
+      reportUrl: stringType(),
+      /** Overall status: healthy, needs_attention, or critical */
+      status: executiveReportStatusSchema,
+      /** 4 key metrics with month-over-month comparison */
+      keyMetrics: executiveKeyMetricsSchema,
+      /** 30-day trend data for sparklines */
+      trends: executiveTrendsSchema,
+      /** Top offenders (most flaky and slowest tests) */
+      topOffenders: executiveTopOffendersSchema,
+      /** Auto-generated signal messages based on thresholds */
+      signals: arrayType(stringType())
+    });
+    executiveReportQuerySchema = objectType({
+      month: stringType().regex(/^\d{4}-\d{2}$/, "month must be in format YYYY-MM")
+    });
+    sendExecutiveReportRequestSchema = objectType({
+      month: stringType().regex(/^\d{4}-\d{2}$/, "month must be in format YYYY-MM"),
+      emails: arrayType(stringType().email())
+    });
+    fixAssignmentStatusSchema = enumType([
+      "assigned",
+      // Currently being worked on
+      "completed",
+      // Successfully fixed
+      "failed"
+      // Fix attempt failed
+    ]);
+    fixAssignmentSchema = objectType({
+      id: stringType(),
+      testRunId: stringType(),
+      // Reference to test_run table
+      assignedTo: stringType().optional(),
+      // User ID (Clerk user ID)
+      assignedAt: stringType().optional(),
+      // ISO timestamp
+      status: fixAssignmentStatusSchema.optional(),
+      completedAt: stringType().optional(),
+      reason: stringType().optional(),
+      createdAt: stringType(),
+      updatedAt: stringType()
+    });
+    testWithAssignmentSchema = objectType({
+      // Core test fields from Test schema
+      id: stringType(),
+      readableId: stringType().optional(),
+      runId: stringType(),
+      file: stringType(),
+      title: stringType(),
+      location: objectType({
+        file: stringType(),
+        line: numberType(),
+        column: numberType().optional()
+      }).optional(),
+      status: enumType(["passed", "failed", "timedOut", "skipped", "interrupted"]),
+      durationMs: numberType(),
+      retryCount: numberType(),
+      isFlaky: booleanType().optional(),
+      // Assignment fields
+      assignmentId: stringType().optional(),
+      assignedTo: stringType().optional(),
+      assignedAt: stringType().optional(),
+      assignmentStatus: fixAssignmentStatusSchema.optional(),
+      assignmentCompletedAt: stringType().optional(),
+      assignmentReason: stringType().optional()
+    });
+    listAssignmentsQuerySchema = objectType({
+      runId: stringType().optional(),
+      assignedTo: stringType().optional(),
+      status: fixAssignmentStatusSchema.optional(),
+      file: stringType().optional(),
+      search: stringType().optional(),
+      page: coerce.number().min(1).default(1),
+      limit: coerce.number().min(1).max(100).default(50)
+    });
+    listTestsWithAssignmentsQuerySchema = objectType({
+      assignedTo: stringType().optional(),
+      status: fixAssignmentStatusSchema.optional(),
+      testStatus: enumType(["passed", "failed", "timedOut", "skipped", "interrupted"]).optional(),
+      file: stringType().optional(),
+      search: stringType().optional(),
+      page: coerce.number().min(1).default(1),
+      limit: coerce.number().min(1).max(100).default(50)
+    });
+    assignmentsListResponseSchema = objectType({
+      assignments: arrayType(testWithAssignmentSchema),
+      total: numberType(),
+      page: numberType(),
+      limit: numberType(),
+      // Summary stats
+      stats: objectType({
+        total: numberType(),
+        assigned: numberType(),
+        completed: numberType(),
+        failed: numberType(),
+        free: numberType()
+      })
+    });
+    assigneeInfoSchema = objectType({
+      id: stringType(),
+      name: stringType(),
+      email: stringType().optional(),
+      activeTests: numberType().default(0)
+      // Number of tests currently assigned
+    });
+    assigneesListResponseSchema = objectType({
+      assignees: arrayType(assigneeInfoSchema)
+    });
+    assignTestsRequestSchema = objectType({
+      testRunIds: arrayType(stringType()).min(1),
+      assignedTo: stringType().min(1),
+      notes: stringType().optional()
+    });
+    assignTestRequestSchema = objectType({
+      testRunId: stringType(),
+      assignedTo: stringType(),
+      reason: stringType().optional()
+    });
+    reassignTestRequestSchema = objectType({
+      assignedTo: stringType().min(1),
+      notes: stringType().optional()
+    });
+    completeAssignmentsRequestSchema = objectType({
+      assignmentIds: arrayType(stringType()).min(1),
+      status: fixAssignmentStatusSchema,
+      notes: stringType().optional(),
+      fixSessionId: stringType().optional()
+    });
+    completeAssignmentRequestSchema = objectType({
+      assignmentId: stringType(),
+      success: booleanType()
+    });
+    bulkReassignRequestSchema = objectType({
+      fromUser: stringType().min(1),
+      toUser: stringType().min(1),
+      status: fixAssignmentStatusSchema.optional(),
+      notes: stringType().optional()
+    });
+    assignmentResponseSchema = objectType({
+      assignment: fixAssignmentSchema
+    });
+    assignTestsResponseSchema = objectType({
+      assigned: arrayType(
+        objectType({
+          id: stringType(),
+          testRunId: stringType()
+        })
+      ),
+      conflicts: arrayType(
+        objectType({
+          testRunId: stringType(),
+          file: stringType(),
+          title: stringType(),
+          currentAssignee: stringType()
+        })
+      )
+    });
+    testsWithAssignmentsResponseSchema = objectType({
+      tests: arrayType(testWithAssignmentSchema),
+      total: numberType(),
+      page: numberType(),
+      limit: numberType(),
+      stats: objectType({
+        total: numberType(),
+        assigned: numberType(),
+        completed: numberType(),
+        failed: numberType(),
+        free: numberType()
+      })
+    });
+    bulkReassignResponseSchema = objectType({
+      reassigned: numberType(),
+      conflicts: arrayType(
+        objectType({
+          testRunId: stringType(),
+          file: stringType(),
+          title: stringType(),
+          reason: stringType()
+        })
+      )
+    });
+    userAssignmentStatsSchema = objectType({
+      assigned: numberType(),
+      completed: numberType(),
+      failed: numberType()
+    });
+    SECONDS_PER_MINUTE = 60;
+    SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;
+    SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;
+    SECONDS_PER_WEEK = 7 * SECONDS_PER_DAY;
+    SECONDS_PER_MONTH = 30 * SECONDS_PER_DAY;
+    SECONDS_PER_YEAR = 365 * SECONDS_PER_DAY;
+  }
+});
+
+// src/utils/claude-oauth.ts
+var claude_oauth_exports = {};
+__export(claude_oauth_exports, {
+  ClaudeOAuthService: () => ClaudeOAuthService
+});
+import { spawn } from "child_process";
+import { createHash, randomBytes } from "crypto";
+import http from "http";
+import { platform } from "os";
+var OAUTH_CONFIG, CALLBACK_PORT, CALLBACK_TIMEOUT_MS, ClaudeOAuthService;
+var init_claude_oauth = __esm({
+  "src/utils/claude-oauth.ts"() {
+    "use strict";
+    OAUTH_CONFIG = {
+      clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+      // Claude Code's client ID
+      authorizationEndpoint: "https://claude.ai/oauth/authorize",
+      tokenEndpoint: "https://console.anthropic.com/v1/oauth/token",
+      redirectUri: "http://localhost:8421/callback",
+      // Local callback for CLI
+      scopes: ["user:inference", "user:profile", "org:create_api_key"]
+    };
+    CALLBACK_PORT = 8421;
+    CALLBACK_TIMEOUT_MS = 3e5;
+    ClaudeOAuthService = class _ClaudeOAuthService {
+      secretStorage;
+      static TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+      // 5 minutes
+      pendingCodeVerifier = null;
+      // Store code verifier for PKCE
+      constructor(secretStorage) {
+        this.secretStorage = secretStorage;
+      }
+      /**
+       * Starts the OAuth authorization flow
+       * Opens the default browser for user authentication
+       * Returns after successful authentication
+       */
+      async authorize() {
+        try {
+          const state = this.generateRandomState();
+          const pkce = this.generatePKCEChallenge();
+          this.pendingCodeVerifier = pkce.codeVerifier;
+          const authUrl = this.buildAuthorizationUrl(state, pkce.codeChallenge);
+          console.log("\nAuthenticating with Claude...\n");
+          console.log(`Opening browser to: ${authUrl}
+`);
+          const tokenPromise = this.startCallbackServer(CALLBACK_PORT, state);
+          try {
+            this.openBrowser(authUrl);
+          } catch (error) {
+            console.warn("Failed to open browser automatically:", error);
+            console.log(`
+Please manually open this URL in your browser:
+${authUrl}
+`);
+          }
+          await tokenPromise;
+          console.log("\n\u2705 Successfully authenticated with Claude!\n");
+          return { success: true };
+        } catch (error) {
+          this.pendingCodeVerifier = null;
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Authentication failed"
+          };
+        }
+      }
+      /**
+       * Start local HTTP server to receive OAuth callback
+       */
+      startCallbackServer(port, expectedState) {
+        return new Promise((resolve2, reject) => {
+          const server = http.createServer(async (req, res) => {
+            if (req.method !== "GET" || !req.url?.startsWith("/callback")) {
+              res.writeHead(404);
+              res.end("Not Found");
+              return;
+            }
+            const url = new URL(req.url, `http://localhost:${port}`);
+            const code = url.searchParams.get("code");
+            const returnedState = url.searchParams.get("state");
+            const error = url.searchParams.get("error");
+            if (error) {
+              res.writeHead(200, { "Content-Type": "text/html" });
+              res.end(this.buildErrorPage(error));
+              server.close();
+              reject(new Error(`OAuth error: ${error}`));
+              return;
+            }
+            if (returnedState !== expectedState) {
+              const errorMsg = "Security error: state parameter mismatch";
+              res.writeHead(200, { "Content-Type": "text/html" });
+              res.end(this.buildErrorPage(errorMsg));
+              server.close();
+              reject(new Error(errorMsg));
+              return;
+            }
+            if (!code) {
+              const errorMsg = "No authorization code received";
+              res.writeHead(400, { "Content-Type": "text/html" });
+              res.end(this.buildErrorPage(errorMsg));
+              server.close();
+              reject(new Error(errorMsg));
+              return;
+            }
+            try {
+              await this.submitAuthCode(code, returnedState);
+              res.writeHead(200, { "Content-Type": "text/html" });
+              res.end(this.buildSuccessPage());
+              server.close();
+              resolve2();
+            } catch (err) {
+              const errorMsg = err instanceof Error ? err.message : "Token exchange failed";
+              res.writeHead(200, { "Content-Type": "text/html" });
+              res.end(this.buildErrorPage(errorMsg));
+              server.close();
+              reject(err);
+            }
+          });
+          server.on("error", (error) => {
+            if (error.code === "EADDRINUSE") {
+              reject(new Error("Port already in use. Please try again."));
+            } else {
+              reject(error);
+            }
+          });
+          const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error("Authentication timeout - no response received after 5 minutes"));
+          }, CALLBACK_TIMEOUT_MS);
+          server.on("close", () => {
+            clearTimeout(timeout);
+          });
+          server.listen(port, "127.0.0.1", () => {
+            console.log(`Waiting for authentication callback on http://localhost:${port}/callback`);
+          });
+        });
+      }
+      /**
+       * Submits the authorization code and exchanges it for tokens
+       */
+      async submitAuthCode(code, state) {
+        const tokens = await this.exchangeCodeForTokens(code, state);
+        await this.saveTokens(tokens);
+        return tokens;
+      }
+      /**
+       * Exchanges authorization code for access and refresh tokens
+       */
+      async exchangeCodeForTokens(code, state) {
+        if (!this.pendingCodeVerifier) {
+          throw new Error("No PKCE code verifier found. Please start the auth flow first.");
+        }
+        const body = {
+          grant_type: "authorization_code",
+          code,
+          state,
+          // Non-standard: state in body
+          redirect_uri: OAUTH_CONFIG.redirectUri,
+          client_id: OAUTH_CONFIG.clientId,
+          code_verifier: this.pendingCodeVerifier
+          // PKCE verifier
+        };
+        const response = await fetch(OAUTH_CONFIG.tokenEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+            // Non-standard: JSON instead of form-encoded
+          },
+          body: JSON.stringify(body)
+        });
+        this.pendingCodeVerifier = null;
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Token exchange failed: ${error}`);
+        }
+        const data = await response.json();
+        return {
+          accessToken: data.access_token,
+          refreshToken: data.refresh_token,
+          expiresAt: Date.now() + data.expires_in * 1e3
+        };
+      }
+      /**
+       * Refreshes the access token using the refresh token
+       */
+      async refreshTokens() {
+        const tokens = await this.getTokens();
+        if (!tokens) {
+          throw new Error("No tokens found to refresh");
+        }
+        const body = {
+          grant_type: "refresh_token",
+          refresh_token: tokens.refreshToken,
+          client_id: OAUTH_CONFIG.clientId
+        };
+        const response = await fetch(OAUTH_CONFIG.tokenEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Token refresh failed: ${error}`);
+        }
+        const data = await response.json();
+        const newTokens = {
+          accessToken: data.access_token,
+          refreshToken: data.refresh_token,
+          expiresAt: Date.now() + data.expires_in * 1e3
+        };
+        await this.saveTokens(newTokens);
+        return newTokens;
+      }
+      /**
+       * Gets the current access token, refreshing if necessary
+       */
+      async getAccessToken() {
+        const tokens = await this.getTokens();
+        if (!tokens) {
+          return null;
+        }
+        if (Date.now() > tokens.expiresAt - _ClaudeOAuthService.TOKEN_REFRESH_BUFFER_MS) {
+          try {
+            const refreshedTokens = await this.refreshTokens();
+            return refreshedTokens.accessToken;
+          } catch (error) {
+            console.warn("Token refresh failed:", error);
+            return null;
+          }
+        }
+        return tokens.accessToken;
+      }
+      /**
+       * Gets the stored tokens
+       */
+      async getTokens() {
+        try {
+          const accessToken = await this.secretStorage.getSecret("claude_oauth_access_token");
+          const refreshToken = await this.secretStorage.getSecret("claude_oauth_refresh_token");
+          const expiresAt = await this.secretStorage.getSecret("claude_oauth_expires_at");
+          if (!accessToken || !refreshToken || !expiresAt) {
+            return null;
+          }
+          return {
+            accessToken,
+            refreshToken,
+            expiresAt: parseInt(expiresAt, 10)
+          };
+        } catch (error) {
+          console.error("Failed to get OAuth tokens:", error);
+          return null;
+        }
+      }
+      /**
+       * Saves OAuth tokens to secure storage
+       */
+      async saveTokens(tokens) {
+        await this.secretStorage.setSecret("claude_oauth_access_token", tokens.accessToken);
+        await this.secretStorage.setSecret("claude_oauth_refresh_token", tokens.refreshToken);
+        await this.secretStorage.setSecret("claude_oauth_expires_at", tokens.expiresAt.toString());
+      }
+      /**
+       * Deletes stored OAuth tokens
+       */
+      async deleteTokens() {
+        await this.secretStorage.deleteSecret("claude_oauth_access_token");
+        await this.secretStorage.deleteSecret("claude_oauth_refresh_token");
+        await this.secretStorage.deleteSecret("claude_oauth_expires_at");
+      }
+      /**
+       * Checks if user is authenticated via OAuth
+       */
+      async isAuthenticated() {
+        const tokens = await this.getTokens();
+        return tokens !== null;
+      }
+      /**
+       * Gets the current OAuth authentication status
+       */
+      async getStatus() {
+        try {
+          const tokens = await this.getTokens();
+          if (!tokens) {
+            return { isAuthenticated: false };
+          }
+          return {
+            isAuthenticated: true,
+            expiresAt: tokens.expiresAt
+          };
+        } catch (error) {
+          return {
+            isAuthenticated: false,
+            error: error instanceof Error ? error.message : "Failed to get OAuth status"
+          };
+        }
+      }
+      /**
+       * Builds the authorization URL with all required parameters
+       */
+      buildAuthorizationUrl(state, codeChallenge) {
+        const params = new URLSearchParams({
+          response_type: "code",
+          client_id: OAUTH_CONFIG.clientId,
+          redirect_uri: OAUTH_CONFIG.redirectUri,
+          scope: OAUTH_CONFIG.scopes.join(" "),
+          state
+        });
+        if (codeChallenge) {
+          params.set("code_challenge", codeChallenge);
+          params.set("code_challenge_method", "S256");
+        }
+        return `${OAUTH_CONFIG.authorizationEndpoint}?${params.toString()}`;
+      }
+      /**
+       * Generates a random state string for CSRF protection
+       */
+      generateRandomState() {
+        return Array.from(crypto.getRandomValues(new Uint8Array(32))).map((b) => b.toString(16).padStart(2, "0")).join("");
+      }
+      /**
+       * Generates PKCE code verifier and challenge
+       * PKCE (Proof Key for Code Exchange) adds security to OAuth for public clients
+       */
+      generatePKCEChallenge() {
+        const codeVerifier = randomBytes(32).toString("base64url");
+        const hash = createHash("sha256").update(codeVerifier).digest("base64url");
+        return {
+          codeVerifier,
+          codeChallenge: hash
+        };
+      }
+      /**
+       * Open a URL in the default browser cross-platform
+       */
+      openBrowser(url) {
+        const os3 = platform();
+        let command;
+        let args;
+        switch (os3) {
+          case "darwin":
+            command = "open";
+            args = [url];
+            break;
+          case "win32":
+            command = "start";
+            args = ["", url];
+            break;
+          default:
+            command = "xdg-open";
+            args = [url];
+            break;
+        }
+        const options = { detached: true, stdio: "ignore", shell: os3 === "win32" };
+        spawn(command, args, options).unref();
+      }
+      /**
+       * Build success HTML page
+       */
+      buildSuccessPage() {
+        return `
+			<!DOCTYPE html>
+			<html lang="en">
+				<head>
+					<meta charset="UTF-8" />
+					<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+					<title>Authentication Successful - Supatest CLI</title>
+					<style>
+						body {
+							font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+							display: flex;
+							align-items: center;
+							justify-content: center;
+							height: 100vh;
+							margin: 0;
+							background: #fefefe;
+						}
+						.container {
+							background: white;
+							padding: 3rem 2rem;
+							border-radius: 12px;
+							box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+							border: 1px solid #e5e7eb;
+							text-align: center;
+							max-width: 400px;
+						}
+						.success-icon {
+							font-size: 48px;
+							margin-bottom: 1rem;
+						}
+						h1 {
+							color: #10b981;
+							margin: 0 0 1rem 0;
+							font-size: 24px;
+						}
+						p {
+							color: #666;
+							margin: 0;
+							line-height: 1.5;
+						}
+					</style>
+				</head>
+				<body>
+					<div class="container">
+						<div class="success-icon">\u2705</div>
+						<h1>Authentication Successful!</h1>
+						<p>You're now authenticated with Claude.</p>
+						<p style="margin-top: 1rem;">You can close this window and return to your terminal.</p>
+					</div>
+				</body>
+			</html>
+		`;
+      }
+      /**
+       * Build error HTML page
+       */
+      buildErrorPage(errorMessage) {
+        const escapedError = errorMessage.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+        return `
+			<!DOCTYPE html>
+			<html lang="en">
+				<head>
+					<meta charset="UTF-8" />
+					<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+					<title>Authentication Failed - Supatest CLI</title>
+					<style>
+						body {
+							font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+							display: flex;
+							align-items: center;
+							justify-content: center;
+							height: 100vh;
+							margin: 0;
+							background: #fefefe;
+						}
+						.container {
+							background: white;
+							padding: 3rem 2rem;
+							border-radius: 12px;
+							box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+							border: 1px solid #e5e7eb;
+							text-align: center;
+							max-width: 400px;
+						}
+						.error-icon {
+							font-size: 48px;
+							margin-bottom: 1rem;
+						}
+						h1 {
+							color: #dc2626;
+							margin: 0 0 1rem 0;
+							font-size: 24px;
+						}
+						p {
+							color: #666;
+							margin: 0;
+							line-height: 1.5;
+						}
+					</style>
+				</head>
+				<body>
+					<div class="container">
+						<div class="error-icon">\u274C</div>
+						<h1>Authentication Failed</h1>
+						<p>${escapedError}</p>
+						<p style="margin-top: 1rem;">You can close this window and try again.</p>
+					</div>
+				</body>
+			</html>
+		`;
+      }
+    };
+  }
+});
+
+// src/utils/secret-storage.ts
+var secret_storage_exports = {};
+__export(secret_storage_exports, {
+  deleteSecret: () => deleteSecret,
+  getSecret: () => getSecret,
+  getSecretStorage: () => getSecretStorage,
+  listSecrets: () => listSecrets,
+  setSecret: () => setSecret
+});
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+async function getSecret(key) {
+  return storage.getSecret(key);
+}
+async function setSecret(key, value) {
+  await storage.setSecret(key, value);
+}
+async function deleteSecret(key) {
+  return storage.deleteSecret(key);
+}
+async function listSecrets() {
+  return storage.listSecrets();
+}
+function getSecretStorage() {
+  return storage;
+}
+var SECRET_FILE_NAME, FileSecretStorage, storage;
+var init_secret_storage = __esm({
+  "src/utils/secret-storage.ts"() {
+    "use strict";
+    SECRET_FILE_NAME = "secrets.json";
+    FileSecretStorage = class {
+      secretFilePath;
+      constructor() {
+        const rootDirName = process.env.NODE_ENV === "development" ? ".supatest-dev" : ".supatest";
+        const secretsDir = join(homedir(), rootDirName, "claude-auth");
+        this.secretFilePath = join(secretsDir, SECRET_FILE_NAME);
+      }
+      async ensureDirectoryExists() {
+        const dir = dirname(this.secretFilePath);
+        await fs.mkdir(dir, { recursive: true, mode: 448 });
+      }
+      async loadSecrets() {
+        try {
+          const data = await fs.readFile(this.secretFilePath, "utf-8");
+          const secrets = JSON.parse(data);
+          return new Map(Object.entries(secrets));
+        } catch (error) {
+          const err = error;
+          if (err.code === "ENOENT") {
+            return /* @__PURE__ */ new Map();
+          }
+          try {
+            await fs.unlink(this.secretFilePath);
+          } catch {
+          }
+          return /* @__PURE__ */ new Map();
+        }
+      }
+      async saveSecrets(secrets) {
+        await this.ensureDirectoryExists();
+        const data = Object.fromEntries(secrets);
+        const json = JSON.stringify(data, null, 2);
+        await fs.writeFile(this.secretFilePath, json, { mode: 384 });
+      }
+      async getSecret(key) {
+        const secrets = await this.loadSecrets();
+        return secrets.get(key) ?? null;
+      }
+      async setSecret(key, value) {
+        const secrets = await this.loadSecrets();
+        secrets.set(key, value);
+        await this.saveSecrets(secrets);
+      }
+      async deleteSecret(key) {
+        const secrets = await this.loadSecrets();
+        if (!secrets.has(key)) {
+          return false;
+        }
+        secrets.delete(key);
+        if (secrets.size === 0) {
+          try {
+            await fs.unlink(this.secretFilePath);
+          } catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT") {
+              throw error;
+            }
+          }
+        } else {
+          await this.saveSecrets(secrets);
+        }
+        return true;
+      }
+      async listSecrets() {
+        const secrets = await this.loadSecrets();
+        return Array.from(secrets.keys());
+      }
+    };
+    storage = new FileSecretStorage();
   }
 });
 
 // src/commands/setup.ts
-import { execSync, spawnSync } from "child_process";
-import fs from "fs";
+import { execSync, spawn as spawn2, spawnSync } from "child_process";
+import fs2 from "fs";
 import os from "os";
 import path from "path";
 function parseVersion(versionString) {
@@ -5688,7 +6692,7 @@ function getPlaywrightCachePath() {
     // Windows
   ];
   for (const cachePath of cachePaths) {
-    if (fs.existsSync(cachePath)) {
+    if (fs2.existsSync(cachePath)) {
       return cachePath;
     }
   }
@@ -5698,7 +6702,7 @@ function getInstalledChromiumVersion() {
   const cachePath = getPlaywrightCachePath();
   if (!cachePath) return null;
   try {
-    const entries = fs.readdirSync(cachePath);
+    const entries = fs2.readdirSync(cachePath);
     const chromiumVersions = entries.filter((entry) => entry.startsWith("chromium-") && !entry.includes("headless")).map((entry) => entry.replace("chromium-", "")).sort((a, b) => Number(b) - Number(a));
     return chromiumVersions[0] || null;
   } catch {
@@ -5730,47 +6734,64 @@ function checkNodeVersion() {
     version: nodeVersion.raw
   };
 }
-function installChromium() {
-  console.log("   Running: npx playwright install chromium");
-  console.log("");
-  try {
-    const result = spawnSync("npx", ["playwright", "install", "chromium"], {
+async function installChromium() {
+  return new Promise((resolve2) => {
+    const child = spawn2("npx", ["playwright", "install", "chromium"], {
       stdio: "inherit",
       shell: true
       // Required for Windows where npx is npx.cmd
     });
-    if (result.status === 0) {
-      return {
-        ok: true,
-        message: "Chromium browser installed successfully."
-      };
-    }
-    return {
-      ok: false,
-      message: `Playwright install exited with code ${result.status}`
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      message: `Failed to install Chromium: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2({
+          ok: true,
+          message: "Chromium browser installed successfully."
+        });
+      } else {
+        resolve2({
+          ok: false,
+          message: `Playwright install exited with code ${code}`
+        });
+      }
+    });
+    child.on("error", (error) => {
+      resolve2({
+        ok: false,
+        message: `Failed to install Chromium: ${error.message}`
+      });
+    });
+  });
 }
 function createSupatestConfig(cwd) {
   const supatestDir = path.join(cwd, ".supatest");
   const mcpJsonPath = path.join(supatestDir, "mcp.json");
   try {
-    if (fs.existsSync(mcpJsonPath)) {
+    if (!fs2.existsSync(supatestDir)) {
+      fs2.mkdirSync(supatestDir, { recursive: true });
+    }
+    let config2;
+    let fileExisted = false;
+    if (fs2.existsSync(mcpJsonPath)) {
+      fileExisted = true;
+      const existingContent = fs2.readFileSync(mcpJsonPath, "utf-8");
+      config2 = JSON.parse(existingContent);
+    } else {
+      config2 = {};
+    }
+    if (!config2.mcpServers || typeof config2.mcpServers !== "object") {
+      config2.mcpServers = {};
+    }
+    if (!config2.mcpServers.playwright) {
+      config2.mcpServers.playwright = DEFAULT_MCP_CONFIG.mcpServers.playwright;
+    }
+    fs2.writeFileSync(mcpJsonPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+    if (fileExisted) {
       return {
         ok: true,
-        message: "mcp.json already exists",
+        message: "Updated .supatest/mcp.json with Playwright MCP server configuration",
         created: false
       };
     }
-    if (!fs.existsSync(supatestDir)) {
-      fs.mkdirSync(supatestDir, { recursive: true });
-    }
-    fs.writeFileSync(mcpJsonPath, JSON.stringify(DEFAULT_MCP_CONFIG, null, 2) + "\n", "utf-8");
     return {
       ok: true,
       message: "Created .supatest/mcp.json with Playwright MCP server configuration",
@@ -5799,7 +6820,6 @@ async function setupCommand(options) {
   const output = [];
   const log = (msg) => {
     output.push(msg);
-    console.log(msg);
   };
   const result = {
     nodeVersionOk: false,
@@ -5833,7 +6853,7 @@ async function setupCommand(options) {
     result.playwrightInstalled = true;
   } else {
     log("   \u{1F4E6} Chromium browser not found. Installing...\n");
-    const chromiumResult = installChromium();
+    const chromiumResult = await installChromium();
     result.playwrightInstalled = chromiumResult.ok;
     log("");
     if (chromiumResult.ok) {
@@ -5891,18 +6911,18 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    CLI_VERSION = "0.0.39";
+    CLI_VERSION = "0.0.41";
   }
 });
 
 // src/utils/error-logger.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as os2 from "os";
 import * as path2 from "path";
 function ensureLogDir() {
   try {
-    if (!fs2.existsSync(LOGS_DIR)) {
-      fs2.mkdirSync(LOGS_DIR, { recursive: true });
+    if (!fs3.existsSync(LOGS_DIR)) {
+      fs3.mkdirSync(LOGS_DIR, { recursive: true });
     }
     return true;
   } catch {
@@ -5911,14 +6931,14 @@ function ensureLogDir() {
 }
 function rotateLogIfNeeded() {
   try {
-    if (!fs2.existsSync(ERROR_LOG_FILE)) return;
-    const stats = fs2.statSync(ERROR_LOG_FILE);
+    if (!fs3.existsSync(ERROR_LOG_FILE)) return;
+    const stats = fs3.statSync(ERROR_LOG_FILE);
     if (stats.size > MAX_LOG_SIZE) {
       const oldLogFile = `${ERROR_LOG_FILE}.old`;
-      if (fs2.existsSync(oldLogFile)) {
-        fs2.unlinkSync(oldLogFile);
+      if (fs3.existsSync(oldLogFile)) {
+        fs3.unlinkSync(oldLogFile);
       }
-      fs2.renameSync(ERROR_LOG_FILE, oldLogFile);
+      fs3.renameSync(ERROR_LOG_FILE, oldLogFile);
     }
   } catch {
   }
@@ -5954,7 +6974,7 @@ function logError(error, context) {
   const logLine = `${JSON.stringify(entry)}
 `;
   try {
-    fs2.appendFileSync(ERROR_LOG_FILE, logLine);
+    fs3.appendFileSync(ERROR_LOG_FILE, logLine);
   } catch {
   }
 }
@@ -5971,7 +6991,7 @@ var init_error_logger = __esm({
 });
 
 // src/utils/logger.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path3 from "path";
 import chalk from "chalk";
 var Logger, logger;
@@ -6005,7 +7025,7 @@ ${"=".repeat(80)}
 ${"=".repeat(80)}
 `;
         try {
-          fs3.appendFileSync(this.logFile, separator);
+          fs4.appendFileSync(this.logFile, separator);
         } catch (error) {
         }
       }
@@ -6019,7 +7039,7 @@ ${"=".repeat(80)}
 ` : `[${timestamp}] [${level}] ${message}
 `;
         try {
-          fs3.appendFileSync(this.logFile, logEntry);
+          fs4.appendFileSync(this.logFile, logEntry);
         } catch (error) {
         }
       }
@@ -6626,13 +7646,146 @@ var init_api_client = __esm({
         logger.debug(`Fetched ${data.history.length} history items for test ${testId}`);
         return data;
       }
+      /**
+       * Assign tests to yourself (or someone else)
+       * @param params - Assignment parameters
+       * @returns Assignment result with assigned tests and conflicts
+       */
+      async assignTests(params) {
+        const url = `${this.apiUrl}/v1/fix-assignments/assign`;
+        logger.debug(`Assigning tests`, {
+          runId: params.runId,
+          count: params.testRunIds.length
+        });
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify({
+            testRunIds: params.testRunIds,
+            assignedTo: params.assignedTo
+          })
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        logger.debug(
+          `Assigned ${data.assigned.length} tests, ${data.conflicts.length} conflicts`
+        );
+        return data;
+      }
+      /**
+       * Mark assignment as complete
+       * @param params - Completion parameters
+       * @returns Success status
+       */
+      async completeAssignment(params) {
+        const url = `${this.apiUrl}/v1/fix-assignments/${params.assignmentId}/status`;
+        logger.debug(`Completing assignment`, {
+          assignmentId: params.assignmentId,
+          status: params.status
+        });
+        const response = await fetch(url, {
+          method: "PATCH",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify({
+            status: params.status,
+            fixSessionId: params.fixSessionId
+          })
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        logger.debug(`Assignment completed: ${params.assignmentId}`);
+        return data;
+      }
+      /**
+       * Release claim (delete assignment)
+       * @param assignmentId - The assignment ID to release
+       * @returns Success status
+       */
+      async releaseAssignment(assignmentId) {
+        const url = `${this.apiUrl}/v1/fix-assignments/${assignmentId}`;
+        logger.debug(`Releasing assignment: ${assignmentId}`);
+        const response = await fetch(url, {
+          method: "DELETE",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        logger.debug(`Assignment released: ${assignmentId}`);
+        return data;
+      }
+      /**
+       * Get my current assignments
+       * @returns List of current assignments
+       */
+      async getMyAssignments() {
+        const url = `${this.apiUrl}/v1/fix-assignments?status=assigned`;
+        logger.debug(`Fetching my assignments`);
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        logger.debug(`Fetched ${data.assignments.length} assignments`);
+        return { assignments: data.assignments };
+      }
+      /**
+       * Get assignments for a specific run (to show what others are working on)
+       * @param runId - The run ID
+       * @returns List of assignments for the run
+       */
+      async getRunAssignments(runId) {
+        const url = `${this.apiUrl}/v1/fix-assignments?runId=${runId}&status=assigned`;
+        logger.debug(`Fetching assignments for run: ${runId}`);
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        logger.debug(`Fetched ${data.assignments.length} assignments for run ${runId}`);
+        return {
+          assignments: data.assignments.map((a) => ({
+            testRunId: a.testRunId,
+            assignedTo: a.assignedTo,
+            assignedAt: a.assignedAt
+          }))
+        };
+      }
     };
   }
 });
 
 // src/utils/command-discovery.ts
 import { existsSync as existsSync2, readdirSync, readFileSync, statSync as statSync2 } from "fs";
-import { join as join3, relative } from "path";
+import { join as join4, relative } from "path";
 function parseMarkdownFrontmatter(content) {
   const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -6657,7 +7810,7 @@ function discoverMarkdownFiles(dir, baseDir, files = []) {
   }
   const entries = readdirSync(dir);
   for (const entry of entries) {
-    const fullPath = join3(dir, entry);
+    const fullPath = join4(dir, entry);
     const stat = statSync2(fullPath);
     if (stat.isDirectory()) {
       discoverMarkdownFiles(fullPath, baseDir, files);
@@ -6668,7 +7821,7 @@ function discoverMarkdownFiles(dir, baseDir, files = []) {
   return files;
 }
 function discoverCommands(cwd) {
-  const commandsDir = join3(cwd, ".supatest", "commands");
+  const commandsDir = join4(cwd, ".supatest", "commands");
   if (!existsSync2(commandsDir)) {
     return [];
   }
@@ -6691,9 +7844,9 @@ function discoverCommands(cwd) {
   return commands.sort((a, b) => a.name.localeCompare(b.name));
 }
 function expandCommand(cwd, commandName, args) {
-  const commandsDir = join3(cwd, ".supatest", "commands");
+  const commandsDir = join4(cwd, ".supatest", "commands");
   const relativePath = commandName.replace(/\./g, "/") + ".md";
-  const filePath = join3(commandsDir, relativePath);
+  const filePath = join4(commandsDir, relativePath);
   if (!existsSync2(filePath)) {
     return null;
   }
@@ -6716,7 +7869,7 @@ function expandCommand(cwd, commandName, args) {
   }
 }
 function discoverAgents(cwd) {
-  const agentsDir = join3(cwd, ".supatest", "agents");
+  const agentsDir = join4(cwd, ".supatest", "agents");
   if (!existsSync2(agentsDir)) {
     return [];
   }
@@ -6747,8 +7900,8 @@ var init_command_discovery = __esm({
 
 // src/utils/mcp-loader.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
 function expandEnvVar(value) {
   return value.replace(/\$\{([^}]+)\}/g, (_, expr) => {
     const [varName, defaultValue] = expr.split(":-");
@@ -6797,9 +7950,9 @@ function loadMcpServersFromFile(mcpPath) {
   }
 }
 function loadMcpServers(cwd) {
-  const globalMcpPath = join4(homedir2(), ".supatest", "mcp.json");
+  const globalMcpPath = join5(homedir3(), ".supatest", "mcp.json");
   const globalServers = loadMcpServersFromFile(globalMcpPath);
-  const projectMcpPath = join4(cwd, ".supatest", "mcp.json");
+  const projectMcpPath = join5(cwd, ".supatest", "mcp.json");
   const projectServers = loadMcpServersFromFile(projectMcpPath);
   return { ...globalServers, ...projectServers };
 }
@@ -6811,11 +7964,11 @@ var init_mcp_loader = __esm({
 
 // src/utils/project-instructions.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function loadProjectInstructions(cwd) {
   const paths = [
-    join5(cwd, "SUPATEST.md"),
-    join5(cwd, ".supatest", "SUPATEST.md")
+    join6(cwd, "SUPATEST.md"),
+    join6(cwd, ".supatest", "SUPATEST.md")
   ];
   for (const path6 of paths) {
     if (existsSync4(path6)) {
@@ -6835,8 +7988,8 @@ var init_project_instructions = __esm({
 
 // src/core/agent.ts
 import { createRequire } from "module";
-import { homedir as homedir3 } from "os";
-import { dirname, join as join6 } from "path";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname2, join as join7 } from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 var CoreAgent;
 var init_agent = __esm({
@@ -6853,6 +8006,8 @@ var init_agent = __esm({
       presenter;
       abortController = null;
       messageBridge = null;
+      // Map of pending questions waiting for user answers
+      pendingQuestionResolvers = /* @__PURE__ */ new Map();
       constructor(presenter, messageBridge) {
         this.presenter = presenter;
         this.messageBridge = messageBridge ?? null;
@@ -6866,9 +8021,37 @@ var init_agent = __esm({
           this.abortController.abort();
         }
       }
+      /**
+       * Create a promise that waits for user to answer a question.
+       * Used by canUseTool callback to pause agent execution until user responds.
+       */
+      createQuestionPromise(questionId) {
+        return new Promise((resolve2) => {
+          this.pendingQuestionResolvers.set(questionId, resolve2);
+        });
+      }
+      /**
+       * Submit an answer for a pending question.
+       * Called from the UI when user responds to AskUserQuestion.
+       * @param questionId - The unique ID of the question
+       * @param answers - The user's answers, or null if dismissed
+       * @returns true if question was found and resolved, false otherwise
+       */
+      submitAnswer(questionId, answers) {
+        const resolver = this.pendingQuestionResolvers.get(questionId);
+        if (resolver) {
+          resolver(answers);
+          this.pendingQuestionResolvers.delete(questionId);
+          return true;
+        }
+        return false;
+      }
       async run(config2) {
         this.abortController = new AbortController();
         this.presenter.onStart(config2);
+        if (config2.providerSessionId) {
+          this.presenter.onLog(`Resuming with providerSessionId: ${config2.providerSessionId}`);
+        }
         const claudeCodePath = await this.resolveClaudeCodePath();
         let prompt = config2.task;
         if (config2.logs) {
@@ -6936,7 +8119,7 @@ ${projectInstructions}`,
           this.presenter.onLog(`Auth: Using Claude Max (default Claude Code credentials)`);
           logger.debug("[agent] Claude Max mode: Using default ~/.claude/ config, cleared provider credentials");
         } else {
-          const internalConfigDir = join6(homedir3(), ".supatest", "claude-internal");
+          const internalConfigDir = join7(homedir4(), ".supatest", "claude-internal");
           cleanEnv.CLAUDE_CONFIG_DIR = internalConfigDir;
           cleanEnv.ANTHROPIC_API_KEY = config2.supatestApiKey || "";
           cleanEnv.ANTHROPIC_BASE_URL = process.env.ANTHROPIC_BASE_URL || "";
@@ -6951,6 +8134,9 @@ ${projectInstructions}`,
           CLAUDE_CONFIG_DIR: cleanEnv.CLAUDE_CONFIG_DIR || "(using default ~/.claude/)"
         });
         cleanEnv.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS = "1";
+        cleanEnv.CLAUDE_CODE_ENABLE_TELEMETRY = "0";
+        cleanEnv.DISABLE_TELEMETRY = "1";
+        cleanEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
         const selectedModel = config2.selectedModel || "premium";
         const defaultModel = resolveToAnthropicModel(selectedModel);
         const queryOptions = {
@@ -6982,7 +8168,7 @@ ${projectInstructions}`,
             return servers;
           })(),
           // Resume from previous session if providerSessionId is provided
-          // This allows the agent to continue conversations with full context
+          // This allows the agent to continue sessions with full context
           // Note: Sessions expire after ~30 days due to Anthropic's data retention policy
           ...config2.providerSessionId && {
             resume: config2.providerSessionId
@@ -6999,6 +8185,29 @@ ${projectInstructions}`,
           env: cleanEnv,
           stderr: (msg) => {
             this.presenter.onLog(`[Agent Failure] ${msg}`);
+          },
+          // Intercept AskUserQuestion tool to wait for user response
+          canUseTool: async (toolName, input) => {
+            if (toolName !== "AskUserQuestion") {
+              return { behavior: "allow", updatedInput: input };
+            }
+            const questions = input.questions || [];
+            if (questions.length === 0) {
+              logger.warn("[AskUserQuestion] No questions provided");
+              return { behavior: "deny", message: "No questions provided" };
+            }
+            const questionId = `ask-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            this.presenter.onToolUse?.(toolName, input, questionId);
+            const answers = await this.createQuestionPromise(questionId);
+            if (answers === null) {
+              this.presenter.onToolResult?.(questionId, JSON.stringify({ dismissed: true }));
+              return { behavior: "deny", message: "User dismissed the question" };
+            }
+            this.presenter.onToolResult?.(questionId, JSON.stringify({ answers }));
+            return {
+              behavior: "allow",
+              updatedInput: { questions, answers }
+            };
           }
         };
         let resultText = "";
@@ -7023,7 +8232,7 @@ ${projectInstructions}`,
         };
         const isSessionExpiredError = (errorMsg) => {
           const expiredPatterns = [
-            "no conversation found",
+            "no session found",
             "session not found",
             "session expired",
             "invalid session"
@@ -7031,6 +8240,20 @@ ${projectInstructions}`,
           const lowerError = errorMsg.toLowerCase();
           return expiredPatterns.some((pattern) => lowerError.includes(pattern));
         };
+        const isContextWindowExceededError = (errorMsg) => {
+          const contextPatterns = [
+            "exceed context limit",
+            "exceeds context limit",
+            "context length",
+            "maximum context",
+            "prompt is too long",
+            "input_length and max_tokens",
+            "requested token count exceeds",
+            "context window"
+          ];
+          const lowerError = errorMsg.toLowerCase();
+          return contextPatterns.some((pattern) => lowerError.includes(pattern));
+        };
         const runQuery = async (options) => {
           logger.debug("[agent] Starting query", {
             model: options.model,
@@ -7181,11 +8404,17 @@ ${projectInstructions}`,
             wasInterrupted = true;
             logger.debug("[agent] Query was aborted by user");
           } else if (config2.providerSessionId && isSessionExpiredError(errorMessage)) {
-            const expiredMessage = "Can't continue conversation older than 30 days. Please start a new session.";
+            const expiredMessage = "Can't continue session older than 30 days. Please start a new session.";
             this.presenter.onError(expiredMessage, true);
             hasError = true;
             errors.push(expiredMessage);
             logger.debug("[agent] Session expired error");
+          } else if (isContextWindowExceededError(errorMessage)) {
+            const contextMessage = "Context window exceeded. The session has grown too large.\n\nSuggestions:\n\u2022 Start a new session to begin fresh\n\u2022 Use /clear to reset the current session\n\u2022 Reduce file sizes or number of files in your request\n\u2022 Be more specific with your prompts to reduce context";
+            this.presenter.onError(contextMessage, true);
+            hasError = true;
+            errors.push(contextMessage);
+            logger.debug("[agent] Context window exceeded error");
           } else {
             logError(error, {
               source: "CoreAgent.run",
@@ -7220,7 +8449,7 @@ ${projectInstructions}`,
         let claudeCodePath;
         const require2 = createRequire(import.meta.url);
         const sdkPath = require2.resolve("@anthropic-ai/claude-agent-sdk/sdk.mjs");
-        claudeCodePath = join6(dirname(sdkPath), "cli.js");
+        claudeCodePath = join7(dirname2(sdkPath), "cli.js");
         this.presenter.onLog(`Using SDK CLI: ${claudeCodePath}`);
         if (config.claudeCodeExecutablePath) {
           claudeCodePath = config.claudeCodeExecutablePath;
@@ -7270,6 +8499,10 @@ function getToolDescription(toolName, input) {
     case "BashOutput":
     case "Command Output":
       return input?.bash_id || "shell output";
+    case "AskUserQuestion": {
+      const question = input?.questions?.[0]?.question || input?.question || "Question";
+      return question.length > 60 ? `${question.substring(0, 60)}...` : question;
+    }
     default:
       return toolName;
   }
@@ -7402,6 +8635,15 @@ var init_react = __esm({
           this.callbacks.onExitPlanMode?.();
         } else if (tool === "EnterPlanMode") {
           this.callbacks.onEnterPlanMode?.();
+        } else if (tool === "AskUserQuestion") {
+          const questions = input?.questions || [];
+          if (questions.length > 0) {
+            const firstQuestion = questions[0];
+            const question = firstQuestion.question || "";
+            const options = firstQuestion.options || [];
+            const multiSelect = firstQuestion.multiSelect || false;
+            this.callbacks.onAskUserQuestion?.(toolId, question, options, multiSelect);
+          }
         }
         streamEventAsync(this.apiClient, this.sessionId, {
           type: "tool_use",
@@ -7528,10 +8770,11 @@ var init_react = __esm({
 
 // src/ui/contexts/SessionContext.tsx
 import React, { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
-var SessionContext, SessionProvider, useSession;
+var UsageStatsContext, SessionContext, SessionProvider, useSession, useUsageStats;
 var init_SessionContext = __esm({
   "src/ui/contexts/SessionContext.tsx"() {
     "use strict";
+    UsageStatsContext = createContext(null);
     SessionContext = createContext(null);
     SessionProvider = ({
       children,
@@ -7558,6 +8801,7 @@ var init_SessionContext = __esm({
       const [allToolsExpanded, setAllToolsExpanded] = useState(true);
       const [toolGroupsExpanded, setToolGroupsExpanded] = useState(false);
       const [staticRemountKey, setStaticRemountKey] = useState(0);
+      const [pendingQuestion, setPendingQuestion] = useState(null);
       const addMessage = useCallback(
         (message) => {
           const expandableTools = ["Bash", "BashOutput", "Command Output"];
@@ -7671,8 +8915,6 @@ var init_SessionContext = __esm({
         setTodos,
         stats,
         updateStats,
-        usageStats,
-        setUsageStats,
         isAgentRunning,
         setIsAgentRunning,
         shouldInterruptAgent,
@@ -7690,7 +8932,9 @@ var init_SessionContext = __esm({
         llmProvider,
         setLlmProvider,
         staticRemountKey,
-        refreshStatic
+        refreshStatic,
+        pendingQuestion,
+        setPendingQuestion
       }), [
         messages,
         addMessage,
@@ -7706,7 +8950,6 @@ var init_SessionContext = __esm({
         todos,
         stats,
         updateStats,
-        usageStats,
         isAgentRunning,
         shouldInterruptAgent,
         sessionId,
@@ -7716,9 +8959,14 @@ var init_SessionContext = __esm({
         selectedModel,
         llmProvider,
         staticRemountKey,
-        refreshStatic
+        refreshStatic,
+        pendingQuestion
       ]);
-      return /* @__PURE__ */ React.createElement(SessionContext.Provider, { value }, children);
+      const usageStatsValue = useMemo(() => ({
+        usageStats,
+        setUsageStats
+      }), [usageStats]);
+      return /* @__PURE__ */ React.createElement(SessionContext.Provider, { value }, /* @__PURE__ */ React.createElement(UsageStatsContext.Provider, { value: usageStatsValue }, children));
     };
     useSession = () => {
       const context = useContext(SessionContext);
@@ -7727,6 +8975,13 @@ var init_SessionContext = __esm({
       }
       return context;
     };
+    useUsageStats = () => {
+      const context = useContext(UsageStatsContext);
+      if (!context) {
+        throw new Error("useUsageStats must be used within SessionProvider");
+      }
+      return context;
+    };
   }
 });
 
@@ -8436,6 +9691,14 @@ function getCommandDisplay(toolName, input) {
       return input.pattern ? [`"${input.pattern}"${input.path ? ` in ${input.path}` : ""}`] : null;
     case "Glob":
       return input.pattern ? [input.pattern] : null;
+    case "AskUserQuestion": {
+      const questions = input.questions || [];
+      if (questions.length > 0) {
+        const question = questions[0].question || "Question";
+        return [question.length > 80 ? `${question.substring(0, 80)}...` : question];
+      }
+      return null;
+    }
     default:
       return null;
   }
@@ -8451,7 +9714,8 @@ function getToolStyle(toolName) {
     Glob: { icon: "\u{1F50D}", color: theme.tool.search },
     Grep: { icon: "\u{1F50D}", color: theme.tool.search },
     Task: { icon: "\u{1F916}", color: theme.tool.agent },
-    TodoWrite: { icon: "\u{1F4DD}", color: theme.text.info }
+    TodoWrite: { icon: "\u{1F4DD}", color: theme.text.info },
+    AskUserQuestion: { icon: "\u2753", color: theme.text.info }
   };
   return styles[toolName] || { icon: "\u{1F527}", color: theme.text.secondary };
 }
@@ -8485,6 +9749,9 @@ function getResultSummary(toolName, result) {
       const lines = result.split("\n").filter((line) => line.trim());
       return lines.length > 0 ? `${lines.length} lines of output` : "No output";
     }
+    case "AskUserQuestion": {
+      return result ? `Answered: ${result.substring(0, 50)}${result.length > 50 ? "..." : ""}` : "Waiting for response...";
+    }
     default:
       return null;
   }
@@ -8569,16 +9836,7 @@ var init_UserMessage = __esm({
     "use strict";
     init_theme();
     UserMessage = ({ text }) => {
-      return /* @__PURE__ */ React11.createElement(Box10, { alignItems: "center", flexDirection: "row", marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: theme.text.info }, "\u{1F464} "), /* @__PURE__ */ React11.createElement(
-        Box10,
-        {
-          borderColor: theme.text.dim,
-          borderStyle: "round",
-          paddingLeft: 1,
-          paddingRight: 1
-        },
-        /* @__PURE__ */ React11.createElement(Text10, { color: theme.text.secondary }, text)
-      ));
+      return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "row", marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: theme.text.info }, "\u{1F464}  "), /* @__PURE__ */ React11.createElement(Text10, { color: theme.text.secondary }, text));
     };
   }
 });
@@ -8621,8 +9879,8 @@ var init_QueuedMessageDisplay = __esm({
 
 // src/ui/components/MessageList.tsx
 import { Box as Box12, Static } from "ink";
-import React13, { memo as memo2, useCallback as useCallback2, useMemo as useMemo3, useRef as useRef3 } from "react";
-var MessageList;
+import React13, { memo as memo2, useCallback as useCallback2, useMemo as useMemo3 } from "react";
+var StaticHeader, MessageList;
 var init_MessageList = __esm({
   "src/ui/components/MessageList.tsx"() {
     "use strict";
@@ -8637,6 +9895,11 @@ var init_MessageList = __esm({
     init_ToolMessage();
     init_UserMessage();
     init_QueuedMessageDisplay();
+    StaticHeader = memo2(({ currentFolder, gitBranch, headless, staticRemountKey }) => {
+      const headerItems = useMemo3(() => [{ id: "header" }], []);
+      return /* @__PURE__ */ React13.createElement(Static, { items: headerItems, key: `header-${staticRemountKey}` }, () => /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", key: "header" }, /* @__PURE__ */ React13.createElement(Header, { currentFolder, gitBranch, headless })));
+    });
+    StaticHeader.displayName = "StaticHeader";
     MessageList = memo2(({ terminalWidth, currentFolder, gitBranch, headless = false, queuedTasks = [] }) => {
       const { messages, updateMessageById, isAgentRunning, staticRemountKey, toolGroupsExpanded, toggleToolGroups } = useSession();
       const handleToggle = useCallback2((id, currentExpanded) => {
@@ -8738,31 +10001,29 @@ var init_MessageList = __esm({
         }
         return renderMessage(group.messages[0]);
       }, [toolGroupsExpanded, toggleToolGroups, handleToggle, renderMessage]);
-      const lastUserMessageIndex = useMemo3(() => {
-        for (let i = messages.length - 1; i >= 0; i--) {
-          if (messages[i].type === "user") {
-            return i;
-          }
-        }
-        return -1;
-      }, [messages]);
       const hasPendingAssistant = useMemo3(
         () => messages.some((m) => m.type === "assistant" && m.isPending),
         [messages]
       );
-      const completedBoundaryRef = useRef3(-1);
-      const completedBoundaryKey = useMemo3(() => {
-        const currentBoundary = lastUserMessageIndex;
-        if (currentBoundary !== completedBoundaryRef.current) {
-          completedBoundaryRef.current = currentBoundary;
-          return `boundary-${currentBoundary}`;
-        }
-        return `boundary-${completedBoundaryRef.current}`;
-      }, [lastUserMessageIndex]);
       const { completedGroups, currentTurnGroups } = useMemo3(() => {
         const completed = [];
         const currentTurn = [];
-        const processTurn = (turnMessages2, targetArray) => {
+        const isMessageComplete = (msg) => {
+          switch (msg.type) {
+            case "user":
+            case "error":
+            case "todo":
+            case "thinking":
+              return true;
+            case "tool":
+              return msg.toolResult !== void 0;
+            case "assistant":
+              return !msg.isPending;
+            default:
+              return true;
+          }
+        };
+        const processTurn = (turnMessages, targetArray) => {
           let currentToolGroup = [];
           const flushToolGroup = () => {
             if (currentToolGroup.length === 0) return;
@@ -8773,7 +10034,7 @@ var init_MessageList = __esm({
             }
             currentToolGroup = [];
           };
-          for (const msg of turnMessages2) {
+          for (const msg of turnMessages) {
             if (msg.type === "tool") {
               currentToolGroup.push(msg);
             } else {
@@ -8783,38 +10044,46 @@ var init_MessageList = __esm({
           }
           flushToolGroup();
         };
-        let turnMessages = [];
-        for (let i = 0; i < lastUserMessageIndex; i++) {
-          const msg = messages[i];
-          if (msg.type === "user") {
-            processTurn(turnMessages, completed);
-            turnMessages = [];
-            completed.push({ type: "single", messages: [msg] });
+        const completeMessages = [];
+        const inProgressMessages = [];
+        for (const msg of messages) {
+          if (isMessageComplete(msg)) {
+            completeMessages.push(msg);
           } else {
-            turnMessages.push(msg);
+            inProgressMessages.push(msg);
           }
         }
-        processTurn(turnMessages, completed);
-        if (lastUserMessageIndex >= 0) {
-          completed.push({ type: "single", messages: [messages[lastUserMessageIndex]] });
+        let splitIndex = messages.length;
+        for (let i = messages.length - 1; i >= 0; i--) {
+          if (isMessageComplete(messages[i])) {
+            splitIndex = i + 1;
+            break;
+          }
         }
-        const currentTurnMessages = lastUserMessageIndex >= 0 ? messages.slice(lastUserMessageIndex + 1) : messages;
-        processTurn(currentTurnMessages, currentTurn);
+        const finalCompleteMessages = messages.slice(0, splitIndex);
+        const finalInProgressMessages = messages.slice(splitIndex);
+        processTurn(finalCompleteMessages, completed);
+        processTurn(finalInProgressMessages, currentTurn);
         return { completedGroups: completed, currentTurnGroups: currentTurn };
-      }, [messages, lastUserMessageIndex, completedBoundaryKey]);
-      const staticItems = useMemo3(() => [
-        { id: "header", type: "header" },
-        ...completedGroups.map((group, idx) => {
+      }, [messages]);
+      const staticItems = useMemo3(
+        () => completedGroups.map((group, idx) => {
           if (group.type === "group") {
-            return { ...group, _isGroup: true, id: `group-${idx}` };
+            return { ...group, _isGroup: true, id: `group-${group.messages[0]?.id || idx}` };
           }
           return { ...group.messages[0], _isMessage: true };
-        })
-      ], [completedGroups]);
-      return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column" }, /* @__PURE__ */ React13.createElement(Static, { items: staticItems, key: staticRemountKey }, (item) => {
-        if (item.type === "header") {
-          return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", key: "header" }, /* @__PURE__ */ React13.createElement(Header, { currentFolder, gitBranch, headless }));
+        }),
+        [completedGroups]
+      );
+      return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column" }, /* @__PURE__ */ React13.createElement(
+        StaticHeader,
+        {
+          currentFolder,
+          gitBranch,
+          headless,
+          staticRemountKey
         }
+      ), staticItems.length > 0 && /* @__PURE__ */ React13.createElement(Static, { items: staticItems, key: `messages-${staticRemountKey}-${toolGroupsExpanded}` }, (item) => {
         if (item._isGroup) {
           const content2 = renderGroupedMessage(item);
           if (!content2) {
@@ -8908,7 +10177,7 @@ var init_stdio = __esm({
 });
 
 // src/utils/encryption.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 import { hostname, userInfo } from "os";
 function deriveEncryptionKey() {
   const host = hostname();
@@ -8917,7 +10186,7 @@ function deriveEncryptionKey() {
   if (process.env.DEBUG_ENCRYPTION) {
     console.error(`[encryption] hostname=${host}, username=${user}, salt=${salt}`);
   }
-  return crypto.scryptSync("supatest-cli-token", salt, KEY_LENGTH);
+  return crypto2.scryptSync("supatest-cli-token", salt, KEY_LENGTH);
 }
 function getEncryptionKey() {
   if (!cachedKey) {
@@ -8927,8 +10196,8 @@ function getEncryptionKey() {
 }
 function encrypt(plaintext) {
   const key = getEncryptionKey();
-  const iv = crypto.randomBytes(IV_LENGTH);
-  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  const iv = crypto2.randomBytes(IV_LENGTH);
+  const cipher = crypto2.createCipheriv(ALGORITHM, key, iv);
   let encrypted = cipher.update(plaintext, "utf8", "hex");
   encrypted += cipher.final("hex");
   const authTag = cipher.getAuthTag();
@@ -8943,7 +10212,7 @@ function decrypt(encryptedData) {
   const iv = Buffer.from(ivHex, "hex");
   const authTag = Buffer.from(authTagHex, "hex");
   const key = getEncryptionKey();
-  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  const decipher = crypto2.createDecipheriv(ALGORITHM, key, iv);
   decipher.setAuthTag(authTag);
   let decrypted = decipher.update(encrypted, "hex", "utf8");
   decrypted += decipher.final("utf8");
@@ -8962,14 +10231,14 @@ var init_encryption = __esm({
 
 // src/utils/token-storage.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
 function getTokenFilePath() {
   const apiUrl = process.env.SUPATEST_API_URL || PRODUCTION_API_URL;
   if (apiUrl === PRODUCTION_API_URL) {
-    return join7(CONFIG_DIR, "token.json");
+    return join8(CONFIG_DIR, "token.json");
   }
-  return join7(CONFIG_DIR, "token.local.json");
+  return join8(CONFIG_DIR, "token.local.json");
 }
 function isV2Format(stored) {
   return "version" in stored && stored.version === 2;
@@ -9037,10 +10306,10 @@ var init_token_storage = __esm({
   "src/utils/token-storage.ts"() {
     "use strict";
     init_encryption();
-    CONFIG_DIR = join7(homedir5(), ".supatest");
+    CONFIG_DIR = join8(homedir6(), ".supatest");
     PRODUCTION_API_URL = "https://code-api.supatest.ai";
     STORAGE_VERSION = 2;
-    TOKEN_FILE = join7(CONFIG_DIR, "token.json");
+    TOKEN_FILE = join8(CONFIG_DIR, "token.json");
   }
 });
 
@@ -9064,7 +10333,7 @@ var init_message_bridge = __esm({
         this.sessionId = sessionId;
       }
       /**
-       * Push a user message to be injected into the conversation.
+       * Push a user message to be injected into the session.
        * Call this from the UI when user submits a message during agent execution.
        */
       push(text) {
@@ -9136,15 +10405,15 @@ var init_message_bridge = __esm({
 });
 
 // src/commands/login.ts
-import { spawn as spawn2 } from "child_process";
-import crypto2 from "crypto";
-import http from "http";
-import { platform } from "os";
+import { spawn as spawn4 } from "child_process";
+import crypto3 from "crypto";
+import http2 from "http";
+import { platform as platform2 } from "os";
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function generateState() {
-  return crypto2.randomBytes(STATE_LENGTH).toString("hex");
+  return crypto3.randomBytes(STATE_LENGTH).toString("hex");
 }
 async function exchangeCodeForToken(code, state) {
   const response = await fetch(`${API_URL}/web/auth/cli-token-exchange`, {
@@ -9160,7 +10429,7 @@ async function exchangeCodeForToken(code, state) {
   return { token: data.token, expiresAt: data.expiresAt };
 }
 function openBrowser(url) {
-  const os3 = platform();
+  const os3 = platform2();
   let command;
   let args;
   switch (os3) {
@@ -9177,11 +10446,11 @@ function openBrowser(url) {
       args = [url];
   }
   const options = { detached: true, stdio: "ignore", shell: os3 === "win32" };
-  spawn2(command, args, options).unref();
+  spawn4(command, args, options).unref();
 }
 function startCallbackServer(port, expectedState) {
   return new Promise((resolve2, reject) => {
-    const server = http.createServer(async (req, res) => {
+    const server = http2.createServer(async (req, res) => {
       if (req.method !== "GET" || !req.url?.startsWith("/callback")) {
         res.writeHead(404);
         res.end("Not Found");
@@ -9242,7 +10511,7 @@ function startCallbackServer(port, expectedState) {
     const timeout = setTimeout(() => {
       server.close();
       reject(new Error("Login timeout - no response received after 5 minutes"));
-    }, CALLBACK_TIMEOUT_MS);
+    }, CALLBACK_TIMEOUT_MS2);
     server.on("close", () => {
       clearTimeout(timeout);
     });
@@ -9501,74 +10770,33 @@ ${loginUrl}
     throw error;
   }
 }
-var CLI_LOGIN_PORT, FRONTEND_URL, API_URL, CALLBACK_TIMEOUT_MS, STATE_LENGTH;
+var CLI_LOGIN_PORT, FRONTEND_URL, API_URL, CALLBACK_TIMEOUT_MS2, STATE_LENGTH;
 var init_login = __esm({
   "src/commands/login.ts"() {
     "use strict";
     CLI_LOGIN_PORT = 8420;
     FRONTEND_URL = process.env.SUPATEST_FRONTEND_URL || "https://code.supatest.ai";
     API_URL = process.env.SUPATEST_API_URL || "https://code-api.supatest.ai";
-    CALLBACK_TIMEOUT_MS = 3e5;
+    CALLBACK_TIMEOUT_MS2 = 3e5;
     STATE_LENGTH = 32;
   }
 });
 
 // src/utils/claude-max.ts
-import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
-function isClaudeMaxAvailable() {
-  const platform2 = process.platform;
-  logger.debug("[claude-max] Checking Claude Code credentials", { platform: platform2 });
-  if (platform2 === "darwin") {
-    return checkMacOSKeychain();
-  } else {
-    return checkCredentialsFile();
-  }
-}
-function checkMacOSKeychain() {
+async function isClaudeMaxAvailable() {
+  logger.debug("[claude-max] Checking Supatest OAuth credentials");
   try {
-    const credentialsJson = execSync5(
-      'security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null',
-      { encoding: "utf-8" }
-    ).trim();
-    if (!credentialsJson) {
-      logger.debug("[claude-max] No credentials found in macOS keychain");
-      return false;
+    const secretStorage = getSecretStorage();
+    const oauthService = new ClaudeOAuthService(secretStorage);
+    const hasSupatestOAuth = await oauthService.isAuthenticated();
+    if (hasSupatestOAuth) {
+      logger.debug("[claude-max] Found Supatest OAuth credentials");
+      return true;
     }
-    const credentials = JSON.parse(credentialsJson);
-    const hasOauth = !!credentials.claudeAiOauth?.accessToken;
-    logger.debug("[claude-max] macOS keychain credentials check", {
-      hasOauth,
-      hasRefreshToken: !!credentials.claudeAiOauth?.refreshToken
-    });
-    return hasOauth;
-  } catch (error) {
-    logger.debug("[claude-max] Error checking macOS keychain", {
-      error: error instanceof Error ? error.message : String(error)
-    });
+    logger.debug("[claude-max] No Supatest OAuth credentials found");
     return false;
-  }
-}
-function checkCredentialsFile() {
-  try {
-    const credentialsPath = join8(homedir6(), ".claude", ".credentials.json");
-    if (!existsSync6(credentialsPath)) {
-      logger.debug("[claude-max] Credentials file not found", { path: credentialsPath });
-      return false;
-    }
-    const credentialsJson = readFileSync5(credentialsPath, "utf-8");
-    const credentials = JSON.parse(credentialsJson);
-    const hasOauth = !!credentials.claudeAiOauth?.accessToken;
-    logger.debug("[claude-max] Credentials file check", {
-      path: credentialsPath,
-      hasOauth,
-      hasRefreshToken: !!credentials.claudeAiOauth?.refreshToken
-    });
-    return hasOauth;
   } catch (error) {
-    logger.debug("[claude-max] Error checking credentials file", {
+    logger.debug("[claude-max] Error checking Supatest OAuth storage", {
       error: error instanceof Error ? error.message : String(error)
     });
     return false;
@@ -9577,12 +10805,14 @@ function checkCredentialsFile() {
 var init_claude_max = __esm({
   "src/utils/claude-max.ts"() {
     "use strict";
+    init_claude_oauth();
     init_logger();
+    init_secret_storage();
   }
 });
 
 // src/utils/mcp-manager.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join9 } from "path";
 function getGlobalMcpPath() {
@@ -9592,11 +10822,11 @@ function getProjectMcpPath(cwd) {
   return join9(cwd, ".supatest", "mcp.json");
 }
 function loadMcpConfigFromFile(mcpPath, scope) {
-  if (!existsSync7(mcpPath)) {
+  if (!existsSync6(mcpPath)) {
     return {};
   }
   try {
-    const content = readFileSync6(mcpPath, "utf-8");
+    const content = readFileSync5(mcpPath, "utf-8");
     const config2 = JSON.parse(content);
     if (!config2.mcpServers) {
       return {};
@@ -9630,7 +10860,7 @@ function loadMcpConfig(cwd) {
 }
 function saveMcpConfigToFile(mcpPath, servers) {
   const mcpDir = join9(mcpPath, "..");
-  if (!existsSync7(mcpDir)) {
+  if (!existsSync6(mcpDir)) {
     mkdirSync3(mcpDir, { recursive: true });
   }
   const config2 = {
@@ -9814,15 +11044,15 @@ var init_mcp_manager = __esm({
 });
 
 // src/utils/settings-loader.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { join as join10 } from "path";
 function loadSupatestSettings(cwd) {
   const settingsPath = join10(cwd, ".supatest", "settings.json");
-  if (!existsSync8(settingsPath)) {
+  if (!existsSync7(settingsPath)) {
     return {};
   }
   try {
-    const content = readFileSync7(settingsPath, "utf-8");
+    const content = readFileSync6(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     console.warn(
@@ -9836,7 +11066,7 @@ function saveSupatestSettings(cwd, settings) {
   const settingsDir = join10(cwd, ".supatest");
   const settingsPath = join10(settingsDir, "settings.json");
   try {
-    if (!existsSync8(settingsDir)) {
+    if (!existsSync7(settingsDir)) {
       mkdirSync4(settingsDir, { recursive: true });
     }
     const existingSettings = loadSupatestSettings(cwd);
@@ -11015,18 +12245,37 @@ var init_TestSelector = __esm({
       apiClient,
       run,
       onSelect,
-      onCancel
+      onCancel,
+      assignments = []
     }) => {
       const [allTests, setAllTests] = useState7([]);
       const [selectedTests, setSelectedTests] = useState7(/* @__PURE__ */ new Set());
       const [cursorIndex, setCursorIndex] = useState7(0);
       const [isLoading, setIsLoading] = useState7(false);
+      const [isLoadingAssignments, setIsLoadingAssignments] = useState7(true);
       const [hasMore, setHasMore] = useState7(true);
       const [totalTests, setTotalTests] = useState7(0);
       const [error, setError] = useState7(null);
+      const [showAvailableOnly, setShowAvailableOnly] = useState7(true);
+      const [groupByFile, setGroupByFile] = useState7(false);
+      const assignedTestMap = new Map(assignments.map((a) => [a.testRunId, a]));
+      const assignedTestIds = new Set(assignments.map((a) => a.testRunId));
       useEffect7(() => {
         loadMoreTests();
       }, []);
+      useEffect7(() => {
+        fetchAssignments();
+      }, [run.id]);
+      const fetchAssignments = async () => {
+        setIsLoadingAssignments(true);
+        try {
+          const result = await apiClient.getRunAssignments(run.id);
+        } catch (err) {
+          console.error("Failed to load assignments:", err);
+        } finally {
+          setIsLoadingAssignments(false);
+        }
+      };
       const loadMoreTests = async () => {
         if (isLoading || !hasMore) {
           return;
@@ -11042,7 +12291,8 @@ var init_TestSelector = __esm({
             // Only fetch failed tests
           });
           setTotalTests(result.total);
-          setHasMore(allTests.length + result.tests.length < result.total);
+          const loadedCount = allTests.length + result.tests.length;
+          setHasMore(result.tests.length === PAGE_SIZE2 && loadedCount < result.total);
           setAllTests((prev) => [...prev, ...result.tests]);
         } catch (err) {
           setError(err instanceof Error ? err.message : String(err));
@@ -11051,8 +12301,34 @@ var init_TestSelector = __esm({
           setIsLoading(false);
         }
       };
-      const totalItems = allTests.length + 1;
-      const isOnFixAll = cursorIndex === 0;
+      const getFilteredTests = () => {
+        if (showAvailableOnly) {
+          return allTests.filter((t) => !assignedTestIds.has(t.id));
+        }
+        return allTests;
+      };
+      const filteredTests = getFilteredTests();
+      const availableCount = allTests.filter((t) => !assignedTestIds.has(t.id)).length;
+      const assignedCount = assignedTestIds.size;
+      const getTestsByFile = () => {
+        const groups = /* @__PURE__ */ new Map();
+        for (const test of filteredTests) {
+          const file = test.file;
+          if (!groups.has(file)) {
+            groups.set(file, []);
+          }
+          groups.get(file).push(test);
+        }
+        return Array.from(groups.entries()).map(([file, tests]) => ({
+          file,
+          tests,
+          availableCount: tests.filter((t) => !assignedTestIds.has(t.id)).length,
+          assignedCount: tests.filter((t) => assignedTestIds.has(t.id)).length
+        }));
+      };
+      const fileGroups = getTestsByFile();
+      const totalItems = groupByFile ? fileGroups.length + 1 : filteredTests.length + 1;
+      const isOnFixNext10 = cursorIndex === 0;
       const toggleTest = (testId) => {
         setSelectedTests((prev) => {
           const next = new Set(prev);
@@ -11064,50 +12340,92 @@ var init_TestSelector = __esm({
           return next;
         });
       };
-      const selectAll = () => {
-        setSelectedTests(new Set(allTests.map((t) => t.id)));
-      };
       const selectNone = () => {
         setSelectedTests(/* @__PURE__ */ new Set());
       };
+      const selectAvailable = (tests) => {
+        const availableTests = tests.filter((t) => !assignedTestIds.has(t.id));
+        setSelectedTests(new Set(availableTests.map((t) => t.id)));
+      };
+      const selectFileTests = (fileTests) => {
+        const available = fileTests.filter((t) => !assignedTestIds.has(t.id));
+        const newSelected = new Set(selectedTests);
+        const allSelected = available.every((t) => newSelected.has(t.id));
+        if (allSelected) {
+          for (const test of available) {
+            newSelected.delete(test.id);
+          }
+        } else {
+          for (const test of available) {
+            newSelected.add(test.id);
+          }
+        }
+        setSelectedTests(newSelected);
+      };
       useInput3((input, key) => {
-        if (allTests.length === 0 && !isLoading) {
+        if (allTests.length === 0 && !isLoading && !isLoadingAssignments) {
           if (key.escape || input === "q") {
             onCancel();
           }
           return;
         }
+        if (input === "f") {
+          setGroupByFile((prev) => !prev);
+          setCursorIndex(0);
+          return;
+        }
+        if (input === "t") {
+          setShowAvailableOnly((prev) => !prev);
+          setCursorIndex(0);
+          return;
+        }
         if (key.upArrow) {
           setCursorIndex((prev) => prev > 0 ? prev - 1 : totalItems - 1);
         } else if (key.downArrow) {
           const newIndex = cursorIndex < totalItems - 1 ? cursorIndex + 1 : 0;
           setCursorIndex(newIndex);
-          if (newIndex >= allTests.length - 2 && hasMore && !isLoading) {
+          if (!groupByFile && newIndex >= allTests.length - 2 && hasMore && !isLoading) {
             loadMoreTests();
           }
         } else if (input === " ") {
-          if (isOnFixAll) {
-            selectAll();
+          if (isOnFixNext10) {
+            const availableTests = getFilteredTests();
+            const next10 = availableTests.slice(0, Math.min(10, availableTests.length));
+            selectAvailable(next10);
+          } else if (groupByFile) {
+            const fileGroups2 = getTestsByFile();
+            const fileIndex = cursorIndex - 1;
+            if (fileGroups2[fileIndex]) {
+              selectFileTests(fileGroups2[fileIndex].tests);
+            }
           } else {
             const testIndex = cursorIndex - 1;
-            if (allTests[testIndex]) {
-              toggleTest(allTests[testIndex].id);
+            const filteredTests2 = getFilteredTests();
+            if (filteredTests2[testIndex]) {
+              const test = filteredTests2[testIndex];
+              if (!assignedTestIds.has(test.id)) {
+                toggleTest(test.id);
+              }
             }
           }
-        } else if (input === "a") {
-          selectAll();
         } else if (input === "n") {
           selectNone();
+        } else if (input === "s") {
+          const availableTests = getFilteredTests();
+          const next10 = availableTests.slice(0, Math.min(10, availableTests.length));
+          selectAvailable(next10);
         } else if (key.return) {
-          if (isOnFixAll) {
-            onSelect(allTests);
+          const availableTests = getFilteredTests();
+          if (isOnFixNext10) {
+            const next10 = availableTests.slice(0, Math.min(10, availableTests.length));
+            onSelect(next10);
           } else if (selectedTests.size > 0) {
-            const testsToFix = allTests.filter((t) => selectedTests.has(t.id));
+            const testsToFix = availableTests.filter((t) => selectedTests.has(t.id));
             onSelect(testsToFix);
-          } else {
+          } else if (!groupByFile) {
             const testIndex = cursorIndex - 1;
-            if (allTests[testIndex]) {
-              onSelect([allTests[testIndex]]);
+            if (availableTests[testIndex] && !assignedTestIds.has(availableTests[testIndex].id)) {
+              onSelect([availableTests[testIndex]]);
             }
           }
         } else if (key.escape || input === "q") {
@@ -11124,44 +12442,66 @@ var init_TestSelector = __esm({
         return /* @__PURE__ */ React21.createElement(Box18, { borderColor: "green", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React21.createElement(Text16, { bold: true, color: "green" }, "No Failed Tests"), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, "All tests passed in this run. Nothing to fix!"), /* @__PURE__ */ React21.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, "Press ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "ESC"), " to go back")));
       }
       const testStartIndex = Math.max(0, cursorIndex - 1);
-      const adjustedStart = isOnFixAll ? 0 : Math.max(0, testStartIndex - Math.floor(VISIBLE_ITEMS2 / 2));
-      const adjustedEnd = Math.min(allTests.length, adjustedStart + VISIBLE_ITEMS2);
-      const visibleTests = allTests.slice(adjustedStart, adjustedEnd);
+      const adjustedStart = isOnFixNext10 ? 0 : Math.max(0, testStartIndex - Math.floor(VISIBLE_ITEMS2 / 2));
+      const adjustedEnd = Math.min(filteredTests.length, adjustedStart + VISIBLE_ITEMS2);
+      const visibleTests = filteredTests.slice(adjustedStart, adjustedEnd);
       const branch = run.git?.branch || "unknown";
       const commit = run.git?.commit?.slice(0, 7) || "";
-      return /* @__PURE__ */ React21.createElement(Box18, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { bold: true, color: "cyan" }, "Run: ", branch, commit && /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " @ ", commit), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: "red" }, allTests.length, " failed test", allTests.length !== 1 ? "s" : ""))), /* @__PURE__ */ React21.createElement(Box18, { flexDirection: "column" }, /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(
+      return /* @__PURE__ */ React21.createElement(Box18, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { bold: true, color: "cyan" }, "Run: ", branch, commit && /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " @ ", commit), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: "red" }, allTests.length, " failed"), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: "green" }, availableCount, " avail"), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: "yellow" }, assignedCount, " working"))), /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, "[", showAvailableOnly ? "x" : " ", "] ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "t"), " avail only", "  ", "[", groupByFile ? "x" : " ", "] ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "f"), " group files")), /* @__PURE__ */ React21.createElement(Box18, { flexDirection: "column" }, /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(
         Text16,
         {
-          backgroundColor: isOnFixAll ? theme.text.accent : void 0,
-          bold: isOnFixAll,
-          color: isOnFixAll ? "black" : theme.text.primary
+          backgroundColor: isOnFixNext10 ? theme.text.accent : void 0,
+          bold: isOnFixNext10,
+          color: isOnFixNext10 ? "black" : theme.text.primary
         },
-        isOnFixAll ? "\u25B6 " : "  ",
-        "[Fix All ",
-        allTests.length,
-        " Failed Test",
-        allTests.length !== 1 ? "s" : "",
+        isOnFixNext10 ? "\u25B6 " : "  ",
+        "[Fix Next 10 Available Test",
+        Math.min(10, filteredTests.length) !== 1 ? "s" : "",
         "]"
-      )), /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), visibleTests.map((test, index) => {
-        const actualIndex = adjustedStart + index;
-        const itemIndex = actualIndex + 1;
-        const isSelected = itemIndex === cursorIndex;
-        const isChecked = selectedTests.has(test.id);
-        const checkbox = isChecked ? "[x]" : "[ ]";
-        const file = test.file.split("/").pop() || test.file;
-        const line = test.location?.line || "";
-        const title = test.title;
-        const indicator = isSelected ? "\u25B6 " : "  ";
-        const bgColor = isSelected ? theme.text.accent : void 0;
-        return /* @__PURE__ */ React21.createElement(Box18, { key: test.id, marginBottom: 0 }, /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, indicator), /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, color: isChecked ? "green" : isSelected ? "black" : theme.text.dim }, checkbox), /* @__PURE__ */ React21.createElement(Text16, null, " "), /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, file, line && /* @__PURE__ */ React21.createElement(Text16, { color: isSelected ? "black" : theme.text.dim }, ":", line), /* @__PURE__ */ React21.createElement(Text16, { color: isSelected ? "black" : theme.text.dim }, " - "), title));
-      })), /* @__PURE__ */ React21.createElement(Box18, { flexDirection: "column", marginTop: 1 }, allTests.length > VISIBLE_ITEMS2 && /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: "yellow" }, "Showing ", adjustedStart + 1, "-", adjustedEnd, " of ", totalTests || allTests.length, " failed tests", hasMore && !isLoading && /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 Scroll for more"))), /* @__PURE__ */ React21.createElement(Box18, null, /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "\u2191\u2193"), " navigate \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "Space"), " toggle \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "a"), " all \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "n"), " none \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "Enter"), " fix selected")), selectedTests.size > 0 && /* @__PURE__ */ React21.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: "green" }, selectedTests.size, " test", selectedTests.size !== 1 ? "s" : "", " selected")), isLoading && /* @__PURE__ */ React21.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: "cyan" }, "Loading more tests..."))));
+      )), /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), groupByFile ? (
+        // File Grouping Mode
+        fileGroups.map((group, index) => {
+          const itemIndex = index + 1;
+          const isSelected = itemIndex === cursorIndex;
+          const bgColor = isSelected ? theme.text.accent : void 0;
+          const indicator = isSelected ? "\u25B6 " : "  ";
+          const fileName = group.file.split("/").pop() || group.file;
+          const allSelected = group.availableCount > 0 && group.tests.filter((t) => !assignedTestIds.has(t.id)).every((t) => selectedTests.has(t.id));
+          const someSelected = group.tests.filter((t) => !assignedTestIds.has(t.id)).some((t) => selectedTests.has(t.id));
+          return /* @__PURE__ */ React21.createElement(Box18, { flexDirection: "column", key: group.file, marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Box18, null, /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, indicator), /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, color: allSelected ? "green" : someSelected ? "yellow" : isSelected ? "black" : theme.text.dim }, "[", allSelected ? "\u2713" : someSelected ? "\u2297" : " ", "]"), /* @__PURE__ */ React21.createElement(Text16, null, " "), /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, fileName), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: "green" }, group.availableCount, " available"), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: "yellow" }, group.assignedCount, " working"), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, group.tests.length, " total")), isSelected && group.tests.length <= 5 && /* @__PURE__ */ React21.createElement(Box18, { marginLeft: 2 }, group.tests.map((test) => {
+            const line = test.location?.line || "";
+            const title = test.title;
+            const isAssigned = assignedTestIds.has(test.id);
+            return /* @__PURE__ */ React21.createElement(Box18, { key: test.id }, /* @__PURE__ */ React21.createElement(Text16, { color: isAssigned ? theme.text.dim : theme.text.primary }, isAssigned ? "\u{1F504} " : "  ", line && /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, line, ": "), title));
+          })));
+        })
+      ) : (
+        // Individual Tests Mode
+        visibleTests.map((test, index) => {
+          const actualIndex = adjustedStart + index;
+          const itemIndex = actualIndex + 1;
+          const isSelected = itemIndex === cursorIndex;
+          const isChecked = selectedTests.has(test.id);
+          const isAssigned = assignedTestIds.has(test.id);
+          const assignment = assignedTestMap.get(test.id);
+          const checkbox = isChecked ? "[x]" : "[ ]";
+          const file = test.file.split("/").pop() || test.file;
+          const line = test.location?.line || "";
+          const title = test.title;
+          const indicator = isSelected ? "\u25B6 " : "  ";
+          const bgColor = isSelected ? theme.text.accent : void 0;
+          const assignee = assignment?.assignedTo || "";
+          const displayAssignee = assignee.startsWith("cli:") ? assignee.slice(4) : assignee;
+          return /* @__PURE__ */ React21.createElement(Box18, { key: test.id, marginBottom: 0 }, /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : isAssigned ? theme.text.dim : theme.text.primary }, indicator), /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, color: isAssigned ? theme.text.dim : isChecked ? "green" : isSelected ? "black" : theme.text.dim }, isAssigned ? "\u{1F504}" : checkbox), /* @__PURE__ */ React21.createElement(Text16, null, " "), /* @__PURE__ */ React21.createElement(Text16, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : isAssigned ? theme.text.dim : theme.text.primary }, file, line && /* @__PURE__ */ React21.createElement(Text16, { color: isSelected ? "black" : theme.text.dim }, ":", line), isAssigned && /* @__PURE__ */ React21.createElement(React21.Fragment, null, /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " \u2022 "), /* @__PURE__ */ React21.createElement(Text16, { color: "yellow" }, displayAssignee)), /* @__PURE__ */ React21.createElement(Text16, { color: isSelected ? "black" : theme.text.dim }, " - "), title));
+        })
+      )), /* @__PURE__ */ React21.createElement(Box18, { flexDirection: "column", marginTop: 1 }, !groupByFile && filteredTests.length > VISIBLE_ITEMS2 && /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: "yellow" }, "Showing ", adjustedStart + 1, "-", adjustedEnd, " of ", filteredTests.length, " ", showAvailableOnly ? "available" : "", " tests", hasMore && !isLoading && /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, " (scroll for more)"))), groupByFile && /* @__PURE__ */ React21.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: "yellow" }, "Showing ", fileGroups.length, " file", fileGroups.length !== 1 ? "s" : "", " \u2022 ", filteredTests.length, " total test", filteredTests.length !== 1 ? "s" : "")), /* @__PURE__ */ React21.createElement(Box18, null, /* @__PURE__ */ React21.createElement(Text16, { color: theme.text.dim }, /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "\u2191\u2193"), " navigate \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "Space"), " toggle \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "n"), " none \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "s"), " next 10 \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "f"), " group files \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "t"), " toggle filter \u2022 ", /* @__PURE__ */ React21.createElement(Text16, { bold: true }, "Enter"), " fix selected")), selectedTests.size > 0 && /* @__PURE__ */ React21.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: "green" }, selectedTests.size, " test", selectedTests.size !== 1 ? "s" : "", " selected")), (isLoading || isLoadingAssignments) && /* @__PURE__ */ React21.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text16, { color: "cyan" }, isLoading ? "Loading more tests..." : "Loading assignments..."))));
     };
   }
 });
 
 // src/ui/components/FixFlow.tsx
 import { Box as Box19, Text as Text17, useInput as useInput4 } from "ink";
-import React22, { useState as useState8 } from "react";
+import React22, { useEffect as useEffect8, useState as useState8 } from "react";
 var FixFlow;
 var init_FixFlow = __esm({
   "src/ui/components/FixFlow.tsx"() {
@@ -11180,6 +12520,8 @@ var init_FixFlow = __esm({
       const [step, setStep] = useState8(initialRunId ? "select-run" : "select-run");
       const [selectedRun, setSelectedRun] = useState8(null);
       const [selectedTests, setSelectedTests] = useState8([]);
+      const [assignments, setAssignments] = useState8([]);
+      const [assignmentIds, setAssignmentIds] = useState8(/* @__PURE__ */ new Map());
       const [loadingProgress, setLoadingProgress] = useState8({ current: 0, total: 0 });
       const [loadError, setLoadError] = useState8(null);
       useInput4((input, key) => {
@@ -11189,7 +12531,7 @@ var init_FixFlow = __esm({
             setStep("select-run");
           } else if (step === "select-run") {
             onCancel();
-          } else if (step === "loading-details" && loadError) {
+          } else if ((step === "loading-details" || step === "claiming-tests" || step === "error") && loadError) {
             setLoadError(null);
             setStep("select-tests");
           }
@@ -11198,13 +12540,47 @@ var init_FixFlow = __esm({
       const handleRunSelect = (run) => {
         setSelectedRun(run);
         setStep("select-tests");
+        fetchAssignments(run.id);
+      };
+      const fetchAssignments = async (runId) => {
+        try {
+          const result = await apiClient.getRunAssignments(runId);
+          setAssignments(result.assignments);
+        } catch (err) {
+          console.error("Failed to load assignments:", err);
+        }
       };
       const handleTestsSelect = async (tests) => {
         setSelectedTests(tests);
-        setStep("loading-details");
-        setLoadingProgress({ current: 0, total: tests.length });
+        setStep("claiming-tests");
         setLoadError(null);
         try {
+          if (selectedRun) {
+            const claimResult = await apiClient.assignTests({
+              runId: selectedRun.id,
+              testRunIds: tests.map((t) => t.id)
+            });
+            if (claimResult.conflicts.length > 0) {
+              const conflictList = claimResult.conflicts.slice(0, 5).map((c) => `${c.file}: ${c.title} (claimed by ${c.currentAssignee})`).join("\n\u2022 ");
+              const moreCount = claimResult.conflicts.length - 5;
+              setLoadError(
+                `${claimResult.conflicts.length} test${claimResult.conflicts.length > 1 ? "s were" : " was"} already claimed by others:
+\u2022 ${conflictList}${moreCount > 0 ? `
+\u2022 ... and ${moreCount} more` : ""}
+
+Please select different tests.`
+              );
+              setStep("error");
+              return;
+            }
+            const assignmentMap = /* @__PURE__ */ new Map();
+            claimResult.assigned.forEach((assignment) => {
+              assignmentMap.set(assignment.testRunId, assignment.id);
+            });
+            setAssignmentIds(assignmentMap);
+          }
+          setStep("loading-details");
+          setLoadingProgress({ current: 0, total: tests.length });
           const testDetails = [];
           const batchSize = 5;
           for (let i = 0; i < tests.length; i += batchSize) {
@@ -11220,7 +12596,25 @@ var init_FixFlow = __esm({
           setStep("fixing");
           onStartFix(prompt, tests);
         } catch (err) {
-          setLoadError(err instanceof Error ? err.message : String(err));
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          if (errorMessage.includes("network") || errorMessage.includes("fetch")) {
+            setLoadError(`Network error: Unable to connect to the server.
+
+Please check your internet connection and try again.
+
+Error: ${errorMessage}`);
+          } else if (errorMessage.includes("auth") || errorMessage.includes("unauthorized")) {
+            setLoadError(`Authentication error: Please run 'supatest auth' to log in.
+
+Error: ${errorMessage}`);
+          } else {
+            setLoadError(`Failed to load test details:
+
+${errorMessage}
+
+Press ESC to go back and try again.`);
+          }
+          setStep("error");
         }
       };
       const handleRunCancel = () => {
@@ -11228,8 +12622,47 @@ var init_FixFlow = __esm({
       };
       const handleTestCancel = () => {
         setSelectedRun(null);
+        setAssignments([]);
         setStep("select-run");
       };
+      const markAssignmentsComplete = async (fixSessionId) => {
+        if (assignmentIds.size === 0) {
+          return;
+        }
+        try {
+          await Promise.all(
+            Array.from(assignmentIds.values()).map(
+              (assignmentId) => apiClient.completeAssignment({
+                assignmentId,
+                status: "completed",
+                fixSessionId
+              })
+            )
+          );
+        } catch (err) {
+          console.error("Failed to mark assignments as complete:", err);
+        }
+      };
+      const releaseAssignments = async () => {
+        if (assignmentIds.size === 0) {
+          return;
+        }
+        try {
+          await Promise.all(
+            Array.from(assignmentIds.values()).map(
+              (assignmentId) => apiClient.releaseAssignment(assignmentId)
+            )
+          );
+          setAssignmentIds(/* @__PURE__ */ new Map());
+        } catch (err) {
+          console.error("Failed to release assignments:", err);
+        }
+      };
+      useEffect8(() => {
+        if (step === "complete") {
+          markAssignmentsComplete();
+        }
+      }, [step]);
       switch (step) {
         case "select-run":
           return /* @__PURE__ */ React22.createElement(
@@ -11249,20 +12682,25 @@ var init_FixFlow = __esm({
             TestSelector,
             {
               apiClient,
+              assignments,
               onCancel: handleTestCancel,
               onSelect: handleTestsSelect,
               run: selectedRun
             }
           );
+        case "claiming-tests":
+          return /* @__PURE__ */ React22.createElement(Box19, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text17, { bold: true, color: "cyan" }, "Claiming Tests..."), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "Assigning ", selectedTests.length, " test", selectedTests.length !== 1 ? "s" : "", " to you...")));
         case "loading-details":
           if (loadError) {
             return /* @__PURE__ */ React22.createElement(Box19, { borderColor: "red", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text17, { bold: true, color: "red" }, "Error Loading Test Details"), /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, loadError), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "Press ", /* @__PURE__ */ React22.createElement(Text17, { bold: true }, "ESC"), " to go back")));
           }
           return /* @__PURE__ */ React22.createElement(Box19, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text17, { bold: true, color: "cyan" }, "Loading Test Details..."), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "Fetching error messages, stack traces, and execution steps...")), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: "yellow" }, loadingProgress.current, " / ", loadingProgress.total, " tests loaded")));
+        case "error":
+          return /* @__PURE__ */ React22.createElement(Box19, { borderColor: "red", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text17, { bold: true, color: "red" }, "Error"), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, loadError)), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "Press ", /* @__PURE__ */ React22.createElement(Text17, { bold: true }, "ESC"), " to go back")));
         case "fixing":
           return /* @__PURE__ */ React22.createElement(Box19, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text17, { bold: true, color: "cyan" }, "Fixing ", selectedTests.length, " Test", selectedTests.length !== 1 ? "s" : "", "..."), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, selectedTests.map((test, index) => /* @__PURE__ */ React22.createElement(Box19, { key: test.id }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, index + 1, ". ", test.file.split("/").pop(), ":", test.location?.line || "", " - ", test.title)))), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "The agent will now analyze and fix each test...")));
         case "complete":
-          return /* @__PURE__ */ React22.createElement(Box19, { borderColor: "green", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text17, { bold: true, color: "green" }, "Fix Complete"), /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "Press any key to continue..."));
+          return /* @__PURE__ */ React22.createElement(Box19, { borderColor: "green", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text17, { bold: true, color: "green" }, "Tests Marked as Complete"), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "\u2713 ", selectedTests.length, " test", selectedTests.length !== 1 ? "s have" : " has", " been marked as fixed")), /* @__PURE__ */ React22.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text17, { color: theme.text.dim }, "Press any key to continue...")));
         default:
           return null;
       }
@@ -11270,91 +12708,144 @@ var init_FixFlow = __esm({
   }
 });
 
-// src/ui/utils/file-completion.ts
-import fs4 from "fs";
+// src/ui/utils/file-search.ts
 import path4 from "path";
-function shouldIgnore(name, isDir) {
-  if (name.startsWith(".")) return true;
-  if (isDir) return IGNORED_DIRS.has(name);
-  const ext = path4.extname(name).toLowerCase();
-  return IGNORED_EXTENSIONS.has(ext);
-}
-function getFiles(rootDir = process.cwd(), maxDepth = 3) {
-  const files = [];
-  function scan(dir, depth) {
-    if (depth > maxDepth) return;
-    try {
-      const entries = fs4.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (shouldIgnore(entry.name, entry.isDirectory())) continue;
-        const fullPath = path4.join(dir, entry.name);
-        const relativePath = path4.relative(rootDir, fullPath);
-        if (entry.isDirectory()) {
-          scan(fullPath, depth + 1);
-        } else {
-          files.push(relativePath);
-        }
-      }
-    } catch (error) {
+import { glob } from "glob";
+function fuzzyMatch(text, query2) {
+  const textLower = text.toLowerCase();
+  const queryLower = query2.toLowerCase();
+  if (!queryLower) return 1;
+  let queryIdx = 0;
+  let score = 0;
+  let consecutiveMatches = 0;
+  for (let i = 0; i < textLower.length && queryIdx < queryLower.length; i++) {
+    if (textLower[i] === queryLower[queryIdx]) {
+      queryIdx++;
+      score += 1 + consecutiveMatches * 0.5;
+      consecutiveMatches++;
+    } else {
+      consecutiveMatches = 0;
     }
   }
-  scan(rootDir, 0);
-  return files;
+  if (queryIdx < queryLower.length) {
+    return 0;
+  }
+  const segments = textLower.split(path4.sep);
+  for (const segment of segments) {
+    if (segment.startsWith(queryLower[0])) {
+      score += 0.5;
+    }
+  }
+  if (textLower === queryLower) {
+    score += 2;
+  }
+  return score;
+}
+async function searchFiles(query2, options = {}) {
+  const { signal, maxResults = 20, maxDepth = 5, cwd = process.cwd() } = options;
+  const pattern = "**/*";
+  const files = await glob(pattern, {
+    cwd,
+    dot: false,
+    // Don't include dotfiles by default
+    signal,
+    nodir: true,
+    maxDepth,
+    absolute: false
+  });
+  const safeFiles = files || [];
+  if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+  if (!query2) {
+    return safeFiles.slice(0, maxResults);
+  }
+  const results = [];
+  for (const file of safeFiles) {
+    const score = fuzzyMatch(file, query2);
+    if (score > 0) {
+      results.push({ file, score });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, maxResults).map((r) => r.file);
 }
-var IGNORED_DIRS, IGNORED_EXTENSIONS;
-var init_file_completion = __esm({
-  "src/ui/utils/file-completion.ts"() {
+var init_file_search = __esm({
+  "src/ui/utils/file-search.ts"() {
     "use strict";
-    IGNORED_DIRS = /* @__PURE__ */ new Set([
-      "node_modules",
-      ".git",
-      ".turbo",
-      "dist",
-      "build",
-      "coverage",
-      ".next",
-      ".cache"
-    ]);
-    IGNORED_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".png",
-      ".jpg",
-      ".jpeg",
-      ".gif",
-      ".ico",
-      ".svg",
-      ".woff",
-      ".woff2",
-      ".ttf",
-      ".eot",
-      ".mp4",
-      ".webm",
-      ".mp3",
-      ".wav",
-      ".zip",
-      ".tar",
-      ".gz",
-      ".7z",
-      ".rar",
-      ".pdf",
-      ".doc",
-      ".docx",
-      ".xls",
-      ".xlsx",
-      ".exe",
-      ".dll",
-      ".so",
-      ".dylib",
-      ".bin",
-      ".map",
-      ".lock",
-      ".tsbuildinfo"
-    ]);
+  }
+});
+
+// src/ui/hooks/useFileCompletion.ts
+import { useEffect as useEffect9, useRef as useRef6, useState as useState9 } from "react";
+function useFileCompletion(enabled, query2, cwd, maxResults = 20) {
+  const [suggestions, setSuggestions] = useState9([]);
+  const [isLoading, setIsLoading] = useState9(false);
+  const abortControllerRef = useRef6(null);
+  const debounceTimerRef = useRef6(null);
+  const loadingTimerRef = useRef6(null);
+  useEffect9(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+    }
+    if (loadingTimerRef.current) {
+      clearTimeout(loadingTimerRef.current);
+    }
+    if (!enabled || !query2 || query2.length === 0) {
+      setSuggestions([]);
+      setIsLoading(false);
+      return;
+    }
+    loadingTimerRef.current = setTimeout(() => {
+      setIsLoading(true);
+    }, 200);
+    debounceTimerRef.current = setTimeout(async () => {
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      try {
+        const results = await searchFiles(query2, {
+          signal: controller.signal,
+          maxResults,
+          cwd
+        });
+        if (!controller.signal.aborted) {
+          setSuggestions(Array.isArray(results) ? results : []);
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name !== "AbortError") {
+          console.error("File search failed:", error);
+        }
+        setSuggestions([]);
+      } finally {
+        if (loadingTimerRef.current) {
+          clearTimeout(loadingTimerRef.current);
+        }
+        setIsLoading(false);
+      }
+    }, 150);
+    return () => {
+      abortControllerRef.current?.abort();
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+      if (loadingTimerRef.current) {
+        clearTimeout(loadingTimerRef.current);
+      }
+    };
+  }, [enabled, query2, cwd, maxResults]);
+  return { suggestions, isLoading };
+}
+var init_useFileCompletion = __esm({
+  "src/ui/hooks/useFileCompletion.ts"() {
+    "use strict";
+    init_file_search();
   }
 });
 
 // src/ui/components/ModelSelector.tsx
 import { Box as Box20, Text as Text18, useInput as useInput5 } from "ink";
-import React23, { useState as useState9 } from "react";
+import React23, { useState as useState10 } from "react";
 function getAvailableModels(isClaudeMax) {
   if (isClaudeMax) {
     return AVAILABLE_MODELS.map((m) => ({
@@ -11389,7 +12880,7 @@ var init_ModelSelector = __esm({
     }) => {
       const models = getAvailableModels(isClaudeMax);
       const currentIndex = models.findIndex((m) => m.id === currentModel);
-      const [selectedIndex, setSelectedIndex] = useState9(currentIndex >= 0 ? currentIndex : 0);
+      const [selectedIndex, setSelectedIndex] = useState10(currentIndex >= 0 ? currentIndex : 0);
       useInput5((input, key) => {
         if (key.upArrow) {
           setSelectedIndex((prev) => prev > 0 ? prev - 1 : models.length - 1);
@@ -11431,7 +12922,7 @@ var init_ModelSelector = __esm({
 import path5 from "path";
 import chalk4 from "chalk";
 import { Box as Box21, Text as Text19 } from "ink";
-import React24, { forwardRef, memo as memo3, useEffect as useEffect9, useImperativeHandle, useState as useState10 } from "react";
+import React24, { forwardRef, memo as memo3, useEffect as useEffect10, useImperativeHandle, useState as useState11 } from "react";
 var InputPromptInner, InputPrompt;
 var init_InputPrompt = __esm({
   "src/ui/components/InputPrompt.tsx"() {
@@ -11439,13 +12930,13 @@ var init_InputPrompt = __esm({
     init_shared_es();
     init_command_discovery();
     init_SessionContext();
+    init_useFileCompletion();
     init_useKeypress();
-    init_file_completion();
     init_theme();
     init_ModelSelector();
     InputPromptInner = forwardRef(({
       onSubmit,
-      placeholder = "Enter your task (press Enter to submit, Shift+Enter for new line)...",
+      placeholder = "Enter your task... (Ctrl+W=del word, Alt+\u2190/\u2192=word nav, Ctrl+U/K=clear)",
       disabled = false,
       onHelpToggle,
       cwd,
@@ -11454,14 +12945,40 @@ var init_InputPrompt = __esm({
       onInputChange,
       isClaudeMax = false
     }, ref) => {
-      const { agentMode, selectedModel, setSelectedModel, isAgentRunning, usageStats } = useSession();
-      const [value, setValue] = useState10("");
-      const [cursorOffset, setCursorOffset] = useState10(0);
-      const [allFiles, setAllFiles] = useState10([]);
-      const [suggestions, setSuggestions] = useState10([]);
-      const [activeSuggestion, setActiveSuggestion] = useState10(0);
-      const [showSuggestions, setShowSuggestions] = useState10(false);
-      const [mentionStartIndex, setMentionStartIndex] = useState10(-1);
+      const { agentMode, selectedModel, setSelectedModel, isAgentRunning } = useSession();
+      const { usageStats } = useUsageStats();
+      const [value, setValue] = useState11("");
+      const [cursorPos, setCursorPos] = useState11([0, 0]);
+      const getCursorOffset = () => {
+        const lines2 = value.split("\n");
+        let offset = 0;
+        for (let i = 0; i < cursorPos[0]; i++) {
+          offset += lines2[i]?.length ?? 0;
+          offset += 1;
+        }
+        offset += cursorPos[1];
+        return offset;
+      };
+      const offsetToCursorPos = (offset, text) => {
+        const lines2 = text.split("\n");
+        let currentOffset = 0;
+        for (let i = 0; i < lines2.length; i++) {
+          const lineLength = lines2[i]?.length ?? 0;
+          if (currentOffset + lineLength >= offset) {
+            return [i, offset - currentOffset];
+          }
+          currentOffset += lineLength + 1;
+        }
+        return [lines2.length - 1, lines2[lines2.length - 1]?.length ?? 0];
+      };
+      const setCursorFromOffset = (offset, text) => {
+        setCursorPos(offsetToCursorPos(offset, text ?? value));
+      };
+      const [suggestions, setSuggestions] = useState11([]);
+      const [activeSuggestion, setActiveSuggestion] = useState11(0);
+      const [showSuggestions, setShowSuggestions] = useState11(false);
+      const [mentionStartIndex, setMentionStartIndex] = useState11(null);
+      const [mentionQuery, setMentionQuery] = useState11("");
       const BUILTIN_SLASH_COMMANDS = [
         { name: "/help", desc: "Show help" },
         { name: "/resume", desc: "Resume session" },
@@ -11477,9 +12994,9 @@ var init_InputPrompt = __esm({
         { name: "/logout", desc: "Log out" },
         { name: "/exit", desc: "Exit CLI" }
       ];
-      const [customCommands, setCustomCommands] = useState10([]);
-      const [isSlashCommand, setIsSlashCommand] = useState10(false);
-      useEffect9(() => {
+      const [customCommands, setCustomCommands] = useState11([]);
+      const [isSlashCommand, setIsSlashCommand] = useState11(false);
+      useEffect10(() => {
         try {
           const projectDir = cwd || process.cwd();
           const discovered = discoverCommands(projectDir);
@@ -11495,29 +13012,55 @@ var init_InputPrompt = __esm({
       useImperativeHandle(ref, () => ({
         clear: () => {
           setValue("");
-          setCursorOffset(0);
+          setCursorPos([0, 0]);
           setShowSuggestions(false);
           onInputChange?.("");
         }
       }));
-      useEffect9(() => {
-        setTimeout(() => {
-          try {
-            const files = getFiles();
-            setAllFiles(files);
-          } catch (e) {
-          }
-        }, 100);
-      }, []);
+      const { suggestions: fileSuggestions, isLoading: isLoadingFiles } = useFileCompletion(
+        showSuggestions && !isSlashCommand && mentionQuery.length > 0,
+        mentionQuery,
+        cwd || process.cwd(),
+        20
+        // maxResults
+      );
+      useEffect10(() => {
+        if (!isSlashCommand && showSuggestions) {
+          setSuggestions(fileSuggestions);
+        }
+      }, [fileSuggestions, isSlashCommand, showSuggestions]);
       const updateValue = (newValue, newCursor) => {
         setValue(newValue);
-        setCursorOffset(newCursor);
+        if (typeof newCursor === "number") {
+          setCursorFromOffset(newCursor, newValue);
+        } else {
+          setCursorPos(newCursor);
+        }
+        const newOffset = typeof newCursor === "number" ? newCursor : (() => {
+          const lines2 = newValue.split("\n");
+          let offset = 0;
+          for (let i = 0; i < newCursor[0]; i++) {
+            offset += lines2[i]?.length ?? 0;
+            offset += 1;
+          }
+          offset += newCursor[1];
+          return offset;
+        })();
         checkSuggestions(newValue, newCursor);
         onInputChange?.(newValue);
       };
       const checkSuggestions = (text, cursor) => {
-        if (text.startsWith("/") && cursor <= text.length && !text.includes(" ", 1)) {
-          const query2 = text.slice(1);
+        let cursorRow;
+        let cursorCol2;
+        if (typeof cursor === "number") {
+          [cursorRow, cursorCol2] = offsetToCursorPos(cursor, text);
+        } else {
+          [cursorRow, cursorCol2] = cursor;
+        }
+        const lines2 = text.split("\n");
+        const currentLine = lines2[cursorRow] || "";
+        if (cursorRow === 0 && text.startsWith("/") && cursorCol2 <= currentLine.length && !currentLine.includes(" ", 1)) {
+          const query2 = currentLine.slice(1);
           const builtinMatches = BUILTIN_SLASH_COMMANDS.filter((cmd) => cmd.name.slice(1).toLowerCase().startsWith(query2.toLowerCase())).map((cmd) => cmd.desc ? `${cmd.name}  ${cmd.desc}` : cmd.name);
           const customMatches = customCommands.filter((cmd) => cmd.name.slice(1).toLowerCase().startsWith(query2.toLowerCase())).map((cmd) => cmd.desc ? `${cmd.name}  ${cmd.desc}` : cmd.name);
           const matches = [];
@@ -11539,25 +13082,26 @@ var init_InputPrompt = __esm({
           }
         }
         setIsSlashCommand(false);
-        const textBeforeCursor = text.slice(0, cursor);
-        const lastAt = textBeforeCursor.lastIndexOf("@");
-        if (lastAt !== -1) {
-          const isValidStart = lastAt === 0 || /\s/.test(textBeforeCursor[lastAt - 1]);
-          if (isValidStart) {
-            const query2 = textBeforeCursor.slice(lastAt + 1);
-            if (!/\s/.test(query2)) {
-              const matches = allFiles.filter((f) => f.toLowerCase().includes(query2.toLowerCase())).slice(0, 5);
-              if (matches.length > 0) {
-                setSuggestions(matches);
-                setShowSuggestions(true);
-                setActiveSuggestion(0);
-                setMentionStartIndex(lastAt);
-                return;
-              }
-            }
+        let foundMention = false;
+        for (let i = cursorCol2 - 1; i >= 0; i--) {
+          const char = currentLine[i];
+          if (char === " ") {
+            break;
+          }
+          if (char === "@") {
+            const query2 = currentLine.slice(i + 1, cursorCol2);
+            setMentionQuery(query2);
+            setShowSuggestions(true);
+            setActiveSuggestion(0);
+            setMentionStartIndex({ row: cursorRow, col: i });
+            foundMention = true;
+            break;
           }
         }
-        setShowSuggestions(false);
+        if (!foundMention) {
+          setMentionQuery("");
+          setShowSuggestions(false);
+        }
       };
       const completeSuggestion = (submit = false) => {
         if (!showSuggestions || suggestions.length === 0) return;
@@ -11566,27 +13110,35 @@ var init_InputPrompt = __esm({
           if (submit) {
             onSubmit(selectedCmd);
             setValue("");
-            setCursorOffset(0);
+            setCursorPos([0, 0]);
             setShowSuggestions(false);
             onInputChange?.("");
             return;
           }
-          updateValue(selectedCmd, selectedCmd.length);
+          updateValue(selectedCmd, [0, selectedCmd.length]);
           setShowSuggestions(false);
           return;
         }
         const selectedFile = suggestions[activeSuggestion];
-        const textBeforeMention = value.slice(0, mentionStartIndex);
-        const textAfterCursor = value.slice(cursorOffset);
-        const newValue = textBeforeMention + "@" + selectedFile + " " + textAfterCursor;
-        const newCursor = mentionStartIndex + 1 + selectedFile.length + 1;
-        updateValue(newValue, newCursor);
+        const mentionStart = mentionStartIndex;
+        const [currentRow, currentCol] = cursorPos;
+        if (!mentionStart) return;
+        const lines2 = value.split("\n");
+        const beforeMention = lines2[mentionStart.row].slice(0, mentionStart.col);
+        const afterCursor = lines2[mentionStart.row].slice(currentCol);
+        const newLine = beforeMention + "@" + selectedFile + " " + afterCursor;
+        const newLines = [...lines2];
+        newLines[mentionStart.row] = newLine;
+        const newCursorCol = mentionStart.col + 1 + selectedFile.length + 1;
+        const newCursorPos = [mentionStart.row, newCursorCol];
+        updateValue(newLines.join("\n"), newCursorPos);
         setShowSuggestions(false);
       };
       useKeypress(
         (key) => {
           if (disabled) return;
           const input = key.sequence;
+          const cursorOffset = getCursorOffset();
           if (input.length > 1 && (input.includes("/") || input.includes("\\"))) {
             let cleanPath = input.trim();
             if (cleanPath.startsWith('"') && cleanPath.endsWith('"') || cleanPath.startsWith("'") && cleanPath.endsWith("'")) {
@@ -11610,7 +13162,7 @@ var init_InputPrompt = __esm({
               return;
             }
           }
-          if (key.shift && key.name === "m" && !isAgentRunning) {
+          if ((key.ctrl || key.meta) && key.shift && key.name === "m" && !isAgentRunning) {
             setSelectedModel(getNextModel(selectedModel, isClaudeMax));
             return;
           }
@@ -11659,7 +13211,7 @@ var init_InputPrompt = __esm({
               if (value.trim()) {
                 onSubmit(value.trim());
                 setValue("");
-                setCursorOffset(0);
+                setCursorPos([0, 0]);
                 setShowSuggestions(false);
                 onInputChange?.("");
               }
@@ -11670,11 +13222,55 @@ var init_InputPrompt = __esm({
               updateValue(newValue, cursorOffset - 1);
             }
           } else if (key.name === "left") {
-            setCursorOffset(Math.max(0, cursorOffset - 1));
+            if (key.meta && !key.shift && !key.ctrl) {
+              const textBefore = value.slice(0, cursorOffset);
+              const match = textBefore.match(/\S+\s*$/);
+              const wordStart = match ? textBefore.length - match[0].length : 0;
+              setCursorFromOffset(wordStart);
+            } else {
+              setCursorFromOffset(Math.max(0, cursorOffset - 1));
+            }
           } else if (key.name === "right") {
-            setCursorOffset(Math.min(value.length, cursorOffset + 1));
-          } else if (key.ctrl && input === "u") {
-            updateValue("", 0);
+            if (key.meta && !key.shift && !key.ctrl) {
+              const textAfter = value.slice(cursorOffset);
+              const match = textAfter.match(/^\s*\S+/);
+              const wordEnd = match ? cursorOffset + match[0].length : value.length;
+              setCursorFromOffset(wordEnd);
+            } else {
+              setCursorFromOffset(Math.min(value.length, cursorOffset + 1));
+            }
+          } else if (key.ctrl && key.name === "u") {
+            const newValue = value.slice(cursorOffset);
+            updateValue(newValue, 0);
+          } else if (key.ctrl && key.name === "k") {
+            const newValue = value.slice(0, cursorOffset);
+            updateValue(newValue, cursorOffset);
+          } else if (key.ctrl && key.name === "w") {
+            const textBefore = value.slice(0, cursorOffset);
+            const match = textBefore.match(/\S+\s*$/);
+            const wordStart = match ? textBefore.length - match[0].length : 0;
+            const newValue = value.slice(0, wordStart) + value.slice(cursorOffset);
+            updateValue(newValue, wordStart);
+          } else if (key.meta && key.name === "backspace") {
+            const textBefore = value.slice(0, cursorOffset);
+            const match = textBefore.match(/\S+\s*$/);
+            const wordStart = match ? textBefore.length - match[0].length : 0;
+            const newValue = value.slice(0, wordStart) + value.slice(cursorOffset);
+            updateValue(newValue, wordStart);
+          } else if (key.meta && key.name === "d") {
+            const textAfter = value.slice(cursorOffset);
+            const match = textAfter.match(/^\s*\S+/);
+            const wordEnd = match ? cursorOffset + match[0].length : value.length;
+            const newValue = value.slice(0, cursorOffset) + value.slice(wordEnd);
+            updateValue(newValue, cursorOffset);
+          } else if (key.ctrl && key.name === "a") {
+            setCursorFromOffset(0);
+          } else if (key.ctrl && key.name === "e") {
+            setCursorFromOffset(value.length);
+          } else if (key.name === "home") {
+            setCursorFromOffset(0);
+          } else if (key.name === "end") {
+            setCursorFromOffset(value.length);
           } else if (key.name === "tab" && !showSuggestions) {
           } else if (key.paste) {
             const newValue = value.slice(0, cursorOffset) + input + value.slice(cursorOffset);
@@ -11688,18 +13284,7 @@ var init_InputPrompt = __esm({
       );
       const lines = value ? value.split("\n") : [];
       const hasContent = value.trim().length > 0;
-      let cursorLine = 0;
-      let cursorCol = cursorOffset;
-      let charCount = 0;
-      for (let i = 0; i < lines.length; i++) {
-        const lineLength = lines[i].length;
-        if (charCount + lineLength >= cursorOffset) {
-          cursorLine = i;
-          cursorCol = cursorOffset - charCount;
-          break;
-        }
-        charCount += lineLength + 1;
-      }
+      const [cursorLine, cursorCol] = cursorPos;
       return /* @__PURE__ */ React24.createElement(Box21, { flexDirection: "column", width: "100%" }, showSuggestions && /* @__PURE__ */ React24.createElement(
         Box21,
         {
@@ -11709,13 +13294,13 @@ var init_InputPrompt = __esm({
           marginBottom: 0,
           paddingX: 1
         },
-        suggestions.map((item, idx) => {
+        isLoadingFiles && !isSlashCommand ? /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, "Searching files...") : suggestions.length > 0 ? suggestions.map((item, idx) => {
           const isSeparator = item.startsWith("\u2500\u2500\u2500\u2500\u2500");
           if (isSeparator) {
             return /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim, key: item }, "  ", item);
           }
           return /* @__PURE__ */ React24.createElement(Text19, { color: idx === activeSuggestion ? theme.text.accent : theme.text.dim, key: item }, idx === activeSuggestion ? "\u276F " : "  ", item);
-        })
+        }) : /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, "No matches")
       ), /* @__PURE__ */ React24.createElement(
         Box21,
         {
@@ -11736,7 +13321,7 @@ var init_InputPrompt = __esm({
           }
           return /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.primary, key: idx }, line);
         })), !hasContent && disabled && /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim, italic: true }, "Waiting for agent to complete...")))
-      ), /* @__PURE__ */ React24.createElement(Box21, { justifyContent: "space-between", paddingX: 1 }, /* @__PURE__ */ React24.createElement(Box21, { gap: 2 }, /* @__PURE__ */ React24.createElement(Box21, null, /* @__PURE__ */ React24.createElement(Text19, { color: agentMode === "plan" ? theme.status.inProgress : theme.text.dim }, agentMode === "plan" ? "\u23F8 plan" : "\u25B6 build"), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, " (shift+tab)")), /* @__PURE__ */ React24.createElement(Box21, null, /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, "model:"), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.info }, getModelDisplayName(selectedModel)), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, " (Cost: "), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.info }, getModelCostLabel(selectedModel)), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, ") (shift+m)"))), /* @__PURE__ */ React24.createElement(Box21, null, /* @__PURE__ */ React24.createElement(Text19, { color: usageStats && usageStats.contextPct >= 90 ? theme.text.error : usageStats && usageStats.contextPct >= 75 ? theme.text.warning : theme.text.dim }, usageStats?.contextPct ?? 0, "% context used"), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, " ", "(", usageStats ? usageStats.inputTokens >= 1e3 ? `${(usageStats.inputTokens / 1e3).toFixed(1)}K` : usageStats.inputTokens : 0, " / ", usageStats ? usageStats.contextWindow >= 1e3 ? `${(usageStats.contextWindow / 1e3).toFixed(0)}K` : usageStats.contextWindow : "200K", ")"))));
+      ), /* @__PURE__ */ React24.createElement(Box21, { justifyContent: "space-between", paddingX: 1 }, /* @__PURE__ */ React24.createElement(Box21, { gap: 2 }, /* @__PURE__ */ React24.createElement(Box21, null, /* @__PURE__ */ React24.createElement(Text19, { color: agentMode === "plan" ? theme.status.inProgress : theme.text.dim }, agentMode === "plan" ? "\u23F8 plan" : "\u25B6 build"), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, " (shift+tab)")), /* @__PURE__ */ React24.createElement(Box21, null, /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, "model:"), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.info }, getModelDisplayName(selectedModel)), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, " (Cost: "), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.info }, getModelCostLabel(selectedModel)), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, ") (ctrl+shift+m)"))), /* @__PURE__ */ React24.createElement(Box21, null, /* @__PURE__ */ React24.createElement(Text19, { color: usageStats && usageStats.contextPct >= 90 ? theme.text.error : usageStats && usageStats.contextPct >= 75 ? theme.text.warning : theme.text.dim }, usageStats?.contextPct ?? 0, "% context used"), /* @__PURE__ */ React24.createElement(Text19, { color: theme.text.dim }, " ", "(", usageStats ? usageStats.inputTokens >= 1e3 ? `${(usageStats.inputTokens / 1e3).toFixed(1)}K` : usageStats.inputTokens : 0, " / ", usageStats ? usageStats.contextWindow >= 1e3 ? `${(usageStats.contextWindow / 1e3).toFixed(0)}K` : usageStats.contextWindow : "200K", ")"))));
     });
     InputPromptInner.displayName = "InputPromptInner";
     InputPrompt = memo3(InputPromptInner);
@@ -11746,19 +13331,19 @@ var init_InputPrompt = __esm({
 
 // src/ui/components/McpAddDialog.tsx
 import { Box as Box22, Text as Text20, useInput as useInput6 } from "ink";
-import React25, { useState as useState11 } from "react";
+import React25, { useState as useState12 } from "react";
 var McpAddDialog;
 var init_McpAddDialog = __esm({
   "src/ui/components/McpAddDialog.tsx"() {
     "use strict";
     init_theme();
     McpAddDialog = ({ onConfirm, onCancel }) => {
-      const [mode, setMode] = useState11("name" /* Name */);
-      const [serverName, setServerName] = useState11("");
-      const [command, setCommand] = useState11("");
-      const [args, setArgs] = useState11("");
-      const [description, setDescription] = useState11("");
-      const [scope, setScope] = useState11("project");
+      const [mode, setMode] = useState12("name" /* Name */);
+      const [serverName, setServerName] = useState12("");
+      const [command, setCommand] = useState12("");
+      const [args, setArgs] = useState12("");
+      const [description, setDescription] = useState12("");
+      const [scope, setScope] = useState12("project");
       useInput6((input, key) => {
         if (key.escape) {
           onCancel();
@@ -11853,7 +13438,7 @@ var init_McpAddDialog = __esm({
 
 // src/ui/components/McpServerSelector.tsx
 import { Box as Box23, Text as Text21, useInput as useInput7 } from "ink";
-import React26, { useState as useState12 } from "react";
+import React26, { useState as useState13 } from "react";
 var McpServerSelector;
 var init_McpServerSelector = __esm({
   "src/ui/components/McpServerSelector.tsx"() {
@@ -11865,7 +13450,7 @@ var init_McpServerSelector = __esm({
       onSelect,
       onCancel
     }) => {
-      const [selectedIndex, setSelectedIndex] = useState12(0);
+      const [selectedIndex, setSelectedIndex] = useState13(0);
       useInput7((input, key) => {
         if (key.escape) {
           onCancel();
@@ -11924,7 +13509,7 @@ var init_McpServerSelector = __esm({
 // src/ui/components/McpServersDisplay.tsx
 import { Box as Box24, Text as Text22, useInput as useInput8 } from "ink";
 import Spinner3 from "ink-spinner";
-import React27, { useEffect as useEffect10, useState as useState13 } from "react";
+import React27, { useEffect as useEffect11, useState as useState14 } from "react";
 var McpServersDisplay;
 var init_McpServersDisplay = __esm({
   "src/ui/components/McpServersDisplay.tsx"() {
@@ -11938,9 +13523,9 @@ var init_McpServersDisplay = __esm({
       onTest,
       cwd
     }) => {
-      const [servers, setServers] = useState13([]);
-      const [isTestingAll, setIsTestingAll] = useState13(false);
-      useEffect10(() => {
+      const [servers, setServers] = useState14([]);
+      const [isTestingAll, setIsTestingAll] = useState14(false);
+      useEffect11(() => {
         const projectDir = cwd || process.cwd();
         const loadedServers = loadMcpConfig(projectDir);
         const serversArray = Object.values(loadedServers).map((server) => ({
@@ -12010,7 +13595,7 @@ var init_McpServersDisplay = __esm({
 
 // src/ui/components/ProviderSelector.tsx
 import { Box as Box25, Text as Text23, useInput as useInput9 } from "ink";
-import React28, { useState as useState14 } from "react";
+import React28, { useState as useState15 } from "react";
 var PROVIDERS, ProviderSelector;
 var init_ProviderSelector = __esm({
   "src/ui/components/ProviderSelector.tsx"() {
@@ -12025,7 +13610,7 @@ var init_ProviderSelector = __esm({
       {
         id: "claude-max",
         name: "Claude Max",
-        description: "Direct Claude Max subscription (requires Claude Code login)"
+        description: "Direct Claude Max subscription (requires OAuth login)"
       }
     ];
     ProviderSelector = ({
@@ -12040,7 +13625,7 @@ var init_ProviderSelector = __esm({
       const currentIndex = availableProviders.findIndex(
         (p) => p.id === currentProvider
       );
-      const [selectedIndex, setSelectedIndex] = useState14(
+      const [selectedIndex, setSelectedIndex] = useState15(
         currentIndex >= 0 ? currentIndex : 0
       );
       useInput9((input, key) => {
@@ -12080,9 +13665,125 @@ var init_ProviderSelector = __esm({
   }
 });
 
-// src/ui/components/SessionSelector.tsx
+// src/ui/components/QuestionSelector.tsx
 import { Box as Box26, Text as Text24, useInput as useInput10 } from "ink";
-import React29, { useEffect as useEffect11, useState as useState15 } from "react";
+import React29, { useState as useState16 } from "react";
+var QuestionSelector;
+var init_QuestionSelector = __esm({
+  "src/ui/components/QuestionSelector.tsx"() {
+    "use strict";
+    init_theme();
+    QuestionSelector = ({
+      question,
+      options,
+      multiSelect = false,
+      allowCustomAnswer = true,
+      // Default to true - always show "Other" option
+      onSubmit,
+      onCancel
+    }) => {
+      const hasOptions = options && options.length > 0;
+      const allOptions = hasOptions && allowCustomAnswer ? [...options, { label: "Other", description: "Provide a custom response" }] : options;
+      const [selectedIndex, setSelectedIndex] = useState16(0);
+      const [selectedItems, setSelectedItems] = useState16(/* @__PURE__ */ new Set());
+      const [customInputMode, setCustomInputMode] = useState16(!hasOptions);
+      const [customAnswer, setCustomAnswer] = useState16("");
+      useInput10((input, key) => {
+        if (customInputMode) {
+          if (key.return) {
+            if (customAnswer.trim()) {
+              onSubmit([customAnswer.trim()]);
+            }
+          } else if (key.escape) {
+            if (!hasOptions) {
+              onCancel();
+            } else {
+              setCustomInputMode(false);
+              setCustomAnswer("");
+            }
+          } else if (key.backspace || key.delete) {
+            setCustomAnswer((prev) => prev.slice(0, -1));
+          } else if (input && !key.ctrl && !key.meta) {
+            setCustomAnswer((prev) => prev + input);
+          }
+          return;
+        }
+        if (key.upArrow) {
+          setSelectedIndex((prev) => prev > 0 ? prev - 1 : allOptions.length - 1);
+        } else if (key.downArrow) {
+          setSelectedIndex((prev) => prev < allOptions.length - 1 ? prev + 1 : 0);
+        } else if (key.return) {
+          const selectedOption = allOptions[selectedIndex];
+          if (selectedOption.label === "Other" && allowCustomAnswer) {
+            setCustomInputMode(true);
+            return;
+          }
+          if (multiSelect) {
+            setSelectedItems((prev) => {
+              const newSet = new Set(prev);
+              if (newSet.has(selectedIndex)) {
+                newSet.delete(selectedIndex);
+              } else {
+                newSet.add(selectedIndex);
+              }
+              return newSet;
+            });
+          } else {
+            onSubmit([selectedOption.label]);
+          }
+        } else if (input === " " && multiSelect) {
+          setSelectedItems((prev) => {
+            const newSet = new Set(prev);
+            if (newSet.has(selectedIndex)) {
+              newSet.delete(selectedIndex);
+            } else {
+              newSet.add(selectedIndex);
+            }
+            return newSet;
+          });
+        } else if (key.escape || input === "q") {
+          onCancel();
+        } else if (input === "s" && multiSelect && selectedItems.size > 0) {
+          const answers = Array.from(selectedItems).sort((a, b) => a - b).map((idx) => allOptions[idx].label);
+          onSubmit(answers);
+        } else if ((input === "o" || input === "O") && allowCustomAnswer) {
+          setCustomInputMode(true);
+        }
+      });
+      if (customInputMode) {
+        return /* @__PURE__ */ React29.createElement(Box26, { borderColor: theme.border.accent, borderStyle: "round", flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React29.createElement(Box26, { marginBottom: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: theme.text.accent }, question)), /* @__PURE__ */ React29.createElement(Box26, { marginBottom: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, hasOptions ? "Enter your custom answer:" : "Type your answer:")), /* @__PURE__ */ React29.createElement(Box26, { marginBottom: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.primary }, ">", " ", customAnswer, /* @__PURE__ */ React29.createElement(Text24, { backgroundColor: theme.text.accent }, " "))), /* @__PURE__ */ React29.createElement(Box26, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "Enter"), " submit \u2022 ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "ESC"), " ", hasOptions ? "back to options" : "cancel")));
+      }
+      return /* @__PURE__ */ React29.createElement(Box26, { borderColor: theme.border.accent, borderStyle: "round", flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React29.createElement(Box26, { marginBottom: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: theme.text.accent }, question)), multiSelect && /* @__PURE__ */ React29.createElement(Box26, { marginBottom: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, "(Select multiple options with ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "Space"), ", submit with ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "S"), ")")), /* @__PURE__ */ React29.createElement(Box26, { flexDirection: "column", marginBottom: 1 }, allOptions.map((option, index) => {
+        const isSelected = index === selectedIndex;
+        const isChosen = selectedItems.has(index);
+        const indicator = isSelected ? "\u25B6 " : "  ";
+        const checkbox = multiSelect ? isChosen ? "[\u2713] " : "[ ] " : "";
+        return /* @__PURE__ */ React29.createElement(Box26, { flexDirection: "column", gap: 0, key: `${option.label}-${index}` }, /* @__PURE__ */ React29.createElement(Box26, null, /* @__PURE__ */ React29.createElement(
+          Text24,
+          {
+            backgroundColor: isSelected ? theme.text.accent : void 0,
+            bold: isSelected,
+            color: isSelected ? "black" : theme.text.primary
+          },
+          indicator,
+          checkbox,
+          option.label
+        )), /* @__PURE__ */ React29.createElement(Box26, { marginLeft: multiSelect ? 6 : 4 }, /* @__PURE__ */ React29.createElement(
+          Text24,
+          {
+            color: isSelected ? theme.text.primary : theme.text.dim,
+            dimColor: !isSelected
+          },
+          option.description
+        )));
+      })), /* @__PURE__ */ React29.createElement(Box26, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "\u2191\u2193"), " navigate \u2022 ", multiSelect ? /* @__PURE__ */ React29.createElement(React29.Fragment, null, /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "Space"), " toggle \u2022 ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "S"), " submit \u2022", " ") : /* @__PURE__ */ React29.createElement(React29.Fragment, null, /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "Enter"), " select \u2022", " "), /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "ESC"), " cancel")));
+    };
+  }
+});
+
+// src/ui/components/SessionSelector.tsx
+import { Box as Box27, Text as Text25, useInput as useInput11 } from "ink";
+import React30, { useEffect as useEffect12, useState as useState17 } from "react";
 function getSessionPrefix(authMethod) {
   return authMethod === "api-key" ? "[Team]" : "[Me]";
 }
@@ -12097,13 +13798,13 @@ var init_SessionSelector = __esm({
       onSelect,
       onCancel
     }) => {
-      const [allSessions, setAllSessions] = useState15([]);
-      const [selectedIndex, setSelectedIndex] = useState15(0);
-      const [isLoading, setIsLoading] = useState15(false);
-      const [hasMore, setHasMore] = useState15(true);
-      const [totalSessions, setTotalSessions] = useState15(0);
-      const [error, setError] = useState15(null);
-      useEffect11(() => {
+      const [allSessions, setAllSessions] = useState17([]);
+      const [selectedIndex, setSelectedIndex] = useState17(0);
+      const [isLoading, setIsLoading] = useState17(false);
+      const [hasMore, setHasMore] = useState17(true);
+      const [totalSessions, setTotalSessions] = useState17(0);
+      const [error, setError] = useState17(null);
+      useEffect12(() => {
         loadMoreSessions();
       }, []);
       const loadMoreSessions = async () => {
@@ -12129,7 +13830,7 @@ var init_SessionSelector = __esm({
           setIsLoading(false);
         }
       };
-      useInput10((input, key) => {
+      useInput11((input, key) => {
         if (allSessions.length === 0) {
           if (key.escape || input === "q") {
             onCancel();
@@ -12153,13 +13854,13 @@ var init_SessionSelector = __esm({
         }
       });
       if (error) {
-        return /* @__PURE__ */ React29.createElement(Box26, { borderColor: "red", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "red" }, "Error Loading Sessions"), /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, error), /* @__PURE__ */ React29.createElement(Box26, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, "Press ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "ESC"), " to cancel")));
+        return /* @__PURE__ */ React30.createElement(Box27, { borderColor: "red", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React30.createElement(Text25, { bold: true, color: "red" }, "Error Loading Sessions"), /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, error), /* @__PURE__ */ React30.createElement(Box27, { marginTop: 1 }, /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, "Press ", /* @__PURE__ */ React30.createElement(Text25, { bold: true }, "ESC"), " to cancel")));
       }
       if (allSessions.length === 0 && isLoading) {
-        return /* @__PURE__ */ React29.createElement(Box26, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "cyan" }, "Loading Sessions..."), /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, "Fetching your sessions from the server"));
+        return /* @__PURE__ */ React30.createElement(Box27, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React30.createElement(Text25, { bold: true, color: "cyan" }, "Loading Sessions..."), /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, "Fetching your sessions from the server"));
       }
       if (allSessions.length === 0 && !isLoading) {
-        return /* @__PURE__ */ React29.createElement(Box26, { borderColor: "yellow", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "yellow" }, "No Sessions Found"), /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, "No previous sessions available. Start a new conversation!"), /* @__PURE__ */ React29.createElement(Box26, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, "Press ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "ESC"), " to cancel")));
+        return /* @__PURE__ */ React30.createElement(Box27, { borderColor: "yellow", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React30.createElement(Text25, { bold: true, color: "yellow" }, "No Sessions Found"), /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, "No previous sessions available. Start a new session!"), /* @__PURE__ */ React30.createElement(Box27, { marginTop: 1 }, /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, "Press ", /* @__PURE__ */ React30.createElement(Text25, { bold: true }, "ESC"), " to cancel")));
       }
       const VISIBLE_ITEMS3 = 10;
       let startIndex;
@@ -12179,7 +13880,7 @@ var init_SessionSelector = __esm({
       const visibleSessions = allSessions.slice(startIndex, endIndex);
       const MAX_TITLE_WIDTH = 50;
       const PREFIX_WIDTH = 6;
-      return /* @__PURE__ */ React29.createElement(Box26, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React29.createElement(Box26, { marginBottom: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "cyan" }, "Select a Session to Resume")), /* @__PURE__ */ React29.createElement(Box26, { flexDirection: "column" }, visibleSessions.map((item, index) => {
+      return /* @__PURE__ */ React30.createElement(Box27, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React30.createElement(Box27, { marginBottom: 1 }, /* @__PURE__ */ React30.createElement(Text25, { bold: true, color: "cyan" }, "Select a Session to Resume")), /* @__PURE__ */ React30.createElement(Box27, { flexDirection: "column" }, visibleSessions.map((item, index) => {
         const actualIndex = startIndex + index;
         const isSelected = actualIndex === selectedIndex;
         const title = item.session.title || "Untitled session";
@@ -12203,18 +13904,18 @@ var init_SessionSelector = __esm({
         const prefixColor = item.prefix === "[Me]" ? "cyan" : "yellow";
         const indicator = isSelected ? "\u25B6 " : "  ";
         const bgColor = isSelected ? theme.text.accent : void 0;
-        return /* @__PURE__ */ React29.createElement(Box26, { key: item.session.id, width: "100%" }, /* @__PURE__ */ React29.createElement(Text24, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, indicator), /* @__PURE__ */ React29.createElement(Text24, { backgroundColor: bgColor, bold: isSelected, color: prefixColor }, prefix), /* @__PURE__ */ React29.createElement(Text24, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, displayTitle), /* @__PURE__ */ React29.createElement(Text24, { backgroundColor: bgColor, color: theme.text.dim }, "(", dateStr, ")"));
-      })), /* @__PURE__ */ React29.createElement(Box26, { flexDirection: "column", marginTop: 1 }, (allSessions.length > VISIBLE_ITEMS3 || totalSessions > allSessions.length) && /* @__PURE__ */ React29.createElement(Box26, { marginBottom: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: "yellow" }, "Showing ", startIndex + 1, "-", endIndex, " of ", totalSessions || allSessions.length, " sessions", hasMore && !isLoading && /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, " \u2022 Scroll for more"))), /* @__PURE__ */ React29.createElement(Box26, null, /* @__PURE__ */ React29.createElement(Text24, { color: theme.text.dim }, "Use ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "\u2191\u2193"), " to navigate \u2022 ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "Enter"), " to select \u2022 ", /* @__PURE__ */ React29.createElement(Text24, { bold: true }, "ESC"), " to cancel")), isLoading && /* @__PURE__ */ React29.createElement(Box26, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: "cyan" }, "Loading more sessions..."))));
+        return /* @__PURE__ */ React30.createElement(Box27, { key: item.session.id, width: "100%" }, /* @__PURE__ */ React30.createElement(Text25, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, indicator), /* @__PURE__ */ React30.createElement(Text25, { backgroundColor: bgColor, bold: isSelected, color: prefixColor }, prefix), /* @__PURE__ */ React30.createElement(Text25, { backgroundColor: bgColor, bold: isSelected, color: isSelected ? "black" : theme.text.primary }, displayTitle), /* @__PURE__ */ React30.createElement(Text25, { backgroundColor: bgColor, color: theme.text.dim }, "(", dateStr, ")"));
+      })), /* @__PURE__ */ React30.createElement(Box27, { flexDirection: "column", marginTop: 1 }, (allSessions.length > VISIBLE_ITEMS3 || totalSessions > allSessions.length) && /* @__PURE__ */ React30.createElement(Box27, { marginBottom: 1 }, /* @__PURE__ */ React30.createElement(Text25, { color: "yellow" }, "Showing ", startIndex + 1, "-", endIndex, " of ", totalSessions || allSessions.length, " sessions", hasMore && !isLoading && /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, " \u2022 Scroll for more"))), /* @__PURE__ */ React30.createElement(Box27, null, /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, "Use ", /* @__PURE__ */ React30.createElement(Text25, { bold: true }, "\u2191\u2193"), " to navigate \u2022 ", /* @__PURE__ */ React30.createElement(Text25, { bold: true }, "Enter"), " to select \u2022 ", /* @__PURE__ */ React30.createElement(Text25, { bold: true }, "ESC"), " to cancel")), isLoading && /* @__PURE__ */ React30.createElement(Box27, { marginTop: 1 }, /* @__PURE__ */ React30.createElement(Text25, { color: "cyan" }, "Loading more sessions..."))));
     };
   }
 });
 
 // src/ui/hooks/useModeToggle.ts
-import { useEffect as useEffect12 } from "react";
+import { useEffect as useEffect13 } from "react";
 function useModeToggle() {
   const { subscribe, unsubscribe } = useKeypressContext();
   const { agentMode, setAgentMode, isAgentRunning } = useSession();
-  useEffect12(() => {
+  useEffect13(() => {
     const handleKeypress = (key) => {
       if (key.name === "tab" && key.shift && !isAgentRunning) {
         const newMode = agentMode === "plan" ? "build" : "plan";
@@ -12235,13 +13936,13 @@ var init_useModeToggle = __esm({
 });
 
 // src/ui/hooks/useOverlayEscapeGuard.ts
-import { useCallback as useCallback4, useMemo as useMemo4, useRef as useRef6 } from "react";
+import { useCallback as useCallback4, useMemo as useMemo4, useRef as useRef7 } from "react";
 var useOverlayEscapeGuard;
 var init_useOverlayEscapeGuard = __esm({
   "src/ui/hooks/useOverlayEscapeGuard.ts"() {
     "use strict";
     useOverlayEscapeGuard = ({ overlays, suppressionMs = 250 }) => {
-      const suppressUntilRef = useRef6(0);
+      const suppressUntilRef = useRef7(0);
       const markOverlayClosed = useCallback4(() => {
         suppressUntilRef.current = Date.now() + suppressionMs;
       }, [suppressionMs]);
@@ -12253,11 +13954,11 @@ var init_useOverlayEscapeGuard = __esm({
 });
 
 // src/ui/App.tsx
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import { homedir as homedir8 } from "os";
-import { Box as Box27, Text as Text25, useApp as useApp2, useStdout as useStdout2 } from "ink";
+import { Box as Box28, Text as Text26, useApp as useApp2, useStdout as useStdout2 } from "ink";
 import Spinner4 from "ink-spinner";
-import React30, { useCallback as useCallback5, useEffect as useEffect13, useRef as useRef7, useState as useState16 } from "react";
+import React31, { useCallback as useCallback5, useEffect as useEffect14, useRef as useRef8, useState as useState18 } from "react";
 var getGitBranch2, getCurrentFolder2, AppContent, App;
 var init_App = __esm({
   "src/ui/App.tsx"() {
@@ -12284,6 +13985,7 @@ var init_App = __esm({
     init_MessageList();
     init_ModelSelector();
     init_ProviderSelector();
+    init_QuestionSelector();
     init_SessionSelector();
     init_SessionContext();
     init_useKeypress();
@@ -12293,7 +13995,7 @@ var init_App = __esm({
     init_theme();
     getGitBranch2 = () => {
       try {
-        return execSync6("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
+        return execSync5("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
       } catch {
         return "";
       }
@@ -12306,36 +14008,37 @@ var init_App = __esm({
       }
       return cwd;
     };
-    AppContent = ({ config: config2, sessionId, webUrl, queuedTasks = [], onExit, onSubmitTask, apiClient, onResumeSession, onClearSession }) => {
+    AppContent = ({ config: config2, sessionId, webUrl, queuedTasks = [], onExit, onSubmitTask, apiClient, onResumeSession, onClearSession, onQuestionAnswer }) => {
       const { exit } = useApp2();
       const { stdout } = useStdout2();
-      const { addMessage, clearMessages, isAgentRunning, setSessionId, setWebUrl, setShouldInterruptAgent, setIsAgentRunning, toggleAllToolOutputs, allToolsExpanded, selectedModel, setSelectedModel, refreshStatic, toggleToolGroups, llmProvider, setLlmProvider } = useSession();
+      const { addMessage, clearMessages, isAgentRunning, setSessionId, setWebUrl, setShouldInterruptAgent, setIsAgentRunning, toggleAllToolOutputs, allToolsExpanded, selectedModel, setSelectedModel, refreshStatic, toggleToolGroups, llmProvider, setLlmProvider, pendingQuestion, setPendingQuestion } = useSession();
       useModeToggle();
-      const [terminalWidth, setTerminalWidth] = useState16(process.stdout.columns || 80);
-      const [showInput, setShowInput] = useState16(true);
-      const [gitBranch] = useState16(() => getGitBranch2());
-      const [currentFolder] = useState16(() => getCurrentFolder2(config2.cwd));
-      const hasInputContentRef = useRef7(false);
-      const [exitWarning, setExitWarning] = useState16(null);
-      const inputPromptRef = useRef7(null);
-      const [showSessionSelector, setShowSessionSelector] = useState16(false);
-      const [showModelSelector, setShowModelSelector] = useState16(false);
-      const [showProviderSelector, setShowProviderSelector] = useState16(false);
-      const [showFeedbackDialog, setShowFeedbackDialog] = useState16(false);
-      const [isLoadingSession, setIsLoadingSession] = useState16(false);
-      const [showFixFlow, setShowFixFlow] = useState16(false);
-      const [fixRunId, setFixRunId] = useState16(void 0);
-      const [showMcpServers, setShowMcpServers] = useState16(false);
-      const [showMcpAdd, setShowMcpAdd] = useState16(false);
-      const [showMcpSelector, setShowMcpSelector] = useState16(false);
-      const [mcpSelectorAction, setMcpSelectorAction] = useState16(
+      const [terminalWidth, setTerminalWidth] = useState18(process.stdout.columns || 80);
+      const [showInput, setShowInput] = useState18(true);
+      const [gitBranch] = useState18(() => getGitBranch2());
+      const [currentFolder] = useState18(() => getCurrentFolder2(config2.cwd));
+      const hasInputContentRef = useRef8(false);
+      const [exitWarning, setExitWarning] = useState18(null);
+      const inputPromptRef = useRef8(null);
+      const [showSessionSelector, setShowSessionSelector] = useState18(false);
+      const [showModelSelector, setShowModelSelector] = useState18(false);
+      const [showProviderSelector, setShowProviderSelector] = useState18(false);
+      const [claudeMaxAvailable, setClaudeMaxAvailable] = useState18(false);
+      const [showFeedbackDialog, setShowFeedbackDialog] = useState18(false);
+      const [isLoadingSession, setIsLoadingSession] = useState18(false);
+      const [showFixFlow, setShowFixFlow] = useState18(false);
+      const [fixRunId, setFixRunId] = useState18(void 0);
+      const [showMcpServers, setShowMcpServers] = useState18(false);
+      const [showMcpAdd, setShowMcpAdd] = useState18(false);
+      const [showMcpSelector, setShowMcpSelector] = useState18(false);
+      const [mcpSelectorAction, setMcpSelectorAction] = useState18(
         "remove"
       );
-      const [mcpServers, setMcpServers] = useState16([]);
-      const [authState, setAuthState] = useState16(
+      const [mcpServers, setMcpServers] = useState18([]);
+      const [authState, setAuthState] = useState18(
         () => config2.supatestApiKey ? "authenticated" /* Authenticated */ : "unauthenticated" /* Unauthenticated */
       );
-      const [showAuthDialog, setShowAuthDialog] = useState16(false);
+      const [showAuthDialog, setShowAuthDialog] = useState18(false);
       const { isOverlayOpen, isCancelSuppressed, markOverlayClosed } = useOverlayEscapeGuard({
         overlays: [
           showSessionSelector,
@@ -12346,15 +14049,16 @@ var init_App = __esm({
           showFixFlow,
           showMcpServers,
           showMcpAdd,
-          showMcpSelector
+          showMcpSelector,
+          !!pendingQuestion
         ]
       });
-      useEffect13(() => {
+      useEffect14(() => {
         if (!config2.supatestApiKey) {
           setShowAuthDialog(true);
         }
       }, [config2.supatestApiKey]);
-      useEffect13(() => {
+      useEffect14(() => {
         if (sessionId) {
           setSessionId(sessionId);
         }
@@ -12369,6 +14073,7 @@ var init_App = __esm({
           type: "assistant",
           content: "Opening browser for authentication..."
         });
+        await new Promise((resolve2) => setTimeout(resolve2, 0));
         try {
           const result = await loginCommand();
           saveToken(result.token, result.expiresAt);
@@ -12463,6 +14168,7 @@ var init_App = __esm({
             return;
           }
           if (command === "/provider") {
+            isClaudeMaxAvailable().then(setClaudeMaxAvailable);
             setShowProviderSelector(true);
             return;
           }
@@ -12515,6 +14221,7 @@ var init_App = __esm({
               type: "assistant",
               content: "Running setup..."
             });
+            await new Promise((resolve2) => setTimeout(resolve2, 0));
             try {
               const result = await setupCommand({ cwd: config2.cwd || process.cwd() });
               addMessage({
@@ -12608,9 +14315,45 @@ var init_App = __esm({
         markOverlayClosed();
         setShowModelSelector(false);
       };
-      const handleProviderSelect = (provider) => {
+      const handleProviderSelect = async (provider) => {
         setShowProviderSelector(false);
         markOverlayClosed();
+        if (provider === "claude-max") {
+          const hasAuth = await isClaudeMaxAvailable();
+          if (!hasAuth) {
+            addMessage({
+              type: "assistant",
+              content: "Claude Max requires OAuth authentication. Starting authentication flow..."
+            });
+            try {
+              const { ClaudeOAuthService: ClaudeOAuthService2 } = await Promise.resolve().then(() => (init_claude_oauth(), claude_oauth_exports));
+              const { getSecretStorage: getSecretStorage2 } = await Promise.resolve().then(() => (init_secret_storage(), secret_storage_exports));
+              const secretStorage = getSecretStorage2();
+              const oauthService = new ClaudeOAuthService2(secretStorage);
+              const result = await oauthService.authorize();
+              if (!result.success) {
+                addMessage({
+                  type: "error",
+                  content: `Authentication failed: ${result.error || "Unknown error"}`,
+                  errorType: "error"
+                });
+                return;
+              }
+              addMessage({
+                type: "assistant",
+                content: "\u2705 Successfully authenticated with Claude! Switching to Claude Max provider..."
+              });
+              setClaudeMaxAvailable(true);
+            } catch (error) {
+              addMessage({
+                type: "error",
+                content: `Authentication failed: ${error instanceof Error ? error.message : String(error)}`,
+                errorType: "error"
+              });
+              return;
+            }
+          }
+        }
         setLlmProvider(provider);
         saveSupatestSettings(config2.cwd || process.cwd(), { llmProvider: provider });
         addMessage({
@@ -12661,6 +14404,38 @@ var init_App = __esm({
         markOverlayClosed();
         setShowFeedbackDialog(false);
       };
+      const handleQuestionSubmit = (answers) => {
+        if (!pendingQuestion) return;
+        const formattedAnswer = answers.length === 1 ? answers[0] : answers.join(", ");
+        addMessage({
+          type: "user",
+          content: formattedAnswer
+        });
+        const answerRecord = {
+          "answer": formattedAnswer
+        };
+        if (onQuestionAnswer) {
+          const success = onQuestionAnswer(pendingQuestion.toolUseId, answerRecord);
+          if (!success) {
+            console.warn("[App] Failed to submit answer - no pending question found");
+          }
+        }
+        setPendingQuestion(null);
+        markOverlayClosed();
+      };
+      const handleQuestionCancel = () => {
+        if (!pendingQuestion) return;
+        if (onQuestionAnswer) {
+          onQuestionAnswer(pendingQuestion.toolUseId, null);
+        }
+        const cancelMsg = "I'd prefer not to answer this question right now.";
+        addMessage({
+          type: "user",
+          content: cancelMsg
+        });
+        setPendingQuestion(null);
+        markOverlayClosed();
+      };
       const handleFixFlowCancel = () => {
         markOverlayClosed();
         setShowFixFlow(false);
@@ -12800,8 +14575,8 @@ var init_App = __esm({
         markOverlayClosed();
         setShowMcpServers(true);
       };
-      const isInitialMount = useRef7(true);
-      useEffect13(() => {
+      const isInitialMount = useRef8(true);
+      useEffect14(() => {
         const handleResize = () => {
           setTerminalWidth(process.stdout.columns || 80);
         };
@@ -12810,7 +14585,7 @@ var init_App = __esm({
           process.stdout.off("resize", handleResize);
         };
       }, []);
-      useEffect13(() => {
+      useEffect14(() => {
         if (isInitialMount.current) {
           isInitialMount.current = false;
           return;
@@ -12872,7 +14647,7 @@ var init_App = __esm({
         },
         { isActive: !isOverlayOpen }
       );
-      useEffect13(() => {
+      useEffect14(() => {
         if (config2.task) {
           addMessage({
             type: "user",
@@ -12880,14 +14655,14 @@ var init_App = __esm({
           });
         }
       }, []);
-      return /* @__PURE__ */ React30.createElement(
-        Box27,
+      return /* @__PURE__ */ React31.createElement(
+        Box28,
         {
           flexDirection: "column",
           paddingX: 1
         },
-        /* @__PURE__ */ React30.createElement(MessageList, { currentFolder, gitBranch, queuedTasks, terminalWidth }),
-        showSessionSelector && apiClient && /* @__PURE__ */ React30.createElement(
+        /* @__PURE__ */ React31.createElement(MessageList, { currentFolder, gitBranch, queuedTasks, terminalWidth }),
+        showSessionSelector && apiClient && /* @__PURE__ */ React31.createElement(
           SessionSelector,
           {
             apiClient,
@@ -12895,8 +14670,8 @@ var init_App = __esm({
             onSelect: handleSessionSelect
           }
         ),
-        isLoadingSession && /* @__PURE__ */ React30.createElement(Box27, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React30.createElement(Box27, { flexDirection: "row" }, /* @__PURE__ */ React30.createElement(Box27, { width: 2 }, /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.accent }, /* @__PURE__ */ React30.createElement(Spinner4, { type: "dots" }))), /* @__PURE__ */ React30.createElement(Text25, { bold: true, color: "cyan" }, "Loading session...")), /* @__PURE__ */ React30.createElement(Text25, { color: theme.text.dim }, "Fetching queries and context")),
-        showModelSelector && /* @__PURE__ */ React30.createElement(
+        isLoadingSession && /* @__PURE__ */ React31.createElement(Box28, { borderColor: "cyan", borderStyle: "round", flexDirection: "column", padding: 1 }, /* @__PURE__ */ React31.createElement(Box28, { flexDirection: "row" }, /* @__PURE__ */ React31.createElement(Box28, { width: 2 }, /* @__PURE__ */ React31.createElement(Text26, { color: theme.text.accent }, /* @__PURE__ */ React31.createElement(Spinner4, { type: "dots" }))), /* @__PURE__ */ React31.createElement(Text26, { bold: true, color: "cyan" }, "Loading session...")), /* @__PURE__ */ React31.createElement(Text26, { color: theme.text.dim }, "Fetching queries and context")),
+        showModelSelector && /* @__PURE__ */ React31.createElement(
           ModelSelector,
           {
             currentModel: selectedModel,
@@ -12905,29 +14680,29 @@ var init_App = __esm({
             onSelect: handleModelSelect
           }
         ),
-        showProviderSelector && /* @__PURE__ */ React30.createElement(
+        showProviderSelector && /* @__PURE__ */ React31.createElement(
           ProviderSelector,
           {
-            claudeMaxAvailable: isClaudeMaxAvailable(),
+            claudeMaxAvailable,
             currentProvider: llmProvider,
             onCancel: handleProviderSelectorCancel,
             onSelect: handleProviderSelect
           }
         ),
-        showAuthDialog && /* @__PURE__ */ React30.createElement(
+        showAuthDialog && /* @__PURE__ */ React31.createElement(
           AuthDialog,
           {
             onLogin: handleLogin
           }
         ),
-        showFeedbackDialog && /* @__PURE__ */ React30.createElement(
+        showFeedbackDialog && /* @__PURE__ */ React31.createElement(
           FeedbackDialog,
           {
             onCancel: handleFeedbackCancel,
             onSubmit: handleFeedbackSubmit
           }
         ),
-        showFixFlow && apiClient && /* @__PURE__ */ React30.createElement(
+        showFixFlow && apiClient && /* @__PURE__ */ React31.createElement(
           FixFlow,
           {
             apiClient,
@@ -12937,7 +14712,7 @@ var init_App = __esm({
             onStartFix: handleFixStart
           }
         ),
-        showMcpServers && /* @__PURE__ */ React30.createElement(
+        showMcpServers && /* @__PURE__ */ React31.createElement(
           McpServersDisplay,
           {
             cwd: config2.cwd,
@@ -12947,8 +14722,8 @@ var init_App = __esm({
             onTest: handleMcpTest
           }
         ),
-        showMcpAdd && /* @__PURE__ */ React30.createElement(McpAddDialog, { onCancel: handleMcpAddCancel, onConfirm: handleMcpAddConfirm }),
-        showMcpSelector && /* @__PURE__ */ React30.createElement(
+        showMcpAdd && /* @__PURE__ */ React31.createElement(McpAddDialog, { onCancel: handleMcpAddCancel, onConfirm: handleMcpAddConfirm }),
+        showMcpSelector && /* @__PURE__ */ React31.createElement(
           McpServerSelector,
           {
             action: mcpSelectorAction,
@@ -12957,7 +14732,17 @@ var init_App = __esm({
             servers: mcpServers
           }
         ),
-        /* @__PURE__ */ React30.createElement(Box27, { flexDirection: "column" }, !showAuthDialog && /* @__PURE__ */ React30.createElement(AuthBanner, { authState }), showInput && !showSessionSelector && !showAuthDialog && !showModelSelector && !showProviderSelector && !showFeedbackDialog && !showFixFlow && !showMcpServers && !showMcpAdd && !showMcpSelector && !isLoadingSession && /* @__PURE__ */ React30.createElement(Box27, { flexDirection: "column", marginTop: 0, width: "100%" }, exitWarning && /* @__PURE__ */ React30.createElement(Box27, { marginBottom: 0, paddingX: 1 }, /* @__PURE__ */ React30.createElement(Text25, { color: "yellow" }, exitWarning)), /* @__PURE__ */ React30.createElement(
+        pendingQuestion && /* @__PURE__ */ React31.createElement(
+          QuestionSelector,
+          {
+            multiSelect: pendingQuestion.multiSelect,
+            onCancel: handleQuestionCancel,
+            onSubmit: handleQuestionSubmit,
+            options: pendingQuestion.options || [],
+            question: pendingQuestion.question
+          }
+        ),
+        /* @__PURE__ */ React31.createElement(Box28, { flexDirection: "column" }, !showAuthDialog && /* @__PURE__ */ React31.createElement(AuthBanner, { authState }), showInput && !showSessionSelector && !showAuthDialog && !showModelSelector && !showProviderSelector && !showFeedbackDialog && !showFixFlow && !showMcpServers && !showMcpAdd && !showMcpSelector && !pendingQuestion && !isLoadingSession && /* @__PURE__ */ React31.createElement(Box28, { flexDirection: "column", marginTop: 0, width: "100%" }, exitWarning && /* @__PURE__ */ React31.createElement(Box28, { marginBottom: 0, paddingX: 1 }, /* @__PURE__ */ React31.createElement(Text26, { color: "yellow" }, exitWarning)), /* @__PURE__ */ React31.createElement(
           InputPrompt,
           {
             currentFolder,
@@ -12973,13 +14758,13 @@ var init_App = __esm({
       );
     };
     App = (props) => {
-      return /* @__PURE__ */ React30.createElement(AppContent, { ...props });
+      return /* @__PURE__ */ React31.createElement(AppContent, { ...props });
     };
   }
 });
 
 // src/ui/hooks/useBracketedPaste.ts
-import { useEffect as useEffect14 } from "react";
+import { useEffect as useEffect15 } from "react";
 var ENABLE_BRACKETED_PASTE, DISABLE_BRACKETED_PASTE, useBracketedPaste;
 var init_useBracketedPaste = __esm({
   "src/ui/hooks/useBracketedPaste.ts"() {
@@ -12988,7 +14773,7 @@ var init_useBracketedPaste = __esm({
     ENABLE_BRACKETED_PASTE = "\x1B[?2004h";
     DISABLE_BRACKETED_PASTE = "\x1B[?2004l";
     useBracketedPaste = () => {
-      useEffect14(() => {
+      useEffect15(() => {
         writeToStdout(ENABLE_BRACKETED_PASTE);
         const cleanup = () => {
           writeToStdout(DISABLE_BRACKETED_PASTE);
@@ -13009,7 +14794,7 @@ __export(interactive_exports, {
   runInteractive: () => runInteractive
 });
 import { render as render2 } from "ink";
-import React31, { useEffect as useEffect15, useRef as useRef8 } from "react";
+import React32, { useEffect as useEffect16, useRef as useRef9 } from "react";
 function getToolDescription2(toolName, input) {
   switch (toolName) {
     case "Read":
@@ -13142,7 +14927,7 @@ async function runInteractive(config2) {
       webUrl = session.webUrl;
     }
     const { unmount, waitUntilExit } = render2(
-      /* @__PURE__ */ React31.createElement(
+      /* @__PURE__ */ React32.createElement(
         InteractiveApp,
         {
           apiClient,
@@ -13158,11 +14943,14 @@ async function runInteractive(config2) {
         stdout: inkStdout,
         stderr: inkStderr,
         stdin: process.stdin,
+        // Keep alternateBuffer: false for native terminal scrollback and text selection
         alternateBuffer: false,
-        // Like Gemini CLI - allows terminal to handle scroll & selection
         exitOnCtrlC: false,
-        // Reduce flickering by using incremental updates (only changed lines, not entire screen)
-        incrementalRendering: true
+        // Disable incrementalRendering - it doesn't work well without alternateBuffer
+        // and can cause more flickering issues
+        incrementalRendering: false,
+        // Prevent Ink from patching console methods
+        patchConsole: false
       }
     );
     unmountFn = unmount;
@@ -13204,7 +14992,7 @@ var init_interactive = __esm({
     init_settings_loader();
     init_stdio();
     init_version();
-    AgentRunner = ({ config: config2, sessionId, apiClient, messageBridge, onComplete, onTurnComplete }) => {
+    AgentRunner = ({ config: config2, sessionId, apiClient, messageBridge, onComplete, onTurnComplete, onAgentCreated }) => {
       const {
         addMessage,
         updateLastMessage,
@@ -13212,23 +15000,24 @@ var init_interactive = __esm({
         setIsAgentRunning,
         updateStats,
         setTodos,
-        setUsageStats,
         shouldInterruptAgent,
         setShouldInterruptAgent,
         agentMode,
         setAgentMode,
         planFilePath,
         selectedModel,
-        llmProvider
+        llmProvider,
+        setPendingQuestion
       } = useSession();
-      const agentRef = useRef8(null);
-      useEffect15(() => {
+      const { setUsageStats } = useUsageStats();
+      const agentRef = useRef9(null);
+      useEffect16(() => {
         if (shouldInterruptAgent && agentRef.current) {
           agentRef.current.abort();
           setShouldInterruptAgent(false);
         }
       }, [shouldInterruptAgent, setShouldInterruptAgent]);
-      useEffect15(() => {
+      useEffect16(() => {
         let isMounted = true;
         const runAgent2 = async () => {
           setIsAgentRunning(true);
@@ -13270,6 +15059,16 @@ var init_interactive = __esm({
                 },
                 onTurnComplete: () => {
                   if (isMounted) onTurnComplete?.();
+                },
+                onAskUserQuestion: (toolId, question, options, multiSelect) => {
+                  if (isMounted) {
+                    setPendingQuestion({
+                      toolUseId: toolId,
+                      question,
+                      options,
+                      multiSelect
+                    });
+                  }
                 }
               },
               apiClient,
@@ -13278,9 +15077,18 @@ var init_interactive = __esm({
             );
             let oauthToken;
             if (llmProvider === "claude-max") {
-              if (isClaudeMaxAvailable()) {
-                oauthToken = "use-claude-max";
-                logger.info("Using Claude Max subscription for LLM calls");
+              if (await isClaudeMaxAvailable()) {
+                const { ClaudeOAuthService: ClaudeOAuthService2 } = await Promise.resolve().then(() => (init_claude_oauth(), claude_oauth_exports));
+                const { getSecretStorage: getSecretStorage2 } = await Promise.resolve().then(() => (init_secret_storage(), secret_storage_exports));
+                const secretStorage = getSecretStorage2();
+                const oauthService = new ClaudeOAuthService2(secretStorage);
+                const token = await oauthService.getAccessToken();
+                if (token) {
+                  oauthToken = token;
+                  logger.info("Using Claude Max subscription for LLM calls");
+                } else {
+                  logger.warn("Claude Max OAuth token not available. Falling back to Supatest Managed.");
+                }
               } else {
                 logger.warn("Claude Max selected but not available. Falling back to Supatest Managed.");
               }
@@ -13296,6 +15104,9 @@ var init_interactive = __esm({
             };
             const agent2 = new CoreAgent(presenter, messageBridge);
             agentRef.current = agent2;
+            if (onAgentCreated) {
+              onAgentCreated(agent2);
+            }
             const result = await agent2.run(runConfig);
             if (isMounted) {
               onComplete(result.success, result.providerSessionId);
@@ -13333,20 +15144,21 @@ var init_interactive = __esm({
         addMessage,
         loadMessages,
         setSessionId: setContextSessionId,
-        setIsAgentRunning,
-        setUsageStats
+        setIsAgentRunning
       } = useSession();
-      const [sessionId, setSessionId] = React31.useState(initialSessionId);
-      const [currentTask, setCurrentTask] = React31.useState(config2.task);
-      const [taskId, setTaskId] = React31.useState(0);
-      const [shouldRunAgent, setShouldRunAgent] = React31.useState(!!config2.task);
-      const [taskQueue, setTaskQueue] = React31.useState([]);
-      const [providerSessionId, setProviderSessionId] = React31.useState();
-      const messageBridgeRef = React31.useRef(null);
-      const lastSubmitRef = React31.useRef(null);
-      const [pendingInjected, setPendingInjected] = React31.useState([]);
-      const pendingInjectedRef = React31.useRef([]);
-      React31.useEffect(() => {
+      const { setUsageStats } = useUsageStats();
+      const [sessionId, setSessionId] = React32.useState(initialSessionId);
+      const [currentTask, setCurrentTask] = React32.useState(config2.task);
+      const [taskId, setTaskId] = React32.useState(0);
+      const [shouldRunAgent, setShouldRunAgent] = React32.useState(!!config2.task);
+      const [taskQueue, setTaskQueue] = React32.useState([]);
+      const [providerSessionId, setProviderSessionId] = React32.useState();
+      const messageBridgeRef = React32.useRef(null);
+      const agentRef = React32.useRef(null);
+      const lastSubmitRef = React32.useRef(null);
+      const [pendingInjected, setPendingInjected] = React32.useState([]);
+      const pendingInjectedRef = React32.useRef([]);
+      React32.useEffect(() => {
         pendingInjectedRef.current = pendingInjected;
       }, [pendingInjected]);
       const handleSubmitTask = async (task) => {
@@ -13364,6 +15176,7 @@ var init_interactive = __esm({
             });
             setSessionId(session.sessionId);
             setContextSessionId(session.sessionId);
+            setProviderSessionId(void 0);
           } catch (error) {
             const errorMessage = error instanceof ApiError ? error.message : `Failed to create session: ${error instanceof Error ? error.message : String(error)}`;
             addMessage({
@@ -13409,7 +15222,7 @@ var init_interactive = __esm({
       if (shouldRunAgent && !messageBridgeRef.current) {
         messageBridgeRef.current = new MessageBridge(providerSessionId || "");
       }
-      React31.useEffect(() => {
+      React32.useEffect(() => {
         if (!shouldRunAgent && taskQueue.length > 0) {
           const [nextTask, ...remaining] = taskQueue;
           setTaskQueue(remaining);
@@ -13423,20 +15236,27 @@ var init_interactive = __esm({
           setShouldRunAgent(true);
         }
       }, [shouldRunAgent, taskQueue, addMessage, providerSessionId]);
-      const handleClearSession = React31.useCallback(() => {
+      const handleClearSession = React32.useCallback(() => {
         setSessionId(void 0);
         setContextSessionId(void 0);
         setProviderSessionId(void 0);
         setTaskQueue([]);
         setPendingInjected([]);
       }, [setContextSessionId]);
-      return /* @__PURE__ */ React31.createElement(React31.Fragment, null, /* @__PURE__ */ React31.createElement(
+      const handleQuestionAnswer = React32.useCallback((questionId, answers) => {
+        if (agentRef.current) {
+          return agentRef.current.submitAnswer(questionId, answers);
+        }
+        return false;
+      }, []);
+      return /* @__PURE__ */ React32.createElement(React32.Fragment, null, /* @__PURE__ */ React32.createElement(
         App,
         {
           apiClient,
           config: { ...config2, task: currentTask },
           onClearSession: handleClearSession,
           onExit,
+          onQuestionAnswer: handleQuestionAnswer,
           onResumeSession: async (session) => {
             try {
               if (!apiClient) {
@@ -13452,7 +15272,9 @@ var init_interactive = __esm({
               const uiMessages = convertQueriesToUIMessages(queries);
               setSessionId(session.id);
               setContextSessionId(session.id);
-              setProviderSessionId(session.providerSessionId || void 0);
+              const resumeProviderSessionId = session.providerSessionId || void 0;
+              logger.debug(`Resume session: ${session.id}, providerSessionId: ${resumeProviderSessionId || "NOT SET"}`);
+              setProviderSessionId(resumeProviderSessionId);
               const contextData = await apiClient.getSessionContext(session.id);
               if (contextData.contextTokens > 0) {
                 const cacheRead = contextData.cacheReadTokens || 0;
@@ -13493,13 +15315,16 @@ var init_interactive = __esm({
           sessionId,
           webUrl
         }
-      ), shouldRunAgent && currentTask && sessionId && messageBridgeRef.current && /* @__PURE__ */ React31.createElement(
+      ), shouldRunAgent && currentTask && sessionId && messageBridgeRef.current && /* @__PURE__ */ React32.createElement(
         AgentRunner,
         {
           apiClient,
           config: { ...config2, task: currentTask, providerSessionId },
           key: `${taskId}`,
           messageBridge: messageBridgeRef.current,
+          onAgentCreated: (agent2) => {
+            agentRef.current = agent2;
+          },
           onComplete: handleAgentComplete,
           onTurnComplete: () => {
             const pending = pendingInjectedRef.current;
@@ -13518,7 +15343,7 @@ var init_interactive = __esm({
       useBracketedPaste();
       const settings = loadSupatestSettings(props.config.cwd || process.cwd());
       const initialProvider = settings.llmProvider || "supatest-managed";
-      return /* @__PURE__ */ React31.createElement(KeypressProvider, null, /* @__PURE__ */ React31.createElement(SessionProvider, { initialLlmProvider: initialProvider, initialModel: props.config.selectedModel }, /* @__PURE__ */ React31.createElement(InteractiveAppContent, { ...props })));
+      return /* @__PURE__ */ React32.createElement(KeypressProvider, null, /* @__PURE__ */ React32.createElement(SessionProvider, { initialLlmProvider: initialProvider, initialModel: props.config.selectedModel }, /* @__PURE__ */ React32.createElement(InteractiveAppContent, { ...props })));
     };
   }
 });
@@ -13526,9 +15351,61 @@ var init_interactive = __esm({
 // src/index.ts
 await init_config();
 init_shared_es();
+import { Command } from "commander";
+
+// src/commands/claude-login.ts
+init_claude_oauth();
+init_secret_storage();
+async function claudeLoginCommand() {
+  const secretStorage = getSecretStorage();
+  const oauthService = new ClaudeOAuthService(secretStorage);
+  const isAuth = await oauthService.isAuthenticated();
+  if (isAuth) {
+    console.log("\u2705 You're already authenticated with Claude.");
+    console.log("\nTo re-authenticate, first run: supatest claude-logout\n");
+    return;
+  }
+  const result = await oauthService.authorize();
+  if (!result.success) {
+    console.error(`
+\u274C Authentication failed: ${result.error}
+`);
+    process.exit(1);
+  }
+}
+async function claudeLogoutCommand() {
+  const secretStorage = getSecretStorage();
+  const oauthService = new ClaudeOAuthService(secretStorage);
+  const isAuth = await oauthService.isAuthenticated();
+  if (!isAuth) {
+    console.log("You're not currently authenticated with Claude.\n");
+    return;
+  }
+  await oauthService.deleteTokens();
+  console.log("\u2705 Successfully logged out from Claude.\n");
+}
+async function claudeStatusCommand() {
+  const secretStorage = getSecretStorage();
+  const oauthService = new ClaudeOAuthService(secretStorage);
+  const status = await oauthService.getStatus();
+  if (status.isAuthenticated) {
+    console.log("\u2705 Authenticated with Claude");
+    if (status.expiresAt) {
+      const expiresDate = new Date(status.expiresAt);
+      console.log(`   Token expires: ${expiresDate.toLocaleString()}`);
+    }
+  } else {
+    console.log("\u274C Not authenticated with Claude");
+    if (status.error) {
+      console.log(`   Error: ${status.error}`);
+    }
+  }
+  console.log();
+}
+
+// src/index.ts
 init_setup();
 await init_config();
-import { Command } from "commander";
 
 // src/modes/headless.ts
 init_api_client();
@@ -13542,7 +15419,7 @@ init_react();
 init_MessageList();
 init_SessionContext();
 import { execSync as execSync2 } from "child_process";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { Box as Box13, useApp } from "ink";
 import React14, { useEffect as useEffect2, useRef as useRef4, useState as useState3 } from "react";
 var getGitBranch = () => {
@@ -13554,7 +15431,7 @@ var getGitBranch = () => {
 };
 var getCurrentFolder = () => {
   const cwd = process.cwd();
-  const home = homedir4();
+  const home = homedir5();
   if (cwd.startsWith(home)) {
     return `~${cwd.slice(home.length)}`;
   }
@@ -13567,9 +15444,9 @@ var HeadlessAgentRunner = ({ config: config2, sessionId, apiClient, onComplete }
     updateMessageByToolId,
     setIsAgentRunning,
     updateStats,
-    setTodos,
-    setUsageStats
+    setTodos
   } = useSession();
+  const { setUsageStats } = useUsageStats();
   const agentRef = useRef4(null);
   useEffect2(() => {
     let isMounted = true;
@@ -13801,7 +15678,7 @@ async function runAgent(config2) {
 // src/utils/auto-update.ts
 init_version();
 init_error_logger();
-import { execSync as execSync3, spawn } from "child_process";
+import { execSync as execSync3, spawn as spawn3 } from "child_process";
 import latestVersion from "latest-version";
 import { gt } from "semver";
 var UPDATE_CHECK_TIMEOUT = 3e3;
@@ -13843,7 +15720,7 @@ Updating Supatest CLI ${CLI_VERSION} \u2192 ${latest}...`);
         });
       }
       console.log("\u2713 Updated successfully\n");
-      const child = spawn(process.argv[0], process.argv.slice(1), {
+      const child = spawn3(process.argv[0], process.argv.slice(1), {
         stdio: "inherit",
         detached: false
       });
@@ -14128,6 +16005,33 @@ program.command("setup").description("Check prerequisites and set up required to
     process.exit(1);
   }
 });
+program.command("claude-login").description("Authenticate with Claude using OAuth (uses your Claude Pro/Max subscription)").action(async () => {
+  try {
+    await claudeLoginCommand();
+  } catch (error) {
+    logError(error, { source: "claude-login" });
+    logger.error(`Claude login failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+program.command("claude-logout").description("Sign out from Claude OAuth").action(async () => {
+  try {
+    await claudeLogoutCommand();
+  } catch (error) {
+    logError(error, { source: "claude-logout" });
+    logger.error(`Claude logout failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+program.command("claude-status").description("Show Claude OAuth authentication status").action(async () => {
+  try {
+    await claudeStatusCommand();
+  } catch (error) {
+    logError(error, { source: "claude-status" });
+    logger.error(`Claude status check failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
 var filteredArgv = process.argv.filter((arg, index) => {
   return !(arg === "--" && index > 1);
 });