claude-use 11.89.0 → 11.90.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -299,30 +299,30 @@ declare const LaunchSchema: z.ZodObject<{
299
299
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
300
300
  identity: "identity";
301
301
  model: "model";
302
+ route: "route";
302
303
  account: "account";
303
304
  provider: "provider";
305
+ version: "version";
304
306
  headroom: "headroom";
305
- route: "route";
307
+ duration: "duration";
306
308
  project: "project";
307
309
  vcs: "vcs";
308
310
  effort: "effort";
309
311
  advisor: "advisor";
310
- version: "version";
311
312
  outputStyle: "outputStyle";
312
313
  cost: "cost";
313
314
  dailyCost: "dailyCost";
314
315
  sessionName: "sessionName";
315
- duration: "duration";
316
316
  speed: "speed";
317
317
  extra: "extra";
318
318
  }>>>;
319
319
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
320
320
  context: "context";
321
321
  quota: "quota";
322
+ environment: "environment";
322
323
  addedDirs: "addedDirs";
323
324
  gitFiles: "gitFiles";
324
325
  memory: "memory";
325
- environment: "environment";
326
326
  sessionTime: "sessionTime";
327
327
  promptCache: "promptCache";
328
328
  compactions: "compactions";
@@ -345,10 +345,10 @@ declare const LaunchSchema: z.ZodObject<{
345
345
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
346
346
  context: "context";
347
347
  quota: "quota";
348
+ environment: "environment";
348
349
  addedDirs: "addedDirs";
349
350
  gitFiles: "gitFiles";
350
351
  memory: "memory";
351
- environment: "environment";
352
352
  sessionTime: "sessionTime";
353
353
  promptCache: "promptCache";
354
354
  compactions: "compactions";
@@ -362,10 +362,10 @@ declare const LaunchSchema: z.ZodObject<{
362
362
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
363
363
  context: "context";
364
364
  quota: "quota";
365
+ environment: "environment";
365
366
  addedDirs: "addedDirs";
366
367
  gitFiles: "gitFiles";
367
368
  memory: "memory";
368
- environment: "environment";
369
369
  sessionTime: "sessionTime";
370
370
  promptCache: "promptCache";
371
371
  compactions: "compactions";
@@ -424,10 +424,10 @@ declare const LaunchSchema: z.ZodObject<{
424
424
  hidden: "hidden";
425
425
  }>>;
426
426
  value: z.ZodOptional<z.ZodEnum<{
427
+ remaining: "remaining";
427
428
  tokens: "tokens";
428
429
  both: "both";
429
430
  percent: "percent";
430
- remaining: "remaining";
431
431
  }>>;
432
432
  estimate: z.ZodOptional<z.ZodEnum<{
433
433
  never: "never";
@@ -469,8 +469,8 @@ declare const LaunchSchema: z.ZodObject<{
469
469
  }, z.core.$strict>>;
470
470
  usage: z.ZodOptional<z.ZodObject<{
471
471
  value: z.ZodOptional<z.ZodEnum<{
472
- remaining: "remaining";
473
472
  used: "used";
473
+ remaining: "remaining";
474
474
  }>>;
475
475
  bar: z.ZodOptional<z.ZodBoolean>;
476
476
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -1529,30 +1529,30 @@ declare const ConfigProfileSchema: z.ZodObject<{
1529
1529
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
1530
1530
  identity: "identity";
1531
1531
  model: "model";
1532
+ route: "route";
1532
1533
  account: "account";
1533
1534
  provider: "provider";
1535
+ version: "version";
1534
1536
  headroom: "headroom";
1535
- route: "route";
1537
+ duration: "duration";
1536
1538
  project: "project";
1537
1539
  vcs: "vcs";
1538
1540
  effort: "effort";
1539
1541
  advisor: "advisor";
1540
- version: "version";
1541
1542
  outputStyle: "outputStyle";
1542
1543
  cost: "cost";
1543
1544
  dailyCost: "dailyCost";
1544
1545
  sessionName: "sessionName";
1545
- duration: "duration";
1546
1546
  speed: "speed";
1547
1547
  extra: "extra";
1548
1548
  }>>>;
1549
1549
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
1550
1550
  context: "context";
1551
1551
  quota: "quota";
1552
+ environment: "environment";
1552
1553
  addedDirs: "addedDirs";
1553
1554
  gitFiles: "gitFiles";
1554
1555
  memory: "memory";
1555
- environment: "environment";
1556
1556
  sessionTime: "sessionTime";
1557
1557
  promptCache: "promptCache";
1558
1558
  compactions: "compactions";
@@ -1575,10 +1575,10 @@ declare const ConfigProfileSchema: z.ZodObject<{
1575
1575
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
1576
1576
  context: "context";
1577
1577
  quota: "quota";
1578
+ environment: "environment";
1578
1579
  addedDirs: "addedDirs";
1579
1580
  gitFiles: "gitFiles";
1580
1581
  memory: "memory";
1581
- environment: "environment";
1582
1582
  sessionTime: "sessionTime";
1583
1583
  promptCache: "promptCache";
1584
1584
  compactions: "compactions";
@@ -1592,10 +1592,10 @@ declare const ConfigProfileSchema: z.ZodObject<{
1592
1592
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
1593
1593
  context: "context";
1594
1594
  quota: "quota";
1595
+ environment: "environment";
1595
1596
  addedDirs: "addedDirs";
1596
1597
  gitFiles: "gitFiles";
1597
1598
  memory: "memory";
1598
- environment: "environment";
1599
1599
  sessionTime: "sessionTime";
1600
1600
  promptCache: "promptCache";
1601
1601
  compactions: "compactions";
@@ -1654,10 +1654,10 @@ declare const ConfigProfileSchema: z.ZodObject<{
1654
1654
  hidden: "hidden";
1655
1655
  }>>;
1656
1656
  value: z.ZodOptional<z.ZodEnum<{
1657
+ remaining: "remaining";
1657
1658
  tokens: "tokens";
1658
1659
  both: "both";
1659
1660
  percent: "percent";
1660
- remaining: "remaining";
1661
1661
  }>>;
1662
1662
  estimate: z.ZodOptional<z.ZodEnum<{
1663
1663
  never: "never";
@@ -1699,8 +1699,8 @@ declare const ConfigProfileSchema: z.ZodObject<{
1699
1699
  }, z.core.$strict>>;
1700
1700
  usage: z.ZodOptional<z.ZodObject<{
1701
1701
  value: z.ZodOptional<z.ZodEnum<{
1702
- remaining: "remaining";
1703
1702
  used: "used";
1703
+ remaining: "remaining";
1704
1704
  }>>;
1705
1705
  bar: z.ZodOptional<z.ZodBoolean>;
1706
1706
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -2288,8 +2288,55 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2288
2288
  key: z.ZodType<trilean.JsonValue, unknown, z.core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
2289
2289
  }, z.core.$strip>], "kind">]>;
2290
2290
  }, z.core.$strict>]>>>;
2291
- extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
2291
+ models: z.ZodOptional<z.ZodObject<{
2292
+ pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
2293
+ virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
2294
+ mode: z.ZodEnum<{
2295
+ ordered: "ordered";
2296
+ "most-allowance": "most-allowance";
2297
+ "soonest-reset": "soonest-reset";
2298
+ spread: "spread";
2299
+ adaptive: "adaptive";
2300
+ "lowest-latency": "lowest-latency";
2301
+ "highest-success": "highest-success";
2302
+ cheapest: "cheapest";
2303
+ }>;
2304
+ members: z.ZodArray<z.ZodString>;
2305
+ }, z.core.$strict>, z.ZodNull]>>>;
2306
+ tiers: z.ZodOptional<z.ZodObject<{
2307
+ fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2308
+ opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2309
+ sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2310
+ haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2311
+ }, z.core.$strict>>;
2312
+ prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
2313
+ input: z.ZodNumber;
2314
+ output: z.ZodNumber;
2315
+ }, z.core.$strict>, z.ZodNull]>>>;
2316
+ hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
2317
+ show: z.ZodOptional<z.ZodArray<z.ZodString>>;
2318
+ same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
2319
+ distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
2320
+ families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
2321
+ names: z.ZodOptional<z.ZodArray<z.ZodString>>;
2322
+ mode: z.ZodOptional<z.ZodEnum<{
2323
+ ordered: "ordered";
2324
+ "most-allowance": "most-allowance";
2325
+ "soonest-reset": "soonest-reset";
2326
+ spread: "spread";
2327
+ adaptive: "adaptive";
2328
+ "lowest-latency": "lowest-latency";
2329
+ "highest-success": "highest-success";
2330
+ cheapest: "cheapest";
2331
+ }>>;
2332
+ context: z.ZodOptional<z.ZodNumber>;
2333
+ vision: z.ZodOptional<z.ZodBoolean>;
2334
+ tools: z.ZodOptional<z.ZodBoolean>;
2335
+ thinking: z.ZodOptional<z.ZodBoolean>;
2336
+ }, z.core.$strict>, z.ZodNull]>>>;
2337
+ }, z.core.$strict>>;
2292
2338
  $schema: z.ZodOptional<z.ZodString>;
2339
+ extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
2293
2340
  categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
2294
2341
  all: z.ZodOptional<z.ZodBoolean>;
2295
2342
  runtime: z.ZodOptional<z.ZodBoolean>;
@@ -2332,30 +2379,30 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2332
2379
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
2333
2380
  identity: "identity";
2334
2381
  model: "model";
2382
+ route: "route";
2335
2383
  account: "account";
2336
2384
  provider: "provider";
2385
+ version: "version";
2337
2386
  headroom: "headroom";
2338
- route: "route";
2387
+ duration: "duration";
2339
2388
  project: "project";
2340
2389
  vcs: "vcs";
2341
2390
  effort: "effort";
2342
2391
  advisor: "advisor";
2343
- version: "version";
2344
2392
  outputStyle: "outputStyle";
2345
2393
  cost: "cost";
2346
2394
  dailyCost: "dailyCost";
2347
2395
  sessionName: "sessionName";
2348
- duration: "duration";
2349
2396
  speed: "speed";
2350
2397
  extra: "extra";
2351
2398
  }>>>;
2352
2399
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
2353
2400
  context: "context";
2354
2401
  quota: "quota";
2402
+ environment: "environment";
2355
2403
  addedDirs: "addedDirs";
2356
2404
  gitFiles: "gitFiles";
2357
2405
  memory: "memory";
2358
- environment: "environment";
2359
2406
  sessionTime: "sessionTime";
2360
2407
  promptCache: "promptCache";
2361
2408
  compactions: "compactions";
@@ -2378,10 +2425,10 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2378
2425
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
2379
2426
  context: "context";
2380
2427
  quota: "quota";
2428
+ environment: "environment";
2381
2429
  addedDirs: "addedDirs";
2382
2430
  gitFiles: "gitFiles";
2383
2431
  memory: "memory";
2384
- environment: "environment";
2385
2432
  sessionTime: "sessionTime";
2386
2433
  promptCache: "promptCache";
2387
2434
  compactions: "compactions";
@@ -2395,10 +2442,10 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2395
2442
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
2396
2443
  context: "context";
2397
2444
  quota: "quota";
2445
+ environment: "environment";
2398
2446
  addedDirs: "addedDirs";
2399
2447
  gitFiles: "gitFiles";
2400
2448
  memory: "memory";
2401
- environment: "environment";
2402
2449
  sessionTime: "sessionTime";
2403
2450
  promptCache: "promptCache";
2404
2451
  compactions: "compactions";
@@ -2457,10 +2504,10 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2457
2504
  hidden: "hidden";
2458
2505
  }>>;
2459
2506
  value: z.ZodOptional<z.ZodEnum<{
2507
+ remaining: "remaining";
2460
2508
  tokens: "tokens";
2461
2509
  both: "both";
2462
2510
  percent: "percent";
2463
- remaining: "remaining";
2464
2511
  }>>;
2465
2512
  estimate: z.ZodOptional<z.ZodEnum<{
2466
2513
  never: "never";
@@ -2502,8 +2549,8 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2502
2549
  }, z.core.$strict>>;
2503
2550
  usage: z.ZodOptional<z.ZodObject<{
2504
2551
  value: z.ZodOptional<z.ZodEnum<{
2505
- remaining: "remaining";
2506
2552
  used: "used";
2553
+ remaining: "remaining";
2507
2554
  }>>;
2508
2555
  bar: z.ZodOptional<z.ZodBoolean>;
2509
2556
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -2861,53 +2908,6 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2861
2908
  }, z.core.$strict>>;
2862
2909
  }, z.core.$strict>>;
2863
2910
  }, z.core.$strict>>;
2864
- models: z.ZodOptional<z.ZodObject<{
2865
- pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
2866
- virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
2867
- mode: z.ZodEnum<{
2868
- ordered: "ordered";
2869
- "most-allowance": "most-allowance";
2870
- "soonest-reset": "soonest-reset";
2871
- spread: "spread";
2872
- adaptive: "adaptive";
2873
- "lowest-latency": "lowest-latency";
2874
- "highest-success": "highest-success";
2875
- cheapest: "cheapest";
2876
- }>;
2877
- members: z.ZodArray<z.ZodString>;
2878
- }, z.core.$strict>, z.ZodNull]>>>;
2879
- tiers: z.ZodOptional<z.ZodObject<{
2880
- fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2881
- opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2882
- sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2883
- haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
2884
- }, z.core.$strict>>;
2885
- prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
2886
- input: z.ZodNumber;
2887
- output: z.ZodNumber;
2888
- }, z.core.$strict>, z.ZodNull]>>>;
2889
- hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
2890
- show: z.ZodOptional<z.ZodArray<z.ZodString>>;
2891
- same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
2892
- distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
2893
- families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
2894
- names: z.ZodOptional<z.ZodArray<z.ZodString>>;
2895
- mode: z.ZodOptional<z.ZodEnum<{
2896
- ordered: "ordered";
2897
- "most-allowance": "most-allowance";
2898
- "soonest-reset": "soonest-reset";
2899
- spread: "spread";
2900
- adaptive: "adaptive";
2901
- "lowest-latency": "lowest-latency";
2902
- "highest-success": "highest-success";
2903
- cheapest: "cheapest";
2904
- }>>;
2905
- context: z.ZodOptional<z.ZodNumber>;
2906
- vision: z.ZodOptional<z.ZodBoolean>;
2907
- tools: z.ZodOptional<z.ZodBoolean>;
2908
- thinking: z.ZodOptional<z.ZodBoolean>;
2909
- }, z.core.$strict>, z.ZodNull]>>>;
2910
- }, z.core.$strict>>;
2911
2911
  path: z.ZodString;
2912
2912
  configProfile: z.ZodOptional<z.ZodString>;
2913
2913
  identity: z.ZodOptional<z.ZodString>;
@@ -3064,8 +3064,55 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3064
3064
  key: z.ZodType<trilean.JsonValue, unknown, z.core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
3065
3065
  }, z.core.$strip>], "kind">]>;
3066
3066
  }, z.core.$strict>]>>>;
3067
- extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
3067
+ models: z.ZodOptional<z.ZodObject<{
3068
+ pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
3069
+ virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
3070
+ mode: z.ZodEnum<{
3071
+ ordered: "ordered";
3072
+ "most-allowance": "most-allowance";
3073
+ "soonest-reset": "soonest-reset";
3074
+ spread: "spread";
3075
+ adaptive: "adaptive";
3076
+ "lowest-latency": "lowest-latency";
3077
+ "highest-success": "highest-success";
3078
+ cheapest: "cheapest";
3079
+ }>;
3080
+ members: z.ZodArray<z.ZodString>;
3081
+ }, z.core.$strict>, z.ZodNull]>>>;
3082
+ tiers: z.ZodOptional<z.ZodObject<{
3083
+ fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3084
+ opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3085
+ sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3086
+ haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3087
+ }, z.core.$strict>>;
3088
+ prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
3089
+ input: z.ZodNumber;
3090
+ output: z.ZodNumber;
3091
+ }, z.core.$strict>, z.ZodNull]>>>;
3092
+ hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
3093
+ show: z.ZodOptional<z.ZodArray<z.ZodString>>;
3094
+ same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
3095
+ distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
3096
+ families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
3097
+ names: z.ZodOptional<z.ZodArray<z.ZodString>>;
3098
+ mode: z.ZodOptional<z.ZodEnum<{
3099
+ ordered: "ordered";
3100
+ "most-allowance": "most-allowance";
3101
+ "soonest-reset": "soonest-reset";
3102
+ spread: "spread";
3103
+ adaptive: "adaptive";
3104
+ "lowest-latency": "lowest-latency";
3105
+ "highest-success": "highest-success";
3106
+ cheapest: "cheapest";
3107
+ }>>;
3108
+ context: z.ZodOptional<z.ZodNumber>;
3109
+ vision: z.ZodOptional<z.ZodBoolean>;
3110
+ tools: z.ZodOptional<z.ZodBoolean>;
3111
+ thinking: z.ZodOptional<z.ZodBoolean>;
3112
+ }, z.core.$strict>, z.ZodNull]>>>;
3113
+ }, z.core.$strict>>;
3068
3114
  $schema: z.ZodOptional<z.ZodString>;
3115
+ extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
3069
3116
  categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
3070
3117
  all: z.ZodOptional<z.ZodBoolean>;
3071
3118
  runtime: z.ZodOptional<z.ZodBoolean>;
@@ -3108,30 +3155,30 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3108
3155
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3109
3156
  identity: "identity";
3110
3157
  model: "model";
3158
+ route: "route";
3111
3159
  account: "account";
3112
3160
  provider: "provider";
3161
+ version: "version";
3113
3162
  headroom: "headroom";
3114
- route: "route";
3163
+ duration: "duration";
3115
3164
  project: "project";
3116
3165
  vcs: "vcs";
3117
3166
  effort: "effort";
3118
3167
  advisor: "advisor";
3119
- version: "version";
3120
3168
  outputStyle: "outputStyle";
3121
3169
  cost: "cost";
3122
3170
  dailyCost: "dailyCost";
3123
3171
  sessionName: "sessionName";
3124
- duration: "duration";
3125
3172
  speed: "speed";
3126
3173
  extra: "extra";
3127
3174
  }>>>;
3128
3175
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3129
3176
  context: "context";
3130
3177
  quota: "quota";
3178
+ environment: "environment";
3131
3179
  addedDirs: "addedDirs";
3132
3180
  gitFiles: "gitFiles";
3133
3181
  memory: "memory";
3134
- environment: "environment";
3135
3182
  sessionTime: "sessionTime";
3136
3183
  promptCache: "promptCache";
3137
3184
  compactions: "compactions";
@@ -3154,10 +3201,10 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3154
3201
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
3155
3202
  context: "context";
3156
3203
  quota: "quota";
3204
+ environment: "environment";
3157
3205
  addedDirs: "addedDirs";
3158
3206
  gitFiles: "gitFiles";
3159
3207
  memory: "memory";
3160
- environment: "environment";
3161
3208
  sessionTime: "sessionTime";
3162
3209
  promptCache: "promptCache";
3163
3210
  compactions: "compactions";
@@ -3171,10 +3218,10 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3171
3218
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3172
3219
  context: "context";
3173
3220
  quota: "quota";
3221
+ environment: "environment";
3174
3222
  addedDirs: "addedDirs";
3175
3223
  gitFiles: "gitFiles";
3176
3224
  memory: "memory";
3177
- environment: "environment";
3178
3225
  sessionTime: "sessionTime";
3179
3226
  promptCache: "promptCache";
3180
3227
  compactions: "compactions";
@@ -3233,10 +3280,10 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3233
3280
  hidden: "hidden";
3234
3281
  }>>;
3235
3282
  value: z.ZodOptional<z.ZodEnum<{
3283
+ remaining: "remaining";
3236
3284
  tokens: "tokens";
3237
3285
  both: "both";
3238
3286
  percent: "percent";
3239
- remaining: "remaining";
3240
3287
  }>>;
3241
3288
  estimate: z.ZodOptional<z.ZodEnum<{
3242
3289
  never: "never";
@@ -3278,8 +3325,8 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3278
3325
  }, z.core.$strict>>;
3279
3326
  usage: z.ZodOptional<z.ZodObject<{
3280
3327
  value: z.ZodOptional<z.ZodEnum<{
3281
- remaining: "remaining";
3282
3328
  used: "used";
3329
+ remaining: "remaining";
3283
3330
  }>>;
3284
3331
  bar: z.ZodOptional<z.ZodBoolean>;
3285
3332
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -3637,53 +3684,6 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3637
3684
  }, z.core.$strict>>;
3638
3685
  }, z.core.$strict>>;
3639
3686
  }, z.core.$strict>>;
3640
- models: z.ZodOptional<z.ZodObject<{
3641
- pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
3642
- virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
3643
- mode: z.ZodEnum<{
3644
- ordered: "ordered";
3645
- "most-allowance": "most-allowance";
3646
- "soonest-reset": "soonest-reset";
3647
- spread: "spread";
3648
- adaptive: "adaptive";
3649
- "lowest-latency": "lowest-latency";
3650
- "highest-success": "highest-success";
3651
- cheapest: "cheapest";
3652
- }>;
3653
- members: z.ZodArray<z.ZodString>;
3654
- }, z.core.$strict>, z.ZodNull]>>>;
3655
- tiers: z.ZodOptional<z.ZodObject<{
3656
- fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3657
- opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3658
- sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3659
- haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
3660
- }, z.core.$strict>>;
3661
- prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
3662
- input: z.ZodNumber;
3663
- output: z.ZodNumber;
3664
- }, z.core.$strict>, z.ZodNull]>>>;
3665
- hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
3666
- show: z.ZodOptional<z.ZodArray<z.ZodString>>;
3667
- same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
3668
- distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
3669
- families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
3670
- names: z.ZodOptional<z.ZodArray<z.ZodString>>;
3671
- mode: z.ZodOptional<z.ZodEnum<{
3672
- ordered: "ordered";
3673
- "most-allowance": "most-allowance";
3674
- "soonest-reset": "soonest-reset";
3675
- spread: "spread";
3676
- adaptive: "adaptive";
3677
- "lowest-latency": "lowest-latency";
3678
- "highest-success": "highest-success";
3679
- cheapest: "cheapest";
3680
- }>>;
3681
- context: z.ZodOptional<z.ZodNumber>;
3682
- vision: z.ZodOptional<z.ZodBoolean>;
3683
- tools: z.ZodOptional<z.ZodBoolean>;
3684
- thinking: z.ZodOptional<z.ZodBoolean>;
3685
- }, z.core.$strict>, z.ZodNull]>>>;
3686
- }, z.core.$strict>>;
3687
3687
  path: z.ZodString;
3688
3688
  configProfile: z.ZodOptional<z.ZodString>;
3689
3689
  identity: z.ZodOptional<z.ZodString>;
@@ -3841,20 +3841,6 @@ declare const PortableConfigSchema: z.ZodObject<{
3841
3841
  key: z.ZodType<trilean.JsonValue, unknown, z.core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
3842
3842
  }, z.core.$strip>], "kind">]>;
3843
3843
  }, z.core.$strict>]>>>;
3844
- $schema: z.ZodOptional<z.ZodString>;
3845
- categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
3846
- all: z.ZodOptional<z.ZodBoolean>;
3847
- runtime: z.ZodOptional<z.ZodBoolean>;
3848
- history: z.ZodOptional<z.ZodBoolean>;
3849
- knowledge: z.ZodOptional<z.ZodBoolean>;
3850
- settings: z.ZodOptional<z.ZodBoolean>;
3851
- }, z.core.$strict>, z.ZodTransform<Partial<Record<"runtime" | "history" | "knowledge" | "settings", boolean>>, {
3852
- all?: boolean | undefined;
3853
- runtime?: boolean | undefined;
3854
- history?: boolean | undefined;
3855
- knowledge?: boolean | undefined;
3856
- settings?: boolean | undefined;
3857
- }>>>;
3858
3844
  models: z.ZodOptional<z.ZodObject<{
3859
3845
  pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
3860
3846
  virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
@@ -3902,6 +3888,20 @@ declare const PortableConfigSchema: z.ZodObject<{
3902
3888
  thinking: z.ZodOptional<z.ZodBoolean>;
3903
3889
  }, z.core.$strict>, z.ZodNull]>>>;
3904
3890
  }, z.core.$strict>>;
3891
+ $schema: z.ZodOptional<z.ZodString>;
3892
+ categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
3893
+ all: z.ZodOptional<z.ZodBoolean>;
3894
+ runtime: z.ZodOptional<z.ZodBoolean>;
3895
+ history: z.ZodOptional<z.ZodBoolean>;
3896
+ knowledge: z.ZodOptional<z.ZodBoolean>;
3897
+ settings: z.ZodOptional<z.ZodBoolean>;
3898
+ }, z.core.$strict>, z.ZodTransform<Partial<Record<"runtime" | "history" | "knowledge" | "settings", boolean>>, {
3899
+ all?: boolean | undefined;
3900
+ runtime?: boolean | undefined;
3901
+ history?: boolean | undefined;
3902
+ knowledge?: boolean | undefined;
3903
+ settings?: boolean | undefined;
3904
+ }>>>;
3905
3905
  extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
3906
3906
  launch: z.ZodOptional<z.ZodObject<{
3907
3907
  skipPermissions: z.ZodOptional<z.ZodBoolean>;
@@ -3931,30 +3931,30 @@ declare const PortableConfigSchema: z.ZodObject<{
3931
3931
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3932
3932
  identity: "identity";
3933
3933
  model: "model";
3934
+ route: "route";
3934
3935
  account: "account";
3935
3936
  provider: "provider";
3937
+ version: "version";
3936
3938
  headroom: "headroom";
3937
- route: "route";
3939
+ duration: "duration";
3938
3940
  project: "project";
3939
3941
  vcs: "vcs";
3940
3942
  effort: "effort";
3941
3943
  advisor: "advisor";
3942
- version: "version";
3943
3944
  outputStyle: "outputStyle";
3944
3945
  cost: "cost";
3945
3946
  dailyCost: "dailyCost";
3946
3947
  sessionName: "sessionName";
3947
- duration: "duration";
3948
3948
  speed: "speed";
3949
3949
  extra: "extra";
3950
3950
  }>>>;
3951
3951
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3952
3952
  context: "context";
3953
3953
  quota: "quota";
3954
+ environment: "environment";
3954
3955
  addedDirs: "addedDirs";
3955
3956
  gitFiles: "gitFiles";
3956
3957
  memory: "memory";
3957
- environment: "environment";
3958
3958
  sessionTime: "sessionTime";
3959
3959
  promptCache: "promptCache";
3960
3960
  compactions: "compactions";
@@ -3977,10 +3977,10 @@ declare const PortableConfigSchema: z.ZodObject<{
3977
3977
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
3978
3978
  context: "context";
3979
3979
  quota: "quota";
3980
+ environment: "environment";
3980
3981
  addedDirs: "addedDirs";
3981
3982
  gitFiles: "gitFiles";
3982
3983
  memory: "memory";
3983
- environment: "environment";
3984
3984
  sessionTime: "sessionTime";
3985
3985
  promptCache: "promptCache";
3986
3986
  compactions: "compactions";
@@ -3994,10 +3994,10 @@ declare const PortableConfigSchema: z.ZodObject<{
3994
3994
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3995
3995
  context: "context";
3996
3996
  quota: "quota";
3997
+ environment: "environment";
3997
3998
  addedDirs: "addedDirs";
3998
3999
  gitFiles: "gitFiles";
3999
4000
  memory: "memory";
4000
- environment: "environment";
4001
4001
  sessionTime: "sessionTime";
4002
4002
  promptCache: "promptCache";
4003
4003
  compactions: "compactions";
@@ -4056,10 +4056,10 @@ declare const PortableConfigSchema: z.ZodObject<{
4056
4056
  hidden: "hidden";
4057
4057
  }>>;
4058
4058
  value: z.ZodOptional<z.ZodEnum<{
4059
+ remaining: "remaining";
4059
4060
  tokens: "tokens";
4060
4061
  both: "both";
4061
4062
  percent: "percent";
4062
- remaining: "remaining";
4063
4063
  }>>;
4064
4064
  estimate: z.ZodOptional<z.ZodEnum<{
4065
4065
  never: "never";
@@ -4101,8 +4101,8 @@ declare const PortableConfigSchema: z.ZodObject<{
4101
4101
  }, z.core.$strict>>;
4102
4102
  usage: z.ZodOptional<z.ZodObject<{
4103
4103
  value: z.ZodOptional<z.ZodEnum<{
4104
- remaining: "remaining";
4105
4104
  used: "used";
4105
+ remaining: "remaining";
4106
4106
  }>>;
4107
4107
  bar: z.ZodOptional<z.ZodBoolean>;
4108
4108
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -4687,30 +4687,30 @@ declare const GlobalConfigSchema: z.ZodObject<{
4687
4687
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
4688
4688
  identity: "identity";
4689
4689
  model: "model";
4690
+ route: "route";
4690
4691
  account: "account";
4691
4692
  provider: "provider";
4693
+ version: "version";
4692
4694
  headroom: "headroom";
4693
- route: "route";
4695
+ duration: "duration";
4694
4696
  project: "project";
4695
4697
  vcs: "vcs";
4696
4698
  effort: "effort";
4697
4699
  advisor: "advisor";
4698
- version: "version";
4699
4700
  outputStyle: "outputStyle";
4700
4701
  cost: "cost";
4701
4702
  dailyCost: "dailyCost";
4702
4703
  sessionName: "sessionName";
4703
- duration: "duration";
4704
4704
  speed: "speed";
4705
4705
  extra: "extra";
4706
4706
  }>>>;
4707
4707
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
4708
4708
  context: "context";
4709
4709
  quota: "quota";
4710
+ environment: "environment";
4710
4711
  addedDirs: "addedDirs";
4711
4712
  gitFiles: "gitFiles";
4712
4713
  memory: "memory";
4713
- environment: "environment";
4714
4714
  sessionTime: "sessionTime";
4715
4715
  promptCache: "promptCache";
4716
4716
  compactions: "compactions";
@@ -4733,10 +4733,10 @@ declare const GlobalConfigSchema: z.ZodObject<{
4733
4733
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
4734
4734
  context: "context";
4735
4735
  quota: "quota";
4736
+ environment: "environment";
4736
4737
  addedDirs: "addedDirs";
4737
4738
  gitFiles: "gitFiles";
4738
4739
  memory: "memory";
4739
- environment: "environment";
4740
4740
  sessionTime: "sessionTime";
4741
4741
  promptCache: "promptCache";
4742
4742
  compactions: "compactions";
@@ -4750,10 +4750,10 @@ declare const GlobalConfigSchema: z.ZodObject<{
4750
4750
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
4751
4751
  context: "context";
4752
4752
  quota: "quota";
4753
+ environment: "environment";
4753
4754
  addedDirs: "addedDirs";
4754
4755
  gitFiles: "gitFiles";
4755
4756
  memory: "memory";
4756
- environment: "environment";
4757
4757
  sessionTime: "sessionTime";
4758
4758
  promptCache: "promptCache";
4759
4759
  compactions: "compactions";
@@ -4812,10 +4812,10 @@ declare const GlobalConfigSchema: z.ZodObject<{
4812
4812
  hidden: "hidden";
4813
4813
  }>>;
4814
4814
  value: z.ZodOptional<z.ZodEnum<{
4815
+ remaining: "remaining";
4815
4816
  tokens: "tokens";
4816
4817
  both: "both";
4817
4818
  percent: "percent";
4818
- remaining: "remaining";
4819
4819
  }>>;
4820
4820
  estimate: z.ZodOptional<z.ZodEnum<{
4821
4821
  never: "never";
@@ -4857,8 +4857,8 @@ declare const GlobalConfigSchema: z.ZodObject<{
4857
4857
  }, z.core.$strict>>;
4858
4858
  usage: z.ZodOptional<z.ZodObject<{
4859
4859
  value: z.ZodOptional<z.ZodEnum<{
4860
- remaining: "remaining";
4861
4860
  used: "used";
4861
+ remaining: "remaining";
4862
4862
  }>>;
4863
4863
  bar: z.ZodOptional<z.ZodBoolean>;
4864
4864
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -7534,7 +7534,7 @@ interface RcInjectDeps {
7534
7534
  readonly newUuid: () => string;
7535
7535
  }
7536
7536
  /**
7537
- * Injects one user-message prompt into an observed session: the documented client-half write, `POST /v1/code/sessions/{id}/events`, authenticated by the observed bearer and carrying the observed protocol headers. The result is the sequence numbers the real service assigned, or a verbose failure. A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
7537
+ * Injects one user-message prompt into an observed session: the documented client-half write, `POST /v1/code/sessions/{id}/events`, authenticated by the observed bearer and carrying the observed protocol headers, the observed `anthropic-client-platform` included, so the door never names an app it is not. The result is the sequence numbers the real service assigned, or a verbose failure. A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
7538
7538
  */
7539
7539
  declare function injectRcUserMessage(deps: RcInjectDeps, sessionId: string, text: string): Promise<RcEventWriteResult>;
7540
7540
  /** The decision an answer carries: approve or deny, with the message a denial shows the worker (the protocol's allow result has no text field, so an approval carries none). */
@@ -8060,6 +8060,143 @@ interface FrontDoorRcControl {
8060
8060
  /** Builds the control client: every request presents the control token, and a non-2xx answer becomes the verbose message the door sent with it. */
8061
8061
  declare function frontDoorRcControl(transport: RcControlTransport, token: string): FrontDoorRcControl;
8062
8062
 
8063
+ /** What a cache stores for one credential: the token, when it was fetched, the source that produced it (a non-secret descriptor, kept so `check` and the launch log can still say where the token came from), and, in the file store, the owner it was cached for (`identity <id>`, `provider <name>`), which the file store records on every write; the Keychain store files each entry under its owner's account and records none. A file-store entry with no `owner` was written before owners were recorded. */
8064
+ declare const CachedCredentialSchema: z.ZodObject<{
8065
+ token: z.ZodString;
8066
+ fetchedAt: z.ZodNumber;
8067
+ source: z.ZodUnion<readonly [z.ZodObject<{
8068
+ env: z.ZodString;
8069
+ }, z.core.$strict>, z.ZodObject<{
8070
+ file: z.ZodString;
8071
+ }, z.core.$strict>, z.ZodObject<{
8072
+ interactive: z.ZodOptional<z.ZodBoolean>;
8073
+ timeoutMs: z.ZodOptional<z.ZodInt>;
8074
+ command: z.ZodTuple<[z.ZodString], z.ZodString>;
8075
+ }, z.core.$strict>, z.ZodObject<{
8076
+ interactive: z.ZodOptional<z.ZodBoolean>;
8077
+ timeoutMs: z.ZodOptional<z.ZodInt>;
8078
+ op: z.ZodString;
8079
+ }, z.core.$strict>, z.ZodObject<{
8080
+ interactive: z.ZodOptional<z.ZodBoolean>;
8081
+ timeoutMs: z.ZodOptional<z.ZodInt>;
8082
+ keychain: z.ZodObject<{
8083
+ service: z.ZodString;
8084
+ account: z.ZodOptional<z.ZodString>;
8085
+ }, z.core.$strict>;
8086
+ }, z.core.$strict>, z.ZodObject<{
8087
+ literal: z.ZodString;
8088
+ }, z.core.$strict>]>;
8089
+ owner: z.ZodOptional<z.ZodString>;
8090
+ }, z.core.$strict>;
8091
+ type CachedCredential = z.infer<typeof CachedCredentialSchema>;
8092
+ /**
8093
+ * Where cached credentials live, injected so resolution and its tests need neither the Keychain nor a real directory. `owner` names what the credential belongs to (`identity work`, `provider z`) and is the entry's key; `store` picks the backing store. `read` returns undefined for a missing or unreadable entry, since an entry that cannot be used is the same as no entry.
8094
+ */
8095
+ interface CredentialCachePort {
8096
+ readonly read: (store: CredentialCacheStore, owner: string) => CachedCredential | undefined;
8097
+ readonly write: (store: CredentialCacheStore, owner: string, entry: CachedCredential) => void;
8098
+ readonly remove: (store: CredentialCacheStore, owner: string) => void;
8099
+ }
8100
+ /**
8101
+ * What the cache holds for one credential, without the token: whether there is an entry, how old it is, and whether it is still within the block's TTL. `expiresInMs` is absent for a block with no expiry.
8102
+ */
8103
+ type CachedCredentialState = {
8104
+ readonly store: CredentialCacheStore;
8105
+ readonly status: "empty";
8106
+ }
8107
+ /** The store cannot be read here (the keychain store configured on a platform without a Keychain): reported with its reason rather than failing the whole report. */
8108
+ | {
8109
+ readonly store: CredentialCacheStore;
8110
+ readonly status: "unreadable";
8111
+ readonly reason: string;
8112
+ } | {
8113
+ readonly store: CredentialCacheStore;
8114
+ readonly status: "fresh" | "expired";
8115
+ readonly ageMs: number;
8116
+ readonly expiresInMs?: number;
8117
+ };
8118
+
8119
+ /** What reading one `file` source found: nothing at that path, or its contents and permission bits. `mode` is undefined on a platform with no POSIX permission bits (Windows), where the looseness check cannot apply. */
8120
+ type SecretFileRead = {
8121
+ readonly found: false;
8122
+ } | {
8123
+ readonly found: true;
8124
+ readonly content: string;
8125
+ readonly mode: number | undefined;
8126
+ };
8127
+ /** The outcome of one credential command. `stderr` is empty for an interactive run, whose stderr goes to the terminal so a person sees any prompt. */
8128
+ interface CredentialCommandResult {
8129
+ readonly status: number | null;
8130
+ readonly stdout: string;
8131
+ readonly stderr: string;
8132
+ readonly timedOut: boolean;
8133
+ }
8134
+ /**
8135
+ * Everything resolving a credential needs from the outside world, injected so the resolver (and every launcher test) runs without `op`, the Keychain, real secret files or a terminal. `src/realPorts.ts` wires the real one; tests wire a fake.
8136
+ */
8137
+ interface CredentialPort {
8138
+ /** Reads a `file` source's path (absolute or `~`-rooted). */
8139
+ readonly readSecretFile: (filePath: string) => SecretFileRead;
8140
+ /** Runs a command source's argv directly (no shell) under a timeout, capturing stdout. An interactive run inherits the terminal's stdin and stderr so a person can answer a prompt. */
8141
+ readonly runCommand: (argv: readonly [string, ...string[]], options: {
8142
+ readonly timeoutMs: number;
8143
+ readonly interactive: boolean;
8144
+ }) => CredentialCommandResult;
8145
+ /** Whether a person can answer a prompt now: standard input is a terminal, or there is a desktop session to show a dialog in. */
8146
+ readonly personPresent: () => boolean;
8147
+ /** Where cached credentials live, used only for a credential block that asks for caching. Omit to resolve every launch from the sources. */
8148
+ readonly cache?: CredentialCacheEnv;
8149
+ }
8150
+ /** One source as `check`, `doctor` and every `--json` output report it: its kind plus the same non-secret identifying detail `describeSource` prints. */
8151
+ type CredentialSourceSummary = {
8152
+ readonly kind: "env";
8153
+ readonly variable: string;
8154
+ } | {
8155
+ readonly kind: "file";
8156
+ readonly path: string;
8157
+ } | {
8158
+ readonly kind: "command";
8159
+ readonly program: string;
8160
+ } | {
8161
+ readonly kind: "op";
8162
+ readonly reference: string;
8163
+ } | {
8164
+ readonly kind: "keychain";
8165
+ readonly service: string;
8166
+ readonly account?: string;
8167
+ } | {
8168
+ readonly kind: "literal";
8169
+ };
8170
+ /** A credential block as it is reported: its effective target and each source's summary, in order. */
8171
+ interface CredentialSummary {
8172
+ readonly target: CredentialTarget;
8173
+ readonly sources: readonly CredentialSourceSummary[];
8174
+ /** The block's cache setting when it asks for caching: how long a token is kept (absent for no expiry) and where. Carried as the config schema's own type, since the summary passes the parsed block's setting through unchanged. */
8175
+ readonly cache?: CredentialCache;
8176
+ }
8177
+ /** What caching a credential needs beyond the block's own `cache` setting: the port holding entries, the platform that picks the default store, and the clock the TTL is measured on. */
8178
+ interface CredentialCacheEnv {
8179
+ readonly port: CredentialCachePort;
8180
+ readonly platform: NodeJS.Platform;
8181
+ readonly now: () => number;
8182
+ }
8183
+
8184
+ /** The result of a successful discovery. */
8185
+ interface DiscoveredClaudeBinary {
8186
+ /** Full path to the discovered `claude` executable. */
8187
+ path: string;
8188
+ /** Which strategy found it. */
8189
+ source: "versions-dir" | "path-fallback";
8190
+ /** The version string, when discovered via the versions directory. */
8191
+ version?: string;
8192
+ }
8193
+ /** What a launch asks binary discovery for: nothing (the highest installed version) or an exact version. */
8194
+ interface ClaudeBinaryRequest {
8195
+ readonly version?: string;
8196
+ }
8197
+ /** Discovers the real `claude` binary to spawn, for the version a launch asked for. Injected into the launcher so it never reads the filesystem or PATH itself. */
8198
+ type ClaudeBinaryResolver = (request?: Readonly<ClaudeBinaryRequest>) => DiscoveredClaudeBinary;
8199
+
8063
8200
  /** What an `lstat` (which never follows symlinks) reports about one path, narrowed to what authenticating the socket needs. */
8064
8201
  interface SocketPathStat {
8065
8202
  readonly kind: "dir" | "file" | "socket" | "symlink" | "other";
@@ -8093,32 +8230,271 @@ interface AllowlistFileProblem {
8093
8230
  readonly repairable: boolean;
8094
8231
  }
8095
8232
 
8233
+ /** The outcome of one external command, as `RunPort` reports it. */
8234
+ interface ReplayRunResult {
8235
+ readonly status: number | null;
8236
+ readonly stdout: string;
8237
+ readonly stderr: string;
8238
+ }
8239
+ /** Runs an external command without blocking the calling thread. */
8240
+ type AsyncRun = (command: string, args: readonly string[]) => Promise<ReplayRunResult>;
8241
+
8242
+ /** The effects a hold needs, so it runs against fakes in tests. */
8243
+ interface HoldPort {
8244
+ /** Whether a person is watching: standard input and standard output are both terminals. A launch nobody watches is never held. */
8245
+ readonly attended: () => boolean;
8246
+ /** Blocks for `ms` milliseconds. */
8247
+ readonly sleep: (ms: number) => void;
8248
+ /** Blocks until one key is pressed, and says whether it was the interrupt key (Ctrl-C), which a terminal in the mode this reads in delivers as a byte and not as a signal. */
8249
+ readonly waitForKey: () => "key" | "interrupt";
8250
+ }
8251
+ /** What a hold decided: carry on with the launch, or the person cancelled it. */
8252
+ type HoldOutcome = "go" | "cancelled";
8253
+
8254
+ /** What a compaction came to. A failure is thrown. */
8255
+ type CompactionResult = {
8256
+ readonly kind: "compacted";
8257
+ readonly beforeTokens?: number;
8258
+ readonly afterTokens?: number;
8259
+ } | {
8260
+ readonly kind: "unchanged";
8261
+ readonly reason: string;
8262
+ };
8263
+
8096
8264
  /**
8097
- * A secondary pre-pipeline surface the listener answers under one path prefix: the typed Remote Control API. The listener owns only the dispatch (the prefix and the not-matched 404); the handle itself is whatever the door built, so this file stays independent of the API framework behind it.
8265
+ * A session's `/goal` as its transcript records it, read with no effect on the session: Claude Code keeps no goal state anywhere a process outside it can ask, so the transcript is the one source a reader has.
8266
+ *
8267
+ * Every goal change is a `goal_status` attachment row (`{"type":"attachment","attachment":{"type":"goal_status",...}}`), as the 2.1.319 CLI writes them and as its own resume restores a goal from them: setting a goal writes `{ met: false, sentinel: true, condition }`; clearing it writes `{ met: true, sentinel: true, condition }`; each evaluation the goal check makes and finds not yet met writes `{ met: false, condition, reason }`; a met goal writes `met: true` and a failed one `failed: true`, both ending it. The rows are read in order, so the last change wins.
8098
8268
  */
8099
- interface PrePipelineApi {
8100
- /** The path prefix every request of this surface arrives under, outside the routed URL space. */
8101
- readonly pathPrefix: string;
8102
- /** Serves one request, resolving with whether a procedure under the prefix matched; the listener answers the 404 itself when one did not. */
8103
- readonly handle: (request: IncomingMessage, response: ServerResponse) => Promise<{
8104
- readonly matched: boolean;
8105
- }>;
8269
+ /** One goal as the transcript records it: the condition, how many turns the goal check has evaluated it on, and the check's last stated reason when it has given one. */
8270
+ interface TranscriptGoal {
8271
+ readonly condition: string;
8272
+ readonly iterations: number;
8273
+ readonly lastCheck?: string;
8106
8274
  }
8107
8275
 
8276
+ /** The brand only `rcSelfHostEventDial` puts on a dial: not exported, so no other code can make a value of the type. */
8277
+ declare const SELF_HOST_DIAL: unique symbol;
8108
8278
  /**
8109
- * The Remote Control operations as a typed oRPC API, so programmatic consumers (automation, a mobile or web client, another of this user's tools) get a generated type-safe client instead of hand-rolled HTTP. One procedure per existing operation, each wrapping the same operation the bespoke token-gated routes wrap (the routes stay: the CLI uses them), with inputs and outputs validating through the Zod schemas of `rcSchemas.ts`, which the operations' own values must satisfy, so contract and behaviour share one schema source and cannot drift apart silently.
8279
+ * A dial that reaches the door's own self-hosted surface and nothing else: the one dial a command written as a person's app may ride. Unlike the client half's other dials (`lateRcEventDial`), which fall back to the real API host while no target is resolved, this one refuses: a write whose target is not resolved, or resolves to anything but a loopback address, is never sent.
8280
+ */
8281
+ interface RcSelfHostEventDial {
8282
+ readonly [SELF_HOST_DIAL]: true;
8283
+ readonly writeEvents: RcEventDial["writeEvents"];
8284
+ }
8285
+ /** What a person's-app write needs: the client half's credential accessors and id minting, and the self-hosted dial in place of the general one. */
8286
+ type RcPersonWriteDeps = Omit<RcInjectDeps, "dial"> & {
8287
+ readonly dial: RcSelfHostEventDial;
8288
+ };
8289
+ /** Everything the self-hosted route needs, injected so it runs against fakes in unit tests. */
8290
+ interface RcSelfHostCommandDeps {
8291
+ /** What writing a command as a person's app needs, its dial the door's own surface alone. */
8292
+ readonly personWrite: RcPersonWriteDeps;
8293
+ /** Why the door's own surface cannot take a command now (it is not bound, as when the door runs self-hosted without a transparent surface), or undefined when it can. */
8294
+ readonly unavailable: () => string | undefined;
8295
+ /** The client attachment's fan-out, on which the worker's answer arrives. */
8296
+ readonly fanout: RcEventFanout;
8297
+ /** The Claude Code version the session's worker last reported in a `system/init`, or undefined when none has been observed. */
8298
+ readonly versionOf: (sessionId: string) => string | undefined;
8299
+ /** Arms one timer, returning the function that cancels it: `setTimeout` in production, a controllable clock in tests. */
8300
+ readonly setTimer: (action: () => void, ms: number) => () => void;
8301
+ /** How long to wait when the caller names no bound. */
8302
+ readonly defaultWaitMs: number;
8303
+ }
8304
+ /** One command this route runs. */
8305
+ type RcSelfHostCommand = {
8306
+ readonly kind: "goal-get";
8307
+ } | {
8308
+ readonly kind: "goal-set";
8309
+ readonly condition: string;
8310
+ } | {
8311
+ readonly kind: "goal-clear";
8312
+ } | {
8313
+ readonly kind: "compact";
8314
+ readonly instructions: string | undefined;
8315
+ };
8316
+ /** What each command reports. */
8317
+ interface RcSelfHostReports {
8318
+ readonly "goal-get": {
8319
+ readonly goal: {
8320
+ readonly condition: string;
8321
+ readonly iterations: number;
8322
+ readonly lastCheck?: string;
8323
+ } | null;
8324
+ };
8325
+ readonly "goal-set": {
8326
+ readonly condition: string;
8327
+ };
8328
+ readonly "goal-clear": {
8329
+ readonly cleared: string | null;
8330
+ };
8331
+ readonly compact: {
8332
+ readonly trigger: string;
8333
+ readonly preTokens: number;
8334
+ readonly postTokens: number;
8335
+ };
8336
+ }
8337
+ type ReportOf<C extends RcSelfHostCommand> = RcSelfHostReports[C["kind"]];
8338
+ /** One local command's answer as the worker emitted it: its output text and, when the worker stated it, the outcome kind. */
8339
+ interface LocalCommandAnswer {
8340
+ readonly text: string;
8341
+ readonly outcome: string | undefined;
8342
+ }
8343
+ /** The worker's answer to the local command `command` run with exactly `args`, when this stream event is that answer. */
8344
+ declare function rcLocalCommandAnswerOf(event: RcStreamEvent, command: string, args: string): LocalCommandAnswer | undefined;
8345
+ /** The token counts a manual compaction's boundary names, when this stream event is that boundary. */
8346
+ declare function rcManualCompactBoundaryOf(event: RcStreamEvent): ReportOf<{
8347
+ kind: "compact";
8348
+ instructions: undefined;
8349
+ }> | undefined;
8350
+ /** Reads `/goal`'s answer with no argument, or undefined when the text is neither shape the verified versions answer with. */
8351
+ declare function parseRcGoalOutput(output: string): ReportOf<{
8352
+ kind: "goal-get";
8353
+ }> | undefined;
8354
+ /** The Claude Code version each observed session's worker reported, read off its own `system/init` events. */
8355
+ interface RcClaudeCodeVersions {
8356
+ readonly versionOf: (sessionId: string) => string | undefined;
8357
+ /** Drops the sessions `isTracked` no longer holds, so an ended session's version is not kept. */
8358
+ readonly sweep: (isTracked: (sessionId: string) => boolean) => void;
8359
+ }
8360
+ /** Subscribes to every session's stream and files the `claude_code_version` each worker-sourced `system/init` names, the worker's own statement of the version it runs (it emits one at the start of the stream and after every turn); an event a client wrote is never taken for the worker's. In memory: on the self-hosted surface a session lives exactly as long as the door that serves it. */
8361
+ declare function createRcClaudeCodeVersions(fanout: RcEventFanout): RcClaudeCodeVersions;
8362
+
8363
+ /**
8364
+ * Goal and compaction control over a Remote Control session: read, set and clear its `/goal`, and compact its conversation, each returning the outcome the session itself reports. One verb surface over the two routes Claude Code 2.1.319 leaves open, chosen per session:
8110
8365
  *
8111
- * Mounted on the provider listener beside the bespoke namespace, authenticated by the same per-generation owner-only control token as a Bearer credential: a fresh random value per door start, written owner-only under the front door's state directory, and checked in constant time like every other capability the door accepts. `rc.subscribe` streams the client attachment's fan-out: every event the door's held stream produced, SSE-framed by oRPC's event iterator, each carrying its sequence number as the SSE event id so a consumer's own reconnect can resume exactly as the door's does.
8366
+ * - **A supervised session** (one an agent-shim supervisor launched, whatever its account or provider): the door finds the launch through the registry, by the `bridge-session` row Claude Code writes into the session's own transcript, and asks the session's in-process control plugin (`supervise/sessionControlPlugin.ts`), which runs `$.session.compact` or `/goal <condition>` and `/goal clear` through the plugin API. The goal is read from the transcript's `goal_status` rows, with no effect on the session.
8367
+ * - **A session on the door's self-hosted surface** that no supervisor owns: the door is the Remote Control service there, so it writes the slash command into its own conversation as a person's app would and reads the worker's answer off the stream (`rcSelfHostCommands.ts`).
8112
8368
  *
8113
- * This module also owns the mount's router-agnostic plumbing, which the control-plane routers (`controlApi.ts`) serve on the same prefix under the same token: the control-token middleware (`doorApiAuth`), the node-handler builder (`doorApiNodeHandlerOf`) and the TLS-pinned client link (`frontDoorApiLink`).
8369
+ * Any other session is refused with the reason: the door has no in-process channel into it, and on the real service the worker runs a slash command only when a person's app wrote it (it treats every other writer, the door's own `send` among them, as a peer whose message the model reads as text), which the door will not claim to be.
8114
8370
  *
8115
- * Every procedure is route-annotated (method, path, summary, tags) under the mount's one REST namespace (`/rest/...`), so the mount serves the same operations twice over: as the oRPC RPC protocol the typed clients and the web client speak, and as plain REST for consumers with no TypeScript client (curl, scripts, other languages), with the OpenAPI document of the whole surface at `RC_OPENAPI_DOC_PATH` under the same token. The two share one router, one token middleware and one Zod schema source, so nothing can drift between them; an annotated (method, path) pair is served REST-shaped and everything else falls through to the RPC handler, and no RPC procedure path begins with `/rest`, so neither address space can ever capture the other.
8371
+ * Both routes are verified for exactly the Claude Code versions `RC_SESSION_COMMAND_VERIFIED_VERSIONS` names, read from the running binary itself (the plugin's `$.session.version()`, or the worker's own `system/init`), and every verb refuses a session on any other version, or one whose version is not known.
8116
8372
  */
8117
- /** The one path prefix the typed API is mounted under, answered before the routed pipeline like the bespoke control routes are. */
8118
- declare const RC_ORPC_PATH_PREFIX = "/__agent-shim/orpc";
8119
- /** Everything the typed API needs: the same operations the bespoke control routes take, the fan-out its subscription reads, and the token both surfaces demand. */
8120
- interface RcApiDeps {
8121
- /** This generation's control token: the value the door wrote owner-only for its callers to present. */
8373
+ /** The Claude Code versions both routes were verified on end to end; a session reporting any other version is refused. */
8374
+ declare const RC_SESSION_COMMAND_VERIFIED_VERSIONS: readonly string[];
8375
+ /** The arguments the 2.1.319 `/goal` command reads as a request to clear the goal rather than set one, compared case-insensitively; a condition that is one of these words cannot be set through `/goal`, so the set verb refuses it rather than clear the goal by accident. */
8376
+ declare const RC_GOAL_CLEAR_WORDS: readonly string[];
8377
+ /** The longest goal condition the 2.1.319 `/goal` command accepts, in characters; it refuses a longer one with its own message, so the set verb refuses it first, unsent. */
8378
+ declare const RC_GOAL_CONDITION_MAX_CHARS = 4000;
8379
+ /**
8380
+ * The longest any verb waits for the session's answer: the largest delay Node's timers accept (a signed 32-bit millisecond count), since a larger one fires after one millisecond instead. Every wait the verbs take is bounded by it, in the schema, the CLI's parser and the timer itself.
8381
+ */
8382
+ declare const RC_SESSION_COMMAND_MAX_WAIT_MS = 2147483647;
8383
+ /** Who answered: the session's supervisor through its in-process plugin, or the door's own self-hosted surface. */
8384
+ type RcSessionCommandRoute = "supervised" | "self-hosted";
8385
+ /** One goal as the session reports it. */
8386
+ type RcGoal = TranscriptGoal;
8387
+ /** What a goal read found: the active goal, or `null` when the session has none. */
8388
+ interface RcGoalReport {
8389
+ readonly route: RcSessionCommandRoute;
8390
+ readonly goal: RcGoal | null;
8391
+ }
8392
+ /** What a goal set did: the condition now set, and the one it replaced, or `null` when none was set. */
8393
+ interface RcGoalSetReport {
8394
+ readonly route: RcSessionCommandRoute;
8395
+ readonly condition: string;
8396
+ readonly superseded: string | null;
8397
+ }
8398
+ /** What a goal clear did: the condition it cleared, or `null` when the session had no goal to clear. */
8399
+ interface RcGoalClearReport {
8400
+ readonly route: RcSessionCommandRoute;
8401
+ readonly cleared: string | null;
8402
+ }
8403
+ /** What a completed compaction reported: what triggered it as the session names it, and the token counts before and after when the session recorded them. */
8404
+ interface RcCompactReport {
8405
+ readonly route: RcSessionCommandRoute;
8406
+ readonly trigger: string;
8407
+ readonly preTokens?: number;
8408
+ readonly postTokens?: number;
8409
+ }
8410
+ /** One verb's outcome: the report, or a verbose failure ready to show a user. */
8411
+ type RcSessionCommandResult<T> = {
8412
+ readonly ok: true;
8413
+ readonly report: T;
8414
+ } | {
8415
+ readonly ok: false;
8416
+ readonly message: string;
8417
+ };
8418
+ /** The options every verb takes. */
8419
+ interface RcSessionCommandOptions {
8420
+ /** How long to wait for the session's answer, in milliseconds, at most `RC_SESSION_COMMAND_MAX_WAIT_MS`; the supervisor's own bound on one compaction (`COMPACT_TIMEOUT_MS`) when absent, since a compaction's one summary request is the longest thing a verb waits on and a goal command, which makes no model request, is answered well within it. */
8421
+ readonly waitMs?: number;
8422
+ /** Aborts the wait, as the caller's request ending does. */
8423
+ readonly signal?: AbortSignal;
8424
+ }
8425
+ /** A compaction's options beyond the wait. */
8426
+ interface RcCompactOptions extends RcSessionCommandOptions {
8427
+ /** Custom summarisation instructions. A directive to the session's model, which is why the typed API serves it under its own grant. */
8428
+ readonly instructions?: string;
8429
+ }
8430
+ /** The supervised launch a Remote Control session belongs to, as the door reaches it. */
8431
+ interface RcSupervisedTarget {
8432
+ /** The conversation the plugin acts on: the session's current one, which differs from its launch id after `/clear`. */
8433
+ readonly conversationId: string;
8434
+ /** The session's current transcript, the goal's record; undefined until the session's hooks have named it. */
8435
+ readonly transcriptPath: string | undefined;
8436
+ /** The Claude Code version the plugin reported when it loaded; undefined when it has not loaded. */
8437
+ readonly version: string | undefined;
8438
+ /** Compacts through the plugin; the request is runnable for `waitMs` and no longer. */
8439
+ readonly compact: (signal: AbortSignal, instructions: string | undefined, waitMs: number) => Promise<CompactionResult>;
8440
+ /** Runs `/goal <args>` through the plugin, runnable for `waitMs` and no longer. */
8441
+ readonly runGoal: (args: string, signal: AbortSignal, waitMs: number) => Promise<unknown>;
8442
+ }
8443
+ /** Everything the verbs need, injected so they run against fakes in unit tests. */
8444
+ interface RcSessionCommandDeps {
8445
+ /** The supervised launch a `cse_` session belongs to; undefined when no live supervisor owns it, or when it does but its control plugin is not recorded; a refusal when the door cannot tell which launch it is (two live launches claim it). */
8446
+ readonly supervisedOf: (sessionId: string) => Promise<RcSupervisedTarget | {
8447
+ readonly refused: string;
8448
+ } | undefined>;
8449
+ /** The goal a transcript leaves active, read incrementally without blocking (`transcriptFollower.ts`); undefined when the file does not exist. */
8450
+ readonly goalOf: (path: string) => Promise<RcGoal | null | undefined>;
8451
+ /** The door's own surface, present only when the door serves Remote Control itself: the one place it writes a command as a person's app. */
8452
+ readonly selfHost: RcSelfHostCommandDeps | undefined;
8453
+ /** Whether the door observes the session at all, so a mistyped id is refused as unknown rather than as unsupported. */
8454
+ readonly isObserved: (sessionId: string) => boolean;
8455
+ }
8456
+ /** Creates the verbs over their dependencies. Verbs on one session run one at a time, in the order they were asked, so two commands never interleave on one session and one never reads the other's answer. */
8457
+ declare function createRcSessionCommands(deps: RcSessionCommandDeps): {
8458
+ /** Reads the session's goal: from the transcript for a supervised session, with no effect on it; by running `/goal` on the self-hosted surface otherwise. */
8459
+ goalGet: (sessionId: string, options?: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalReport>>;
8460
+ /**
8461
+ * Sets the session's goal: the goal check then keeps the session working until the condition holds, and the condition reaches its model as a directive (`docs/rc-slash-commands.md`, the trust boundary). Refused unsent: an empty condition, one `/goal` reads as a clear, and one longer than it accepts. The answer names the goal it replaced.
8462
+ */
8463
+ goalSet: (sessionId: string, condition: string, options?: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalSetReport>>;
8464
+ /** Clears the session's goal and names the condition it cleared, or `null` when there was none, which is not a failure (clearing is idempotent). */
8465
+ goalClear: (sessionId: string, options?: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalClearReport>>;
8466
+ /** Compacts the session's conversation, with custom summary instructions when given, and resolves with the outcome: the trigger and token counts, or the session's reason for not compacting. */
8467
+ compact: (sessionId: string, options?: RcCompactOptions) => Promise<RcSessionCommandResult<RcCompactReport>>;
8468
+ };
8469
+ /** The verbs as `createRcSessionCommands` builds them. */
8470
+ type RcSessionCommands = ReturnType<typeof createRcSessionCommands>;
8471
+
8472
+ /**
8473
+ * A secondary pre-pipeline surface the listener answers under one path prefix: the typed Remote Control API. The listener owns only the dispatch (the prefix and the not-matched 404); the handle itself is whatever the door built, so this file stays independent of the API framework behind it.
8474
+ */
8475
+ interface PrePipelineApi {
8476
+ /** The path prefix every request of this surface arrives under, outside the routed URL space. */
8477
+ readonly pathPrefix: string;
8478
+ /** Serves one request, resolving with whether a procedure under the prefix matched; the listener answers the 404 itself when one did not. */
8479
+ readonly handle: (request: IncomingMessage, response: ServerResponse) => Promise<{
8480
+ readonly matched: boolean;
8481
+ }>;
8482
+ }
8483
+
8484
+ /**
8485
+ * The Remote Control operations as a typed oRPC API, so programmatic consumers (automation, a mobile or web client, another of this user's tools) get a generated type-safe client instead of hand-rolled HTTP. One procedure per existing operation, each wrapping the same operation the bespoke token-gated routes wrap (the routes stay: the CLI uses them), with inputs and outputs validating through the Zod schemas of `rcSchemas.ts`, which the operations' own values must satisfy, so contract and behaviour share one schema source and cannot drift apart silently.
8486
+ *
8487
+ * Mounted on the provider listener beside the bespoke namespace, authenticated by the same per-generation owner-only control token as a Bearer credential: a fresh random value per door start, written owner-only under the front door's state directory, and checked in constant time like every other capability the door accepts. `rc.subscribe` streams the client attachment's fan-out: every event the door's held stream produced, SSE-framed by oRPC's event iterator, each carrying its sequence number as the SSE event id so a consumer's own reconnect can resume exactly as the door's does.
8488
+ *
8489
+ * This module also owns the mount's router-agnostic plumbing, which the control-plane routers (`controlApi.ts`) serve on the same prefix under the same token: the control-token middleware (`doorApiAuth`), the node-handler builder (`doorApiNodeHandlerOf`) and the TLS-pinned client link (`frontDoorApiLink`).
8490
+ *
8491
+ * Every procedure is route-annotated (method, path, summary, tags) under the mount's one REST namespace (`/rest/...`), so the mount serves the same operations twice over: as the oRPC RPC protocol the typed clients and the web client speak, and as plain REST for consumers with no TypeScript client (curl, scripts, other languages), with the OpenAPI document of the whole surface at `RC_OPENAPI_DOC_PATH` under the same token. The two share one router, one token middleware and one Zod schema source, so nothing can drift between them; an annotated (method, path) pair is served REST-shaped and everything else falls through to the RPC handler, and no RPC procedure path begins with `/rest`, so neither address space can ever capture the other.
8492
+ */
8493
+ /** The one path prefix the typed API is mounted under, answered before the routed pipeline like the bespoke control routes are. */
8494
+ declare const RC_ORPC_PATH_PREFIX = "/__agent-shim/orpc";
8495
+ /** Everything the typed API needs: the same operations the bespoke control routes take, the fan-out its subscription reads, and the token both surfaces demand. */
8496
+ interface RcApiDeps {
8497
+ /** This generation's control token: the value the door wrote owner-only for its callers to present. */
8122
8498
  readonly expectedToken: string;
8123
8499
  /** The observed sessions as the tracker lists them. */
8124
8500
  readonly list: () => readonly RcSessionSummary[];
@@ -8158,6 +8534,14 @@ interface RcApiDeps {
8158
8534
  readonly mcpOAuthCallbackUrl: (sessionId: string, serverName: string, callbackUrl: string) => Promise<RcEventWriteResult>;
8159
8535
  /** The teleport operation, already wired to the tracker and the door's API-host dial. */
8160
8536
  readonly teleport: (sessionId: string, marker: string) => Promise<RcEventWriteResult>;
8537
+ /** The goal read (`rcSessionCommands.ts`), routed to the session's supervisor or the door's own self-hosted surface. */
8538
+ readonly goalGet: (sessionId: string, options: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalReport>>;
8539
+ /** The goal set, routed the same way. */
8540
+ readonly goalSet: (sessionId: string, condition: string, options: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalSetReport>>;
8541
+ /** The goal clear, routed the same way. */
8542
+ readonly goalClear: (sessionId: string, options: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalClearReport>>;
8543
+ /** The compaction, routed the same way. */
8544
+ readonly compact: (sessionId: string, options: RcCompactOptions) => Promise<RcSessionCommandResult<RcCompactReport>>;
8161
8545
  /** The client attachment's fan-out, whose events the subscription yields. */
8162
8546
  readonly fanout: RcEventFanout;
8163
8547
  }
@@ -8360,6 +8744,72 @@ declare function createRcApiRouter(deps: RcApiDeps): {
8360
8744
  session: zod.ZodString;
8361
8745
  sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
8362
8746
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8747
+ goalGet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8748
+ session: zod.ZodString;
8749
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8750
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8751
+ goal: zod.ZodNullable<zod.ZodObject<{
8752
+ condition: zod.ZodString;
8753
+ iterations: zod.ZodInt;
8754
+ lastCheck: zod.ZodOptional<zod.ZodString>;
8755
+ }, zod_v4_core.$strict>>;
8756
+ session: zod.ZodString;
8757
+ route: zod.ZodEnum<{
8758
+ supervised: "supervised";
8759
+ "self-hosted": "self-hosted";
8760
+ }>;
8761
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8762
+ goalSet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8763
+ session: zod.ZodString;
8764
+ condition: zod.ZodString;
8765
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8766
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8767
+ condition: zod.ZodString;
8768
+ superseded: zod.ZodNullable<zod.ZodString>;
8769
+ session: zod.ZodString;
8770
+ route: zod.ZodEnum<{
8771
+ supervised: "supervised";
8772
+ "self-hosted": "self-hosted";
8773
+ }>;
8774
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8775
+ goalClear: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8776
+ session: zod.ZodString;
8777
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8778
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8779
+ cleared: zod.ZodNullable<zod.ZodString>;
8780
+ session: zod.ZodString;
8781
+ route: zod.ZodEnum<{
8782
+ supervised: "supervised";
8783
+ "self-hosted": "self-hosted";
8784
+ }>;
8785
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8786
+ compact: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8787
+ session: zod.ZodString;
8788
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8789
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8790
+ trigger: zod.ZodString;
8791
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
8792
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
8793
+ session: zod.ZodString;
8794
+ route: zod.ZodEnum<{
8795
+ supervised: "supervised";
8796
+ "self-hosted": "self-hosted";
8797
+ }>;
8798
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8799
+ compactWithInstructions: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8800
+ session: zod.ZodString;
8801
+ instructions: zod.ZodString;
8802
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8803
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8804
+ trigger: zod.ZodString;
8805
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
8806
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
8807
+ session: zod.ZodString;
8808
+ route: zod.ZodEnum<{
8809
+ supervised: "supervised";
8810
+ "self-hosted": "self-hosted";
8811
+ }>;
8812
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8363
8813
  subscribe: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8364
8814
  session: zod.ZodOptional<zod.ZodString>;
8365
8815
  }, zod_v4_core.$strict>, any, MergedErrorMap<$ErrorMap, TErrorMap>>;
@@ -8535,12 +8985,12 @@ declare const CheckReportJsonSchema: z.ZodObject<{
8535
8985
  identity: z.ZodObject<{
8536
8986
  name: z.ZodNullable<z.ZodString>;
8537
8987
  source: z.ZodEnum<{
8538
- env: "env";
8539
- none: "none";
8540
8988
  "config-dir-escape-hatch": "config-dir-escape-hatch";
8541
8989
  argv: "argv";
8990
+ env: "env";
8542
8991
  "directory-pin": "directory-pin";
8543
8992
  "active-identity-file": "active-identity-file";
8993
+ none: "none";
8544
8994
  }>;
8545
8995
  }, z.core.$strict>;
8546
8996
  pool: z.ZodOptional<z.ZodObject<{
@@ -8618,11 +9068,11 @@ declare const CheckReportJsonSchema: z.ZodObject<{
8618
9068
  "category-default": "category-default";
8619
9069
  }>;
8620
9070
  category: z.ZodNullable<z.ZodEnum<{
9071
+ secret: "secret";
8621
9072
  runtime: "runtime";
8622
9073
  history: "history";
8623
9074
  knowledge: "knowledge";
8624
9075
  settings: "settings";
8625
- secret: "secret";
8626
9076
  }>>;
8627
9077
  rule: z.ZodOptional<z.ZodObject<{
8628
9078
  key: z.ZodString;
@@ -8822,8 +9272,8 @@ declare const CheckReportJsonSchema: z.ZodObject<{
8822
9272
  pinned: z.ZodOptional<z.ZodObject<{
8823
9273
  version: z.ZodString;
8824
9274
  source: z.ZodEnum<{
8825
- environment: "environment";
8826
9275
  flag: "flag";
9276
+ environment: "environment";
8827
9277
  cascade: "cascade";
8828
9278
  }>;
8829
9279
  installed: z.ZodBoolean;
@@ -8834,127 +9284,6 @@ declare const CheckReportJsonSchema: z.ZodObject<{
8834
9284
  }, z.core.$strict>;
8835
9285
  type CheckReportJson = z.output<typeof CheckReportJsonSchema>;
8836
9286
 
8837
- /** What a cache stores for one credential: the token, when it was fetched, the source that produced it (a non-secret descriptor, kept so `check` and the launch log can still say where the token came from), and, in the file store, the owner it was cached for (`identity <id>`, `provider <name>`), which the file store records on every write; the Keychain store files each entry under its owner's account and records none. A file-store entry with no `owner` was written before owners were recorded. */
8838
- declare const CachedCredentialSchema: z.ZodObject<{
8839
- token: z.ZodString;
8840
- fetchedAt: z.ZodNumber;
8841
- source: z.ZodUnion<readonly [z.ZodObject<{
8842
- env: z.ZodString;
8843
- }, z.core.$strict>, z.ZodObject<{
8844
- file: z.ZodString;
8845
- }, z.core.$strict>, z.ZodObject<{
8846
- interactive: z.ZodOptional<z.ZodBoolean>;
8847
- timeoutMs: z.ZodOptional<z.ZodInt>;
8848
- command: z.ZodTuple<[z.ZodString], z.ZodString>;
8849
- }, z.core.$strict>, z.ZodObject<{
8850
- interactive: z.ZodOptional<z.ZodBoolean>;
8851
- timeoutMs: z.ZodOptional<z.ZodInt>;
8852
- op: z.ZodString;
8853
- }, z.core.$strict>, z.ZodObject<{
8854
- interactive: z.ZodOptional<z.ZodBoolean>;
8855
- timeoutMs: z.ZodOptional<z.ZodInt>;
8856
- keychain: z.ZodObject<{
8857
- service: z.ZodString;
8858
- account: z.ZodOptional<z.ZodString>;
8859
- }, z.core.$strict>;
8860
- }, z.core.$strict>, z.ZodObject<{
8861
- literal: z.ZodString;
8862
- }, z.core.$strict>]>;
8863
- owner: z.ZodOptional<z.ZodString>;
8864
- }, z.core.$strict>;
8865
- type CachedCredential = z.infer<typeof CachedCredentialSchema>;
8866
- /**
8867
- * Where cached credentials live, injected so resolution and its tests need neither the Keychain nor a real directory. `owner` names what the credential belongs to (`identity work`, `provider z`) and is the entry's key; `store` picks the backing store. `read` returns undefined for a missing or unreadable entry, since an entry that cannot be used is the same as no entry.
8868
- */
8869
- interface CredentialCachePort {
8870
- readonly read: (store: CredentialCacheStore, owner: string) => CachedCredential | undefined;
8871
- readonly write: (store: CredentialCacheStore, owner: string, entry: CachedCredential) => void;
8872
- readonly remove: (store: CredentialCacheStore, owner: string) => void;
8873
- }
8874
- /**
8875
- * What the cache holds for one credential, without the token: whether there is an entry, how old it is, and whether it is still within the block's TTL. `expiresInMs` is absent for a block with no expiry.
8876
- */
8877
- type CachedCredentialState = {
8878
- readonly store: CredentialCacheStore;
8879
- readonly status: "empty";
8880
- }
8881
- /** The store cannot be read here (the keychain store configured on a platform without a Keychain): reported with its reason rather than failing the whole report. */
8882
- | {
8883
- readonly store: CredentialCacheStore;
8884
- readonly status: "unreadable";
8885
- readonly reason: string;
8886
- } | {
8887
- readonly store: CredentialCacheStore;
8888
- readonly status: "fresh" | "expired";
8889
- readonly ageMs: number;
8890
- readonly expiresInMs?: number;
8891
- };
8892
-
8893
- /** What reading one `file` source found: nothing at that path, or its contents and permission bits. `mode` is undefined on a platform with no POSIX permission bits (Windows), where the looseness check cannot apply. */
8894
- type SecretFileRead = {
8895
- readonly found: false;
8896
- } | {
8897
- readonly found: true;
8898
- readonly content: string;
8899
- readonly mode: number | undefined;
8900
- };
8901
- /** The outcome of one credential command. `stderr` is empty for an interactive run, whose stderr goes to the terminal so a person sees any prompt. */
8902
- interface CredentialCommandResult {
8903
- readonly status: number | null;
8904
- readonly stdout: string;
8905
- readonly stderr: string;
8906
- readonly timedOut: boolean;
8907
- }
8908
- /**
8909
- * Everything resolving a credential needs from the outside world, injected so the resolver (and every launcher test) runs without `op`, the Keychain, real secret files or a terminal. `src/realPorts.ts` wires the real one; tests wire a fake.
8910
- */
8911
- interface CredentialPort {
8912
- /** Reads a `file` source's path (absolute or `~`-rooted). */
8913
- readonly readSecretFile: (filePath: string) => SecretFileRead;
8914
- /** Runs a command source's argv directly (no shell) under a timeout, capturing stdout. An interactive run inherits the terminal's stdin and stderr so a person can answer a prompt. */
8915
- readonly runCommand: (argv: readonly [string, ...string[]], options: {
8916
- readonly timeoutMs: number;
8917
- readonly interactive: boolean;
8918
- }) => CredentialCommandResult;
8919
- /** Whether a person can answer a prompt now: standard input is a terminal, or there is a desktop session to show a dialog in. */
8920
- readonly personPresent: () => boolean;
8921
- /** Where cached credentials live, used only for a credential block that asks for caching. Omit to resolve every launch from the sources. */
8922
- readonly cache?: CredentialCacheEnv;
8923
- }
8924
- /** One source as `check`, `doctor` and every `--json` output report it: its kind plus the same non-secret identifying detail `describeSource` prints. */
8925
- type CredentialSourceSummary = {
8926
- readonly kind: "env";
8927
- readonly variable: string;
8928
- } | {
8929
- readonly kind: "file";
8930
- readonly path: string;
8931
- } | {
8932
- readonly kind: "command";
8933
- readonly program: string;
8934
- } | {
8935
- readonly kind: "op";
8936
- readonly reference: string;
8937
- } | {
8938
- readonly kind: "keychain";
8939
- readonly service: string;
8940
- readonly account?: string;
8941
- } | {
8942
- readonly kind: "literal";
8943
- };
8944
- /** A credential block as it is reported: its effective target and each source's summary, in order. */
8945
- interface CredentialSummary {
8946
- readonly target: CredentialTarget;
8947
- readonly sources: readonly CredentialSourceSummary[];
8948
- /** The block's cache setting when it asks for caching: how long a token is kept (absent for no expiry) and where. Carried as the config schema's own type, since the summary passes the parsed block's setting through unchanged. */
8949
- readonly cache?: CredentialCache;
8950
- }
8951
- /** What caching a credential needs beyond the block's own `cache` setting: the port holding entries, the platform that picks the default store, and the clock the TTL is measured on. */
8952
- interface CredentialCacheEnv {
8953
- readonly port: CredentialCachePort;
8954
- readonly platform: NodeJS.Platform;
8955
- readonly now: () => number;
8956
- }
8957
-
8958
9287
  /** Where a pinned Claude Code version came from, strongest first: the launch's own flag, then the environment, then the cascade. */
8959
9288
  declare const CLAUDE_VERSION_SOURCES: readonly ["flag", "environment", "cascade"];
8960
9289
  type ClaudeVersionSource = (typeof CLAUDE_VERSION_SOURCES)[number];
@@ -9830,22 +10159,6 @@ interface RenameJournalListing {
9830
10159
  declare const ProviderAliasesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
9831
10160
  type ProviderAliases = z.infer<typeof ProviderAliasesSchema>;
9832
10161
 
9833
- /** The result of a successful discovery. */
9834
- interface DiscoveredClaudeBinary {
9835
- /** Full path to the discovered `claude` executable. */
9836
- path: string;
9837
- /** Which strategy found it. */
9838
- source: "versions-dir" | "path-fallback";
9839
- /** The version string, when discovered via the versions directory. */
9840
- version?: string;
9841
- }
9842
- /** What a launch asks binary discovery for: nothing (the highest installed version) or an exact version. */
9843
- interface ClaudeBinaryRequest {
9844
- readonly version?: string;
9845
- }
9846
- /** Discovers the real `claude` binary to spawn, for the version a launch asked for. Injected into the launcher so it never reads the filesystem or PATH itself. */
9847
- type ClaudeBinaryResolver = (request?: Readonly<ClaudeBinaryRequest>) => DiscoveredClaudeBinary;
9848
-
9849
10162
  declare const DOCTOR_SEVERITIES: readonly ["pass", "warn", "fail"];
9850
10163
  type DoctorSeverity = (typeof DOCTOR_SEVERITIES)[number];
9851
10164
  declare const DOCTOR_SECTIONS: readonly ["ambient-credential", "binary-discovery", "claude-shim", "path-resolution", "legacy-name", "config-profile", "identity", "sign-in", "pool", "provider", "keychain", "directory-rules", "global-config", "categories-local", "active-identity", "headroom", "frontdoor", "models"];
@@ -10088,15 +10401,6 @@ type CodexApiRouter = ReturnType<typeof createCodexApiRouter>;
10088
10401
  /** The Codex procedures alone as a client sees them. */
10089
10402
  type CodexApiClient = RouterClient<CodexApiRouter>;
10090
10403
 
10091
- /** The outcome of one external command, as `RunPort` reports it. */
10092
- interface ReplayRunResult {
10093
- readonly status: number | null;
10094
- readonly stdout: string;
10095
- readonly stderr: string;
10096
- }
10097
- /** Runs an external command without blocking the calling thread. */
10098
- type AsyncRun = (command: string, args: readonly string[]) => Promise<ReplayRunResult>;
10099
-
10100
10404
  /**
10101
10405
  * The door's configuration management as a typed oRPC API: the writes the CLI's `identity`, `profile`, `pool`, `provider` and `rule` verbs make, as `config.<noun>.<verb>` procedures, every one behind the same per-generation control token as the rest of the mount.
10102
10406
  *
@@ -10392,6 +10696,53 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10392
10696
  }, zod_v4_core.$strip>], "kind">]>;
10393
10697
  }, zod_v4_core.$strict>]>>>;
10394
10698
  description: zod.ZodOptional<zod.ZodString>;
10699
+ models: zod.ZodOptional<zod.ZodObject<{
10700
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
10701
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
10702
+ mode: zod.ZodEnum<{
10703
+ ordered: "ordered";
10704
+ "most-allowance": "most-allowance";
10705
+ "soonest-reset": "soonest-reset";
10706
+ spread: "spread";
10707
+ adaptive: "adaptive";
10708
+ "lowest-latency": "lowest-latency";
10709
+ "highest-success": "highest-success";
10710
+ cheapest: "cheapest";
10711
+ }>;
10712
+ members: zod.ZodArray<zod.ZodString>;
10713
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
10714
+ tiers: zod.ZodOptional<zod.ZodObject<{
10715
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10716
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10717
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10718
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10719
+ }, zod_v4_core.$strict>>;
10720
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
10721
+ input: zod.ZodNumber;
10722
+ output: zod.ZodNumber;
10723
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
10724
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
10725
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
10726
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
10727
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
10728
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
10729
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
10730
+ mode: zod.ZodOptional<zod.ZodEnum<{
10731
+ ordered: "ordered";
10732
+ "most-allowance": "most-allowance";
10733
+ "soonest-reset": "soonest-reset";
10734
+ spread: "spread";
10735
+ adaptive: "adaptive";
10736
+ "lowest-latency": "lowest-latency";
10737
+ "highest-success": "highest-success";
10738
+ cheapest: "cheapest";
10739
+ }>>;
10740
+ context: zod.ZodOptional<zod.ZodNumber>;
10741
+ vision: zod.ZodOptional<zod.ZodBoolean>;
10742
+ tools: zod.ZodOptional<zod.ZodBoolean>;
10743
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
10744
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
10745
+ }, zod_v4_core.$strict>>;
10395
10746
  extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
10396
10747
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
10397
10748
  all: zod.ZodOptional<zod.ZodBoolean>;
@@ -10435,30 +10786,30 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10435
10786
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
10436
10787
  identity: "identity";
10437
10788
  model: "model";
10789
+ route: "route";
10438
10790
  account: "account";
10439
10791
  provider: "provider";
10792
+ version: "version";
10440
10793
  headroom: "headroom";
10441
- route: "route";
10794
+ duration: "duration";
10442
10795
  project: "project";
10443
10796
  vcs: "vcs";
10444
10797
  effort: "effort";
10445
10798
  advisor: "advisor";
10446
- version: "version";
10447
10799
  outputStyle: "outputStyle";
10448
10800
  cost: "cost";
10449
10801
  dailyCost: "dailyCost";
10450
10802
  sessionName: "sessionName";
10451
- duration: "duration";
10452
10803
  speed: "speed";
10453
10804
  extra: "extra";
10454
10805
  }>>>;
10455
10806
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
10456
10807
  context: "context";
10457
10808
  quota: "quota";
10809
+ environment: "environment";
10458
10810
  addedDirs: "addedDirs";
10459
10811
  gitFiles: "gitFiles";
10460
10812
  memory: "memory";
10461
- environment: "environment";
10462
10813
  sessionTime: "sessionTime";
10463
10814
  promptCache: "promptCache";
10464
10815
  compactions: "compactions";
@@ -10481,10 +10832,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10481
10832
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
10482
10833
  context: "context";
10483
10834
  quota: "quota";
10835
+ environment: "environment";
10484
10836
  addedDirs: "addedDirs";
10485
10837
  gitFiles: "gitFiles";
10486
10838
  memory: "memory";
10487
- environment: "environment";
10488
10839
  sessionTime: "sessionTime";
10489
10840
  promptCache: "promptCache";
10490
10841
  compactions: "compactions";
@@ -10498,10 +10849,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10498
10849
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
10499
10850
  context: "context";
10500
10851
  quota: "quota";
10852
+ environment: "environment";
10501
10853
  addedDirs: "addedDirs";
10502
10854
  gitFiles: "gitFiles";
10503
10855
  memory: "memory";
10504
- environment: "environment";
10505
10856
  sessionTime: "sessionTime";
10506
10857
  promptCache: "promptCache";
10507
10858
  compactions: "compactions";
@@ -10560,10 +10911,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10560
10911
  hidden: "hidden";
10561
10912
  }>>;
10562
10913
  value: zod.ZodOptional<zod.ZodEnum<{
10914
+ remaining: "remaining";
10563
10915
  tokens: "tokens";
10564
10916
  both: "both";
10565
10917
  percent: "percent";
10566
- remaining: "remaining";
10567
10918
  }>>;
10568
10919
  estimate: zod.ZodOptional<zod.ZodEnum<{
10569
10920
  never: "never";
@@ -10605,8 +10956,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10605
10956
  }, zod_v4_core.$strict>>;
10606
10957
  usage: zod.ZodOptional<zod.ZodObject<{
10607
10958
  value: zod.ZodOptional<zod.ZodEnum<{
10608
- remaining: "remaining";
10609
10959
  used: "used";
10960
+ remaining: "remaining";
10610
10961
  }>>;
10611
10962
  bar: zod.ZodOptional<zod.ZodBoolean>;
10612
10963
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -10964,53 +11315,6 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10964
11315
  }, zod_v4_core.$strict>>;
10965
11316
  }, zod_v4_core.$strict>>;
10966
11317
  }, zod_v4_core.$strict>>;
10967
- models: zod.ZodOptional<zod.ZodObject<{
10968
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
10969
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
10970
- mode: zod.ZodEnum<{
10971
- ordered: "ordered";
10972
- "most-allowance": "most-allowance";
10973
- "soonest-reset": "soonest-reset";
10974
- spread: "spread";
10975
- adaptive: "adaptive";
10976
- "lowest-latency": "lowest-latency";
10977
- "highest-success": "highest-success";
10978
- cheapest: "cheapest";
10979
- }>;
10980
- members: zod.ZodArray<zod.ZodString>;
10981
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
10982
- tiers: zod.ZodOptional<zod.ZodObject<{
10983
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10984
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10985
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10986
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
10987
- }, zod_v4_core.$strict>>;
10988
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
10989
- input: zod.ZodNumber;
10990
- output: zod.ZodNumber;
10991
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
10992
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
10993
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
10994
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
10995
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
10996
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
10997
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
10998
- mode: zod.ZodOptional<zod.ZodEnum<{
10999
- ordered: "ordered";
11000
- "most-allowance": "most-allowance";
11001
- "soonest-reset": "soonest-reset";
11002
- spread: "spread";
11003
- adaptive: "adaptive";
11004
- "lowest-latency": "lowest-latency";
11005
- "highest-success": "highest-success";
11006
- cheapest: "cheapest";
11007
- }>>;
11008
- context: zod.ZodOptional<zod.ZodNumber>;
11009
- vision: zod.ZodOptional<zod.ZodBoolean>;
11010
- tools: zod.ZodOptional<zod.ZodBoolean>;
11011
- thinking: zod.ZodOptional<zod.ZodBoolean>;
11012
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
11013
- }, zod_v4_core.$strict>>;
11014
11318
  }, zod_v4_core.$strict>;
11015
11319
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
11016
11320
  set: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
@@ -11116,6 +11420,53 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11116
11420
  }, zod_v4_core.$strip>], "kind">]>;
11117
11421
  }, zod_v4_core.$strict>]>>>;
11118
11422
  description: zod.ZodOptional<zod.ZodString>;
11423
+ models: zod.ZodOptional<zod.ZodObject<{
11424
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
11425
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
11426
+ mode: zod.ZodEnum<{
11427
+ ordered: "ordered";
11428
+ "most-allowance": "most-allowance";
11429
+ "soonest-reset": "soonest-reset";
11430
+ spread: "spread";
11431
+ adaptive: "adaptive";
11432
+ "lowest-latency": "lowest-latency";
11433
+ "highest-success": "highest-success";
11434
+ cheapest: "cheapest";
11435
+ }>;
11436
+ members: zod.ZodArray<zod.ZodString>;
11437
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
11438
+ tiers: zod.ZodOptional<zod.ZodObject<{
11439
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11440
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11441
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11442
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11443
+ }, zod_v4_core.$strict>>;
11444
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
11445
+ input: zod.ZodNumber;
11446
+ output: zod.ZodNumber;
11447
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
11448
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
11449
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
11450
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
11451
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
11452
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
11453
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
11454
+ mode: zod.ZodOptional<zod.ZodEnum<{
11455
+ ordered: "ordered";
11456
+ "most-allowance": "most-allowance";
11457
+ "soonest-reset": "soonest-reset";
11458
+ spread: "spread";
11459
+ adaptive: "adaptive";
11460
+ "lowest-latency": "lowest-latency";
11461
+ "highest-success": "highest-success";
11462
+ cheapest: "cheapest";
11463
+ }>>;
11464
+ context: zod.ZodOptional<zod.ZodNumber>;
11465
+ vision: zod.ZodOptional<zod.ZodBoolean>;
11466
+ tools: zod.ZodOptional<zod.ZodBoolean>;
11467
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
11468
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
11469
+ }, zod_v4_core.$strict>>;
11119
11470
  extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
11120
11471
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
11121
11472
  all: zod.ZodOptional<zod.ZodBoolean>;
@@ -11159,30 +11510,30 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11159
11510
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
11160
11511
  identity: "identity";
11161
11512
  model: "model";
11513
+ route: "route";
11162
11514
  account: "account";
11163
11515
  provider: "provider";
11516
+ version: "version";
11164
11517
  headroom: "headroom";
11165
- route: "route";
11518
+ duration: "duration";
11166
11519
  project: "project";
11167
11520
  vcs: "vcs";
11168
11521
  effort: "effort";
11169
11522
  advisor: "advisor";
11170
- version: "version";
11171
11523
  outputStyle: "outputStyle";
11172
11524
  cost: "cost";
11173
11525
  dailyCost: "dailyCost";
11174
11526
  sessionName: "sessionName";
11175
- duration: "duration";
11176
11527
  speed: "speed";
11177
11528
  extra: "extra";
11178
11529
  }>>>;
11179
11530
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
11180
11531
  context: "context";
11181
11532
  quota: "quota";
11533
+ environment: "environment";
11182
11534
  addedDirs: "addedDirs";
11183
11535
  gitFiles: "gitFiles";
11184
11536
  memory: "memory";
11185
- environment: "environment";
11186
11537
  sessionTime: "sessionTime";
11187
11538
  promptCache: "promptCache";
11188
11539
  compactions: "compactions";
@@ -11205,10 +11556,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11205
11556
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
11206
11557
  context: "context";
11207
11558
  quota: "quota";
11559
+ environment: "environment";
11208
11560
  addedDirs: "addedDirs";
11209
11561
  gitFiles: "gitFiles";
11210
11562
  memory: "memory";
11211
- environment: "environment";
11212
11563
  sessionTime: "sessionTime";
11213
11564
  promptCache: "promptCache";
11214
11565
  compactions: "compactions";
@@ -11222,10 +11573,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11222
11573
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
11223
11574
  context: "context";
11224
11575
  quota: "quota";
11576
+ environment: "environment";
11225
11577
  addedDirs: "addedDirs";
11226
11578
  gitFiles: "gitFiles";
11227
11579
  memory: "memory";
11228
- environment: "environment";
11229
11580
  sessionTime: "sessionTime";
11230
11581
  promptCache: "promptCache";
11231
11582
  compactions: "compactions";
@@ -11284,10 +11635,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11284
11635
  hidden: "hidden";
11285
11636
  }>>;
11286
11637
  value: zod.ZodOptional<zod.ZodEnum<{
11638
+ remaining: "remaining";
11287
11639
  tokens: "tokens";
11288
11640
  both: "both";
11289
11641
  percent: "percent";
11290
- remaining: "remaining";
11291
11642
  }>>;
11292
11643
  estimate: zod.ZodOptional<zod.ZodEnum<{
11293
11644
  never: "never";
@@ -11329,8 +11680,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11329
11680
  }, zod_v4_core.$strict>>;
11330
11681
  usage: zod.ZodOptional<zod.ZodObject<{
11331
11682
  value: zod.ZodOptional<zod.ZodEnum<{
11332
- remaining: "remaining";
11333
11683
  used: "used";
11684
+ remaining: "remaining";
11334
11685
  }>>;
11335
11686
  bar: zod.ZodOptional<zod.ZodBoolean>;
11336
11687
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -11688,53 +12039,6 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11688
12039
  }, zod_v4_core.$strict>>;
11689
12040
  }, zod_v4_core.$strict>>;
11690
12041
  }, zod_v4_core.$strict>>;
11691
- models: zod.ZodOptional<zod.ZodObject<{
11692
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
11693
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
11694
- mode: zod.ZodEnum<{
11695
- ordered: "ordered";
11696
- "most-allowance": "most-allowance";
11697
- "soonest-reset": "soonest-reset";
11698
- spread: "spread";
11699
- adaptive: "adaptive";
11700
- "lowest-latency": "lowest-latency";
11701
- "highest-success": "highest-success";
11702
- cheapest: "cheapest";
11703
- }>;
11704
- members: zod.ZodArray<zod.ZodString>;
11705
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
11706
- tiers: zod.ZodOptional<zod.ZodObject<{
11707
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11708
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11709
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11710
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
11711
- }, zod_v4_core.$strict>>;
11712
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
11713
- input: zod.ZodNumber;
11714
- output: zod.ZodNumber;
11715
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
11716
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
11717
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
11718
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
11719
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
11720
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
11721
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
11722
- mode: zod.ZodOptional<zod.ZodEnum<{
11723
- ordered: "ordered";
11724
- "most-allowance": "most-allowance";
11725
- "soonest-reset": "soonest-reset";
11726
- spread: "spread";
11727
- adaptive: "adaptive";
11728
- "lowest-latency": "lowest-latency";
11729
- "highest-success": "highest-success";
11730
- cheapest: "cheapest";
11731
- }>>;
11732
- context: zod.ZodOptional<zod.ZodNumber>;
11733
- vision: zod.ZodOptional<zod.ZodBoolean>;
11734
- tools: zod.ZodOptional<zod.ZodBoolean>;
11735
- thinking: zod.ZodOptional<zod.ZodBoolean>;
11736
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
11737
- }, zod_v4_core.$strict>>;
11738
12042
  }, zod_v4_core.$strict>;
11739
12043
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
11740
12044
  remove: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
@@ -11972,8 +12276,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11972
12276
  add: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
11973
12277
  name: zod.ZodString;
11974
12278
  kind: zod.ZodOptional<zod.ZodEnum<{
11975
- http: "http";
11976
12279
  codex: "codex";
12280
+ http: "http";
11977
12281
  antigravity: "antigravity";
11978
12282
  router: "router";
11979
12283
  }>>;
@@ -12036,8 +12340,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12036
12340
  value: zod.ZodObject<{
12037
12341
  name: zod.ZodString;
12038
12342
  kind: zod.ZodEnum<{
12039
- http: "http";
12040
12343
  codex: "codex";
12344
+ http: "http";
12041
12345
  antigravity: "antigravity";
12042
12346
  router: "router";
12043
12347
  }>;
@@ -12159,8 +12463,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12159
12463
  value: zod.ZodObject<{
12160
12464
  name: zod.ZodString;
12161
12465
  kind: zod.ZodEnum<{
12162
- http: "http";
12163
12466
  codex: "codex";
12467
+ http: "http";
12164
12468
  antigravity: "antigravity";
12165
12469
  router: "router";
12166
12470
  }>;
@@ -12315,8 +12619,55 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12315
12619
  key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
12316
12620
  }, zod_v4_core.$strip>], "kind">]>;
12317
12621
  }, zod_v4_core.$strict>]>>>;
12318
- extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12622
+ models: zod.ZodOptional<zod.ZodObject<{
12623
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
12624
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
12625
+ mode: zod.ZodEnum<{
12626
+ ordered: "ordered";
12627
+ "most-allowance": "most-allowance";
12628
+ "soonest-reset": "soonest-reset";
12629
+ spread: "spread";
12630
+ adaptive: "adaptive";
12631
+ "lowest-latency": "lowest-latency";
12632
+ "highest-success": "highest-success";
12633
+ cheapest: "cheapest";
12634
+ }>;
12635
+ members: zod.ZodArray<zod.ZodString>;
12636
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
12637
+ tiers: zod.ZodOptional<zod.ZodObject<{
12638
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12639
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12640
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12641
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12642
+ }, zod_v4_core.$strict>>;
12643
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
12644
+ input: zod.ZodNumber;
12645
+ output: zod.ZodNumber;
12646
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
12647
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12648
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12649
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
12650
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
12651
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
12652
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12653
+ mode: zod.ZodOptional<zod.ZodEnum<{
12654
+ ordered: "ordered";
12655
+ "most-allowance": "most-allowance";
12656
+ "soonest-reset": "soonest-reset";
12657
+ spread: "spread";
12658
+ adaptive: "adaptive";
12659
+ "lowest-latency": "lowest-latency";
12660
+ "highest-success": "highest-success";
12661
+ cheapest: "cheapest";
12662
+ }>>;
12663
+ context: zod.ZodOptional<zod.ZodNumber>;
12664
+ vision: zod.ZodOptional<zod.ZodBoolean>;
12665
+ tools: zod.ZodOptional<zod.ZodBoolean>;
12666
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
12667
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
12668
+ }, zod_v4_core.$strict>>;
12319
12669
  $schema: zod.ZodOptional<zod.ZodString>;
12670
+ extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12320
12671
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
12321
12672
  all: zod.ZodOptional<zod.ZodBoolean>;
12322
12673
  runtime: zod.ZodOptional<zod.ZodBoolean>;
@@ -12359,30 +12710,30 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12359
12710
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
12360
12711
  identity: "identity";
12361
12712
  model: "model";
12713
+ route: "route";
12362
12714
  account: "account";
12363
12715
  provider: "provider";
12716
+ version: "version";
12364
12717
  headroom: "headroom";
12365
- route: "route";
12718
+ duration: "duration";
12366
12719
  project: "project";
12367
12720
  vcs: "vcs";
12368
12721
  effort: "effort";
12369
12722
  advisor: "advisor";
12370
- version: "version";
12371
12723
  outputStyle: "outputStyle";
12372
12724
  cost: "cost";
12373
12725
  dailyCost: "dailyCost";
12374
12726
  sessionName: "sessionName";
12375
- duration: "duration";
12376
12727
  speed: "speed";
12377
12728
  extra: "extra";
12378
12729
  }>>>;
12379
12730
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
12380
12731
  context: "context";
12381
12732
  quota: "quota";
12733
+ environment: "environment";
12382
12734
  addedDirs: "addedDirs";
12383
12735
  gitFiles: "gitFiles";
12384
12736
  memory: "memory";
12385
- environment: "environment";
12386
12737
  sessionTime: "sessionTime";
12387
12738
  promptCache: "promptCache";
12388
12739
  compactions: "compactions";
@@ -12405,10 +12756,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12405
12756
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
12406
12757
  context: "context";
12407
12758
  quota: "quota";
12759
+ environment: "environment";
12408
12760
  addedDirs: "addedDirs";
12409
12761
  gitFiles: "gitFiles";
12410
12762
  memory: "memory";
12411
- environment: "environment";
12412
12763
  sessionTime: "sessionTime";
12413
12764
  promptCache: "promptCache";
12414
12765
  compactions: "compactions";
@@ -12422,10 +12773,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12422
12773
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
12423
12774
  context: "context";
12424
12775
  quota: "quota";
12776
+ environment: "environment";
12425
12777
  addedDirs: "addedDirs";
12426
12778
  gitFiles: "gitFiles";
12427
12779
  memory: "memory";
12428
- environment: "environment";
12429
12780
  sessionTime: "sessionTime";
12430
12781
  promptCache: "promptCache";
12431
12782
  compactions: "compactions";
@@ -12484,10 +12835,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12484
12835
  hidden: "hidden";
12485
12836
  }>>;
12486
12837
  value: zod.ZodOptional<zod.ZodEnum<{
12838
+ remaining: "remaining";
12487
12839
  tokens: "tokens";
12488
12840
  both: "both";
12489
12841
  percent: "percent";
12490
- remaining: "remaining";
12491
12842
  }>>;
12492
12843
  estimate: zod.ZodOptional<zod.ZodEnum<{
12493
12844
  never: "never";
@@ -12529,8 +12880,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12529
12880
  }, zod_v4_core.$strict>>;
12530
12881
  usage: zod.ZodOptional<zod.ZodObject<{
12531
12882
  value: zod.ZodOptional<zod.ZodEnum<{
12532
- remaining: "remaining";
12533
12883
  used: "used";
12884
+ remaining: "remaining";
12534
12885
  }>>;
12535
12886
  bar: zod.ZodOptional<zod.ZodBoolean>;
12536
12887
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -12888,53 +13239,6 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12888
13239
  }, zod_v4_core.$strict>>;
12889
13240
  }, zod_v4_core.$strict>>;
12890
13241
  }, zod_v4_core.$strict>>;
12891
- models: zod.ZodOptional<zod.ZodObject<{
12892
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
12893
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
12894
- mode: zod.ZodEnum<{
12895
- ordered: "ordered";
12896
- "most-allowance": "most-allowance";
12897
- "soonest-reset": "soonest-reset";
12898
- spread: "spread";
12899
- adaptive: "adaptive";
12900
- "lowest-latency": "lowest-latency";
12901
- "highest-success": "highest-success";
12902
- cheapest: "cheapest";
12903
- }>;
12904
- members: zod.ZodArray<zod.ZodString>;
12905
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
12906
- tiers: zod.ZodOptional<zod.ZodObject<{
12907
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12908
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12909
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12910
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
12911
- }, zod_v4_core.$strict>>;
12912
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
12913
- input: zod.ZodNumber;
12914
- output: zod.ZodNumber;
12915
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
12916
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12917
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12918
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
12919
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
12920
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
12921
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
12922
- mode: zod.ZodOptional<zod.ZodEnum<{
12923
- ordered: "ordered";
12924
- "most-allowance": "most-allowance";
12925
- "soonest-reset": "soonest-reset";
12926
- spread: "spread";
12927
- adaptive: "adaptive";
12928
- "lowest-latency": "lowest-latency";
12929
- "highest-success": "highest-success";
12930
- cheapest: "cheapest";
12931
- }>>;
12932
- context: zod.ZodOptional<zod.ZodNumber>;
12933
- vision: zod.ZodOptional<zod.ZodBoolean>;
12934
- tools: zod.ZodOptional<zod.ZodBoolean>;
12935
- thinking: zod.ZodOptional<zod.ZodBoolean>;
12936
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
12937
- }, zod_v4_core.$strict>>;
12938
13242
  path: zod.ZodString;
12939
13243
  configProfile: zod.ZodOptional<zod.ZodString>;
12940
13244
  identity: zod.ZodOptional<zod.ZodString>;
@@ -13096,8 +13400,55 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13096
13400
  key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
13097
13401
  }, zod_v4_core.$strip>], "kind">]>;
13098
13402
  }, zod_v4_core.$strict>]>>>;
13099
- extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13403
+ models: zod.ZodOptional<zod.ZodObject<{
13404
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
13405
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
13406
+ mode: zod.ZodEnum<{
13407
+ ordered: "ordered";
13408
+ "most-allowance": "most-allowance";
13409
+ "soonest-reset": "soonest-reset";
13410
+ spread: "spread";
13411
+ adaptive: "adaptive";
13412
+ "lowest-latency": "lowest-latency";
13413
+ "highest-success": "highest-success";
13414
+ cheapest: "cheapest";
13415
+ }>;
13416
+ members: zod.ZodArray<zod.ZodString>;
13417
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
13418
+ tiers: zod.ZodOptional<zod.ZodObject<{
13419
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13420
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13421
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13422
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13423
+ }, zod_v4_core.$strict>>;
13424
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
13425
+ input: zod.ZodNumber;
13426
+ output: zod.ZodNumber;
13427
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
13428
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13429
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13430
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
13431
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
13432
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
13433
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13434
+ mode: zod.ZodOptional<zod.ZodEnum<{
13435
+ ordered: "ordered";
13436
+ "most-allowance": "most-allowance";
13437
+ "soonest-reset": "soonest-reset";
13438
+ spread: "spread";
13439
+ adaptive: "adaptive";
13440
+ "lowest-latency": "lowest-latency";
13441
+ "highest-success": "highest-success";
13442
+ cheapest: "cheapest";
13443
+ }>>;
13444
+ context: zod.ZodOptional<zod.ZodNumber>;
13445
+ vision: zod.ZodOptional<zod.ZodBoolean>;
13446
+ tools: zod.ZodOptional<zod.ZodBoolean>;
13447
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
13448
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
13449
+ }, zod_v4_core.$strict>>;
13100
13450
  $schema: zod.ZodOptional<zod.ZodString>;
13451
+ extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13101
13452
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
13102
13453
  all: zod.ZodOptional<zod.ZodBoolean>;
13103
13454
  runtime: zod.ZodOptional<zod.ZodBoolean>;
@@ -13140,30 +13491,30 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13140
13491
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
13141
13492
  identity: "identity";
13142
13493
  model: "model";
13494
+ route: "route";
13143
13495
  account: "account";
13144
13496
  provider: "provider";
13497
+ version: "version";
13145
13498
  headroom: "headroom";
13146
- route: "route";
13499
+ duration: "duration";
13147
13500
  project: "project";
13148
13501
  vcs: "vcs";
13149
13502
  effort: "effort";
13150
13503
  advisor: "advisor";
13151
- version: "version";
13152
13504
  outputStyle: "outputStyle";
13153
13505
  cost: "cost";
13154
13506
  dailyCost: "dailyCost";
13155
13507
  sessionName: "sessionName";
13156
- duration: "duration";
13157
13508
  speed: "speed";
13158
13509
  extra: "extra";
13159
13510
  }>>>;
13160
13511
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
13161
13512
  context: "context";
13162
13513
  quota: "quota";
13514
+ environment: "environment";
13163
13515
  addedDirs: "addedDirs";
13164
13516
  gitFiles: "gitFiles";
13165
13517
  memory: "memory";
13166
- environment: "environment";
13167
13518
  sessionTime: "sessionTime";
13168
13519
  promptCache: "promptCache";
13169
13520
  compactions: "compactions";
@@ -13186,10 +13537,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13186
13537
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
13187
13538
  context: "context";
13188
13539
  quota: "quota";
13540
+ environment: "environment";
13189
13541
  addedDirs: "addedDirs";
13190
13542
  gitFiles: "gitFiles";
13191
13543
  memory: "memory";
13192
- environment: "environment";
13193
13544
  sessionTime: "sessionTime";
13194
13545
  promptCache: "promptCache";
13195
13546
  compactions: "compactions";
@@ -13203,10 +13554,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13203
13554
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
13204
13555
  context: "context";
13205
13556
  quota: "quota";
13557
+ environment: "environment";
13206
13558
  addedDirs: "addedDirs";
13207
13559
  gitFiles: "gitFiles";
13208
13560
  memory: "memory";
13209
- environment: "environment";
13210
13561
  sessionTime: "sessionTime";
13211
13562
  promptCache: "promptCache";
13212
13563
  compactions: "compactions";
@@ -13265,10 +13616,10 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13265
13616
  hidden: "hidden";
13266
13617
  }>>;
13267
13618
  value: zod.ZodOptional<zod.ZodEnum<{
13619
+ remaining: "remaining";
13268
13620
  tokens: "tokens";
13269
13621
  both: "both";
13270
13622
  percent: "percent";
13271
- remaining: "remaining";
13272
13623
  }>>;
13273
13624
  estimate: zod.ZodOptional<zod.ZodEnum<{
13274
13625
  never: "never";
@@ -13310,8 +13661,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13310
13661
  }, zod_v4_core.$strict>>;
13311
13662
  usage: zod.ZodOptional<zod.ZodObject<{
13312
13663
  value: zod.ZodOptional<zod.ZodEnum<{
13313
- remaining: "remaining";
13314
13664
  used: "used";
13665
+ remaining: "remaining";
13315
13666
  }>>;
13316
13667
  bar: zod.ZodOptional<zod.ZodBoolean>;
13317
13668
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -13669,53 +14020,6 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13669
14020
  }, zod_v4_core.$strict>>;
13670
14021
  }, zod_v4_core.$strict>>;
13671
14022
  }, zod_v4_core.$strict>>;
13672
- models: zod.ZodOptional<zod.ZodObject<{
13673
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
13674
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
13675
- mode: zod.ZodEnum<{
13676
- ordered: "ordered";
13677
- "most-allowance": "most-allowance";
13678
- "soonest-reset": "soonest-reset";
13679
- spread: "spread";
13680
- adaptive: "adaptive";
13681
- "lowest-latency": "lowest-latency";
13682
- "highest-success": "highest-success";
13683
- cheapest: "cheapest";
13684
- }>;
13685
- members: zod.ZodArray<zod.ZodString>;
13686
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
13687
- tiers: zod.ZodOptional<zod.ZodObject<{
13688
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13689
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13690
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13691
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
13692
- }, zod_v4_core.$strict>>;
13693
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
13694
- input: zod.ZodNumber;
13695
- output: zod.ZodNumber;
13696
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
13697
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13698
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13699
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
13700
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
13701
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
13702
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
13703
- mode: zod.ZodOptional<zod.ZodEnum<{
13704
- ordered: "ordered";
13705
- "most-allowance": "most-allowance";
13706
- "soonest-reset": "soonest-reset";
13707
- spread: "spread";
13708
- adaptive: "adaptive";
13709
- "lowest-latency": "lowest-latency";
13710
- "highest-success": "highest-success";
13711
- cheapest: "cheapest";
13712
- }>>;
13713
- context: zod.ZodOptional<zod.ZodNumber>;
13714
- vision: zod.ZodOptional<zod.ZodBoolean>;
13715
- tools: zod.ZodOptional<zod.ZodBoolean>;
13716
- thinking: zod.ZodOptional<zod.ZodBoolean>;
13717
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
13718
- }, zod_v4_core.$strict>>;
13719
14023
  path: zod.ZodString;
13720
14024
  configProfile: zod.ZodOptional<zod.ZodString>;
13721
14025
  identity: zod.ZodOptional<zod.ZodString>;
@@ -14120,9 +14424,9 @@ declare function createLifecycleApiRouter(deps: LifecycleApiDeps): {
14120
14424
  current: z.ZodString;
14121
14425
  latest: z.ZodString;
14122
14426
  action: z.ZodEnum<{
14123
- updated: "updated";
14124
14427
  current: "current";
14125
14428
  available: "available";
14429
+ updated: "updated";
14126
14430
  }>;
14127
14431
  }, z.core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
14128
14432
  };
@@ -14160,30 +14464,30 @@ declare const StatuslineSchema: z.ZodObject<{
14160
14464
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
14161
14465
  identity: "identity";
14162
14466
  model: "model";
14467
+ route: "route";
14163
14468
  account: "account";
14164
14469
  provider: "provider";
14470
+ version: "version";
14165
14471
  headroom: "headroom";
14166
- route: "route";
14472
+ duration: "duration";
14167
14473
  project: "project";
14168
14474
  vcs: "vcs";
14169
14475
  effort: "effort";
14170
14476
  advisor: "advisor";
14171
- version: "version";
14172
14477
  outputStyle: "outputStyle";
14173
14478
  cost: "cost";
14174
14479
  dailyCost: "dailyCost";
14175
14480
  sessionName: "sessionName";
14176
- duration: "duration";
14177
14481
  speed: "speed";
14178
14482
  extra: "extra";
14179
14483
  }>>>;
14180
14484
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
14181
14485
  context: "context";
14182
14486
  quota: "quota";
14487
+ environment: "environment";
14183
14488
  addedDirs: "addedDirs";
14184
14489
  gitFiles: "gitFiles";
14185
14490
  memory: "memory";
14186
- environment: "environment";
14187
14491
  sessionTime: "sessionTime";
14188
14492
  promptCache: "promptCache";
14189
14493
  compactions: "compactions";
@@ -14206,10 +14510,10 @@ declare const StatuslineSchema: z.ZodObject<{
14206
14510
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
14207
14511
  context: "context";
14208
14512
  quota: "quota";
14513
+ environment: "environment";
14209
14514
  addedDirs: "addedDirs";
14210
14515
  gitFiles: "gitFiles";
14211
14516
  memory: "memory";
14212
- environment: "environment";
14213
14517
  sessionTime: "sessionTime";
14214
14518
  promptCache: "promptCache";
14215
14519
  compactions: "compactions";
@@ -14223,10 +14527,10 @@ declare const StatuslineSchema: z.ZodObject<{
14223
14527
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
14224
14528
  context: "context";
14225
14529
  quota: "quota";
14530
+ environment: "environment";
14226
14531
  addedDirs: "addedDirs";
14227
14532
  gitFiles: "gitFiles";
14228
14533
  memory: "memory";
14229
- environment: "environment";
14230
14534
  sessionTime: "sessionTime";
14231
14535
  promptCache: "promptCache";
14232
14536
  compactions: "compactions";
@@ -14285,10 +14589,10 @@ declare const StatuslineSchema: z.ZodObject<{
14285
14589
  hidden: "hidden";
14286
14590
  }>>;
14287
14591
  value: z.ZodOptional<z.ZodEnum<{
14592
+ remaining: "remaining";
14288
14593
  tokens: "tokens";
14289
14594
  both: "both";
14290
14595
  percent: "percent";
14291
- remaining: "remaining";
14292
14596
  }>>;
14293
14597
  estimate: z.ZodOptional<z.ZodEnum<{
14294
14598
  never: "never";
@@ -14330,8 +14634,8 @@ declare const StatuslineSchema: z.ZodObject<{
14330
14634
  }, z.core.$strict>>;
14331
14635
  usage: z.ZodOptional<z.ZodObject<{
14332
14636
  value: z.ZodOptional<z.ZodEnum<{
14333
- remaining: "remaining";
14334
14637
  used: "used";
14638
+ remaining: "remaining";
14335
14639
  }>>;
14336
14640
  bar: z.ZodOptional<z.ZodBoolean>;
14337
14641
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -14730,18 +15034,6 @@ interface SupervisedLaunch {
14730
15034
  readonly settingsFile?: string;
14731
15035
  }
14732
15036
 
14733
- /** The effects a hold needs, so it runs against fakes in tests. */
14734
- interface HoldPort {
14735
- /** Whether a person is watching: standard input and standard output are both terminals. A launch nobody watches is never held. */
14736
- readonly attended: () => boolean;
14737
- /** Blocks for `ms` milliseconds. */
14738
- readonly sleep: (ms: number) => void;
14739
- /** Blocks until one key is pressed, and says whether it was the interrupt key (Ctrl-C), which a terminal in the mode this reads in delivers as a byte and not as a signal. */
14740
- readonly waitForKey: () => "key" | "interrupt";
14741
- }
14742
- /** What a hold decided: carry on with the launch, or the person cancelled it. */
14743
- type HoldOutcome = "go" | "cancelled";
14744
-
14745
15037
  /**
14746
15038
  * Everything the launch-time update check needs from its host, injected so tests run it against scripted answers and no launch ever reaches GitHub by accident. Deliberately narrower than `UpdatePorts`: the launch path never downloads anything (the detached `agent-shim update` does), so only the release check, the cooldown stamp, the clock, the background spawn and the terminal are wired.
14747
15039
  */
@@ -14973,12 +15265,12 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
14973
15265
  identity: zod.ZodOptional<zod.ZodString>;
14974
15266
  identityId: zod.ZodOptional<zod.ZodString>;
14975
15267
  identitySource: zod.ZodEnum<{
14976
- env: "env";
14977
- none: "none";
14978
15268
  "config-dir-escape-hatch": "config-dir-escape-hatch";
14979
15269
  argv: "argv";
15270
+ env: "env";
14980
15271
  "directory-pin": "directory-pin";
14981
15272
  "active-identity-file": "active-identity-file";
15273
+ none: "none";
14982
15274
  }>;
14983
15275
  pool: zod.ZodOptional<zod.ZodObject<{
14984
15276
  name: zod.ZodString;
@@ -15028,30 +15320,30 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15028
15320
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
15029
15321
  identity: "identity";
15030
15322
  model: "model";
15323
+ route: "route";
15031
15324
  account: "account";
15032
15325
  provider: "provider";
15326
+ version: "version";
15033
15327
  headroom: "headroom";
15034
- route: "route";
15328
+ duration: "duration";
15035
15329
  project: "project";
15036
15330
  vcs: "vcs";
15037
15331
  effort: "effort";
15038
15332
  advisor: "advisor";
15039
- version: "version";
15040
15333
  outputStyle: "outputStyle";
15041
15334
  cost: "cost";
15042
15335
  dailyCost: "dailyCost";
15043
15336
  sessionName: "sessionName";
15044
- duration: "duration";
15045
15337
  speed: "speed";
15046
15338
  extra: "extra";
15047
15339
  }>>>;
15048
15340
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
15049
15341
  context: "context";
15050
15342
  quota: "quota";
15343
+ environment: "environment";
15051
15344
  addedDirs: "addedDirs";
15052
15345
  gitFiles: "gitFiles";
15053
15346
  memory: "memory";
15054
- environment: "environment";
15055
15347
  sessionTime: "sessionTime";
15056
15348
  promptCache: "promptCache";
15057
15349
  compactions: "compactions";
@@ -15074,10 +15366,10 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15074
15366
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
15075
15367
  context: "context";
15076
15368
  quota: "quota";
15369
+ environment: "environment";
15077
15370
  addedDirs: "addedDirs";
15078
15371
  gitFiles: "gitFiles";
15079
15372
  memory: "memory";
15080
- environment: "environment";
15081
15373
  sessionTime: "sessionTime";
15082
15374
  promptCache: "promptCache";
15083
15375
  compactions: "compactions";
@@ -15091,10 +15383,10 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15091
15383
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
15092
15384
  context: "context";
15093
15385
  quota: "quota";
15386
+ environment: "environment";
15094
15387
  addedDirs: "addedDirs";
15095
15388
  gitFiles: "gitFiles";
15096
15389
  memory: "memory";
15097
- environment: "environment";
15098
15390
  sessionTime: "sessionTime";
15099
15391
  promptCache: "promptCache";
15100
15392
  compactions: "compactions";
@@ -15153,10 +15445,10 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15153
15445
  hidden: "hidden";
15154
15446
  }>>;
15155
15447
  value: zod.ZodOptional<zod.ZodEnum<{
15448
+ remaining: "remaining";
15156
15449
  tokens: "tokens";
15157
15450
  both: "both";
15158
15451
  percent: "percent";
15159
- remaining: "remaining";
15160
15452
  }>>;
15161
15453
  estimate: zod.ZodOptional<zod.ZodEnum<{
15162
15454
  never: "never";
@@ -15198,8 +15490,8 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15198
15490
  }, zod_v4_core.$strict>>;
15199
15491
  usage: zod.ZodOptional<zod.ZodObject<{
15200
15492
  value: zod.ZodOptional<zod.ZodEnum<{
15201
- remaining: "remaining";
15202
15493
  used: "used";
15494
+ remaining: "remaining";
15203
15495
  }>>;
15204
15496
  bar: zod.ZodOptional<zod.ZodBoolean>;
15205
15497
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -15560,8 +15852,8 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15560
15852
  claudeVersion: zod.ZodOptional<zod.ZodObject<{
15561
15853
  version: zod.ZodString;
15562
15854
  source: zod.ZodEnum<{
15563
- environment: "environment";
15564
15855
  flag: "flag";
15856
+ environment: "environment";
15565
15857
  cascade: "cascade";
15566
15858
  }>;
15567
15859
  }, zod_v4_core.$strict>>;
@@ -16181,12 +16473,12 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
16181
16473
  identity: zod.ZodObject<{
16182
16474
  name: zod.ZodNullable<zod.ZodString>;
16183
16475
  source: zod.ZodEnum<{
16184
- env: "env";
16185
- none: "none";
16186
16476
  "config-dir-escape-hatch": "config-dir-escape-hatch";
16187
16477
  argv: "argv";
16478
+ env: "env";
16188
16479
  "directory-pin": "directory-pin";
16189
16480
  "active-identity-file": "active-identity-file";
16481
+ none: "none";
16190
16482
  }>;
16191
16483
  }, zod_v4_core.$strict>;
16192
16484
  pool: zod.ZodOptional<zod.ZodObject<{
@@ -16264,11 +16556,11 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
16264
16556
  "category-default": "category-default";
16265
16557
  }>;
16266
16558
  category: zod.ZodNullable<zod.ZodEnum<{
16559
+ secret: "secret";
16267
16560
  runtime: "runtime";
16268
16561
  history: "history";
16269
16562
  knowledge: "knowledge";
16270
16563
  settings: "settings";
16271
- secret: "secret";
16272
16564
  }>>;
16273
16565
  rule: zod.ZodOptional<zod.ZodObject<{
16274
16566
  key: zod.ZodString;
@@ -16468,8 +16760,8 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
16468
16760
  pinned: zod.ZodOptional<zod.ZodObject<{
16469
16761
  version: zod.ZodString;
16470
16762
  source: zod.ZodEnum<{
16471
- environment: "environment";
16472
16763
  flag: "flag";
16764
+ environment: "environment";
16473
16765
  cascade: "cascade";
16474
16766
  }>;
16475
16767
  installed: zod.ZodBoolean;
@@ -16487,12 +16779,10 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
16487
16779
  "global-config": "global-config";
16488
16780
  "config-profile": "config-profile";
16489
16781
  identity: "identity";
16490
- keychain: "keychain";
16491
16782
  provider: "provider";
16492
- headroom: "headroom";
16493
- models: "models";
16494
- pool: "pool";
16495
16783
  frontdoor: "frontdoor";
16784
+ pool: "pool";
16785
+ keychain: "keychain";
16496
16786
  "ambient-credential": "ambient-credential";
16497
16787
  "binary-discovery": "binary-discovery";
16498
16788
  "claude-shim": "claude-shim";
@@ -16502,6 +16792,8 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
16502
16792
  "directory-rules": "directory-rules";
16503
16793
  "categories-local": "categories-local";
16504
16794
  "active-identity": "active-identity";
16795
+ headroom: "headroom";
16796
+ models: "models";
16505
16797
  }>;
16506
16798
  subject: zod.ZodOptional<zod.ZodString>;
16507
16799
  severity: zod.ZodEnum<{
@@ -16699,12 +16991,12 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
16699
16991
  identity: zod.ZodOptional<zod.ZodString>;
16700
16992
  identityId: zod.ZodOptional<zod.ZodString>;
16701
16993
  identitySource: zod.ZodEnum<{
16702
- env: "env";
16703
- none: "none";
16704
16994
  "config-dir-escape-hatch": "config-dir-escape-hatch";
16705
16995
  argv: "argv";
16996
+ env: "env";
16706
16997
  "directory-pin": "directory-pin";
16707
16998
  "active-identity-file": "active-identity-file";
16999
+ none: "none";
16708
17000
  }>;
16709
17001
  pool: zod.ZodOptional<zod.ZodObject<{
16710
17002
  name: zod.ZodString;
@@ -16754,30 +17046,30 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
16754
17046
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
16755
17047
  identity: "identity";
16756
17048
  model: "model";
17049
+ route: "route";
16757
17050
  account: "account";
16758
17051
  provider: "provider";
17052
+ version: "version";
16759
17053
  headroom: "headroom";
16760
- route: "route";
17054
+ duration: "duration";
16761
17055
  project: "project";
16762
17056
  vcs: "vcs";
16763
17057
  effort: "effort";
16764
17058
  advisor: "advisor";
16765
- version: "version";
16766
17059
  outputStyle: "outputStyle";
16767
17060
  cost: "cost";
16768
17061
  dailyCost: "dailyCost";
16769
17062
  sessionName: "sessionName";
16770
- duration: "duration";
16771
17063
  speed: "speed";
16772
17064
  extra: "extra";
16773
17065
  }>>>;
16774
17066
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
16775
17067
  context: "context";
16776
17068
  quota: "quota";
17069
+ environment: "environment";
16777
17070
  addedDirs: "addedDirs";
16778
17071
  gitFiles: "gitFiles";
16779
17072
  memory: "memory";
16780
- environment: "environment";
16781
17073
  sessionTime: "sessionTime";
16782
17074
  promptCache: "promptCache";
16783
17075
  compactions: "compactions";
@@ -16800,10 +17092,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
16800
17092
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
16801
17093
  context: "context";
16802
17094
  quota: "quota";
17095
+ environment: "environment";
16803
17096
  addedDirs: "addedDirs";
16804
17097
  gitFiles: "gitFiles";
16805
17098
  memory: "memory";
16806
- environment: "environment";
16807
17099
  sessionTime: "sessionTime";
16808
17100
  promptCache: "promptCache";
16809
17101
  compactions: "compactions";
@@ -16817,10 +17109,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
16817
17109
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
16818
17110
  context: "context";
16819
17111
  quota: "quota";
17112
+ environment: "environment";
16820
17113
  addedDirs: "addedDirs";
16821
17114
  gitFiles: "gitFiles";
16822
17115
  memory: "memory";
16823
- environment: "environment";
16824
17116
  sessionTime: "sessionTime";
16825
17117
  promptCache: "promptCache";
16826
17118
  compactions: "compactions";
@@ -16879,10 +17171,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
16879
17171
  hidden: "hidden";
16880
17172
  }>>;
16881
17173
  value: zod.ZodOptional<zod.ZodEnum<{
17174
+ remaining: "remaining";
16882
17175
  tokens: "tokens";
16883
17176
  both: "both";
16884
17177
  percent: "percent";
16885
- remaining: "remaining";
16886
17178
  }>>;
16887
17179
  estimate: zod.ZodOptional<zod.ZodEnum<{
16888
17180
  never: "never";
@@ -16924,8 +17216,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
16924
17216
  }, zod_v4_core.$strict>>;
16925
17217
  usage: zod.ZodOptional<zod.ZodObject<{
16926
17218
  value: zod.ZodOptional<zod.ZodEnum<{
16927
- remaining: "remaining";
16928
17219
  used: "used";
17220
+ remaining: "remaining";
16929
17221
  }>>;
16930
17222
  bar: zod.ZodOptional<zod.ZodBoolean>;
16931
17223
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -17286,8 +17578,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17286
17578
  claudeVersion: zod.ZodOptional<zod.ZodObject<{
17287
17579
  version: zod.ZodString;
17288
17580
  source: zod.ZodEnum<{
17289
- environment: "environment";
17290
17581
  flag: "flag";
17582
+ environment: "environment";
17291
17583
  cascade: "cascade";
17292
17584
  }>;
17293
17585
  }, zod_v4_core.$strict>>;
@@ -17635,6 +17927,53 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17635
17927
  }, zod_v4_core.$strip>], "kind">]>;
17636
17928
  }, zod_v4_core.$strict>]>>>;
17637
17929
  description: zod.ZodOptional<zod.ZodString>;
17930
+ models: zod.ZodOptional<zod.ZodObject<{
17931
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
17932
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
17933
+ mode: zod.ZodEnum<{
17934
+ ordered: "ordered";
17935
+ "most-allowance": "most-allowance";
17936
+ "soonest-reset": "soonest-reset";
17937
+ spread: "spread";
17938
+ adaptive: "adaptive";
17939
+ "lowest-latency": "lowest-latency";
17940
+ "highest-success": "highest-success";
17941
+ cheapest: "cheapest";
17942
+ }>;
17943
+ members: zod.ZodArray<zod.ZodString>;
17944
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
17945
+ tiers: zod.ZodOptional<zod.ZodObject<{
17946
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
17947
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
17948
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
17949
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
17950
+ }, zod_v4_core.$strict>>;
17951
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
17952
+ input: zod.ZodNumber;
17953
+ output: zod.ZodNumber;
17954
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
17955
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
17956
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
17957
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
17958
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
17959
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
17960
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
17961
+ mode: zod.ZodOptional<zod.ZodEnum<{
17962
+ ordered: "ordered";
17963
+ "most-allowance": "most-allowance";
17964
+ "soonest-reset": "soonest-reset";
17965
+ spread: "spread";
17966
+ adaptive: "adaptive";
17967
+ "lowest-latency": "lowest-latency";
17968
+ "highest-success": "highest-success";
17969
+ cheapest: "cheapest";
17970
+ }>>;
17971
+ context: zod.ZodOptional<zod.ZodNumber>;
17972
+ vision: zod.ZodOptional<zod.ZodBoolean>;
17973
+ tools: zod.ZodOptional<zod.ZodBoolean>;
17974
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
17975
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
17976
+ }, zod_v4_core.$strict>>;
17638
17977
  extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
17639
17978
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
17640
17979
  all: zod.ZodOptional<zod.ZodBoolean>;
@@ -17678,30 +18017,30 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17678
18017
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
17679
18018
  identity: "identity";
17680
18019
  model: "model";
18020
+ route: "route";
17681
18021
  account: "account";
17682
18022
  provider: "provider";
18023
+ version: "version";
17683
18024
  headroom: "headroom";
17684
- route: "route";
18025
+ duration: "duration";
17685
18026
  project: "project";
17686
18027
  vcs: "vcs";
17687
18028
  effort: "effort";
17688
18029
  advisor: "advisor";
17689
- version: "version";
17690
18030
  outputStyle: "outputStyle";
17691
18031
  cost: "cost";
17692
18032
  dailyCost: "dailyCost";
17693
18033
  sessionName: "sessionName";
17694
- duration: "duration";
17695
18034
  speed: "speed";
17696
18035
  extra: "extra";
17697
18036
  }>>>;
17698
18037
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
17699
18038
  context: "context";
17700
18039
  quota: "quota";
18040
+ environment: "environment";
17701
18041
  addedDirs: "addedDirs";
17702
18042
  gitFiles: "gitFiles";
17703
18043
  memory: "memory";
17704
- environment: "environment";
17705
18044
  sessionTime: "sessionTime";
17706
18045
  promptCache: "promptCache";
17707
18046
  compactions: "compactions";
@@ -17724,10 +18063,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17724
18063
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
17725
18064
  context: "context";
17726
18065
  quota: "quota";
18066
+ environment: "environment";
17727
18067
  addedDirs: "addedDirs";
17728
18068
  gitFiles: "gitFiles";
17729
18069
  memory: "memory";
17730
- environment: "environment";
17731
18070
  sessionTime: "sessionTime";
17732
18071
  promptCache: "promptCache";
17733
18072
  compactions: "compactions";
@@ -17741,10 +18080,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17741
18080
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
17742
18081
  context: "context";
17743
18082
  quota: "quota";
18083
+ environment: "environment";
17744
18084
  addedDirs: "addedDirs";
17745
18085
  gitFiles: "gitFiles";
17746
18086
  memory: "memory";
17747
- environment: "environment";
17748
18087
  sessionTime: "sessionTime";
17749
18088
  promptCache: "promptCache";
17750
18089
  compactions: "compactions";
@@ -17803,10 +18142,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17803
18142
  hidden: "hidden";
17804
18143
  }>>;
17805
18144
  value: zod.ZodOptional<zod.ZodEnum<{
18145
+ remaining: "remaining";
17806
18146
  tokens: "tokens";
17807
18147
  both: "both";
17808
18148
  percent: "percent";
17809
- remaining: "remaining";
17810
18149
  }>>;
17811
18150
  estimate: zod.ZodOptional<zod.ZodEnum<{
17812
18151
  never: "never";
@@ -17848,8 +18187,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17848
18187
  }, zod_v4_core.$strict>>;
17849
18188
  usage: zod.ZodOptional<zod.ZodObject<{
17850
18189
  value: zod.ZodOptional<zod.ZodEnum<{
17851
- remaining: "remaining";
17852
18190
  used: "used";
18191
+ remaining: "remaining";
17853
18192
  }>>;
17854
18193
  bar: zod.ZodOptional<zod.ZodBoolean>;
17855
18194
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -18207,53 +18546,6 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18207
18546
  }, zod_v4_core.$strict>>;
18208
18547
  }, zod_v4_core.$strict>>;
18209
18548
  }, zod_v4_core.$strict>>;
18210
- models: zod.ZodOptional<zod.ZodObject<{
18211
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
18212
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18213
- mode: zod.ZodEnum<{
18214
- ordered: "ordered";
18215
- "most-allowance": "most-allowance";
18216
- "soonest-reset": "soonest-reset";
18217
- spread: "spread";
18218
- adaptive: "adaptive";
18219
- "lowest-latency": "lowest-latency";
18220
- "highest-success": "highest-success";
18221
- cheapest: "cheapest";
18222
- }>;
18223
- members: zod.ZodArray<zod.ZodString>;
18224
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18225
- tiers: zod.ZodOptional<zod.ZodObject<{
18226
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18227
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18228
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18229
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18230
- }, zod_v4_core.$strict>>;
18231
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18232
- input: zod.ZodNumber;
18233
- output: zod.ZodNumber;
18234
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18235
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18236
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18237
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
18238
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
18239
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18240
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18241
- mode: zod.ZodOptional<zod.ZodEnum<{
18242
- ordered: "ordered";
18243
- "most-allowance": "most-allowance";
18244
- "soonest-reset": "soonest-reset";
18245
- spread: "spread";
18246
- adaptive: "adaptive";
18247
- "lowest-latency": "lowest-latency";
18248
- "highest-success": "highest-success";
18249
- cheapest: "cheapest";
18250
- }>>;
18251
- context: zod.ZodOptional<zod.ZodNumber>;
18252
- vision: zod.ZodOptional<zod.ZodBoolean>;
18253
- tools: zod.ZodOptional<zod.ZodBoolean>;
18254
- thinking: zod.ZodOptional<zod.ZodBoolean>;
18255
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18256
- }, zod_v4_core.$strict>>;
18257
18549
  }, zod_v4_core.$strict>;
18258
18550
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
18259
18551
  set: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
@@ -18359,6 +18651,53 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18359
18651
  }, zod_v4_core.$strip>], "kind">]>;
18360
18652
  }, zod_v4_core.$strict>]>>>;
18361
18653
  description: zod.ZodOptional<zod.ZodString>;
18654
+ models: zod.ZodOptional<zod.ZodObject<{
18655
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
18656
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18657
+ mode: zod.ZodEnum<{
18658
+ ordered: "ordered";
18659
+ "most-allowance": "most-allowance";
18660
+ "soonest-reset": "soonest-reset";
18661
+ spread: "spread";
18662
+ adaptive: "adaptive";
18663
+ "lowest-latency": "lowest-latency";
18664
+ "highest-success": "highest-success";
18665
+ cheapest: "cheapest";
18666
+ }>;
18667
+ members: zod.ZodArray<zod.ZodString>;
18668
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18669
+ tiers: zod.ZodOptional<zod.ZodObject<{
18670
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18671
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18672
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18673
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18674
+ }, zod_v4_core.$strict>>;
18675
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18676
+ input: zod.ZodNumber;
18677
+ output: zod.ZodNumber;
18678
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18679
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18680
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18681
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
18682
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
18683
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18684
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18685
+ mode: zod.ZodOptional<zod.ZodEnum<{
18686
+ ordered: "ordered";
18687
+ "most-allowance": "most-allowance";
18688
+ "soonest-reset": "soonest-reset";
18689
+ spread: "spread";
18690
+ adaptive: "adaptive";
18691
+ "lowest-latency": "lowest-latency";
18692
+ "highest-success": "highest-success";
18693
+ cheapest: "cheapest";
18694
+ }>>;
18695
+ context: zod.ZodOptional<zod.ZodNumber>;
18696
+ vision: zod.ZodOptional<zod.ZodBoolean>;
18697
+ tools: zod.ZodOptional<zod.ZodBoolean>;
18698
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
18699
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18700
+ }, zod_v4_core.$strict>>;
18362
18701
  extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18363
18702
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
18364
18703
  all: zod.ZodOptional<zod.ZodBoolean>;
@@ -18402,30 +18741,30 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18402
18741
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
18403
18742
  identity: "identity";
18404
18743
  model: "model";
18744
+ route: "route";
18405
18745
  account: "account";
18406
18746
  provider: "provider";
18747
+ version: "version";
18407
18748
  headroom: "headroom";
18408
- route: "route";
18749
+ duration: "duration";
18409
18750
  project: "project";
18410
18751
  vcs: "vcs";
18411
18752
  effort: "effort";
18412
18753
  advisor: "advisor";
18413
- version: "version";
18414
18754
  outputStyle: "outputStyle";
18415
18755
  cost: "cost";
18416
18756
  dailyCost: "dailyCost";
18417
18757
  sessionName: "sessionName";
18418
- duration: "duration";
18419
18758
  speed: "speed";
18420
18759
  extra: "extra";
18421
18760
  }>>>;
18422
18761
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
18423
18762
  context: "context";
18424
18763
  quota: "quota";
18764
+ environment: "environment";
18425
18765
  addedDirs: "addedDirs";
18426
18766
  gitFiles: "gitFiles";
18427
18767
  memory: "memory";
18428
- environment: "environment";
18429
18768
  sessionTime: "sessionTime";
18430
18769
  promptCache: "promptCache";
18431
18770
  compactions: "compactions";
@@ -18448,10 +18787,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18448
18787
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
18449
18788
  context: "context";
18450
18789
  quota: "quota";
18790
+ environment: "environment";
18451
18791
  addedDirs: "addedDirs";
18452
18792
  gitFiles: "gitFiles";
18453
18793
  memory: "memory";
18454
- environment: "environment";
18455
18794
  sessionTime: "sessionTime";
18456
18795
  promptCache: "promptCache";
18457
18796
  compactions: "compactions";
@@ -18465,10 +18804,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18465
18804
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
18466
18805
  context: "context";
18467
18806
  quota: "quota";
18807
+ environment: "environment";
18468
18808
  addedDirs: "addedDirs";
18469
18809
  gitFiles: "gitFiles";
18470
18810
  memory: "memory";
18471
- environment: "environment";
18472
18811
  sessionTime: "sessionTime";
18473
18812
  promptCache: "promptCache";
18474
18813
  compactions: "compactions";
@@ -18527,10 +18866,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18527
18866
  hidden: "hidden";
18528
18867
  }>>;
18529
18868
  value: zod.ZodOptional<zod.ZodEnum<{
18869
+ remaining: "remaining";
18530
18870
  tokens: "tokens";
18531
18871
  both: "both";
18532
18872
  percent: "percent";
18533
- remaining: "remaining";
18534
18873
  }>>;
18535
18874
  estimate: zod.ZodOptional<zod.ZodEnum<{
18536
18875
  never: "never";
@@ -18572,8 +18911,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18572
18911
  }, zod_v4_core.$strict>>;
18573
18912
  usage: zod.ZodOptional<zod.ZodObject<{
18574
18913
  value: zod.ZodOptional<zod.ZodEnum<{
18575
- remaining: "remaining";
18576
18914
  used: "used";
18915
+ remaining: "remaining";
18577
18916
  }>>;
18578
18917
  bar: zod.ZodOptional<zod.ZodBoolean>;
18579
18918
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -18931,53 +19270,6 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18931
19270
  }, zod_v4_core.$strict>>;
18932
19271
  }, zod_v4_core.$strict>>;
18933
19272
  }, zod_v4_core.$strict>>;
18934
- models: zod.ZodOptional<zod.ZodObject<{
18935
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
18936
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18937
- mode: zod.ZodEnum<{
18938
- ordered: "ordered";
18939
- "most-allowance": "most-allowance";
18940
- "soonest-reset": "soonest-reset";
18941
- spread: "spread";
18942
- adaptive: "adaptive";
18943
- "lowest-latency": "lowest-latency";
18944
- "highest-success": "highest-success";
18945
- cheapest: "cheapest";
18946
- }>;
18947
- members: zod.ZodArray<zod.ZodString>;
18948
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18949
- tiers: zod.ZodOptional<zod.ZodObject<{
18950
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18951
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18952
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18953
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
18954
- }, zod_v4_core.$strict>>;
18955
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18956
- input: zod.ZodNumber;
18957
- output: zod.ZodNumber;
18958
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18959
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18960
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18961
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
18962
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
18963
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
18964
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
18965
- mode: zod.ZodOptional<zod.ZodEnum<{
18966
- ordered: "ordered";
18967
- "most-allowance": "most-allowance";
18968
- "soonest-reset": "soonest-reset";
18969
- spread: "spread";
18970
- adaptive: "adaptive";
18971
- "lowest-latency": "lowest-latency";
18972
- "highest-success": "highest-success";
18973
- cheapest: "cheapest";
18974
- }>>;
18975
- context: zod.ZodOptional<zod.ZodNumber>;
18976
- vision: zod.ZodOptional<zod.ZodBoolean>;
18977
- tools: zod.ZodOptional<zod.ZodBoolean>;
18978
- thinking: zod.ZodOptional<zod.ZodBoolean>;
18979
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
18980
- }, zod_v4_core.$strict>>;
18981
19273
  }, zod_v4_core.$strict>;
18982
19274
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
18983
19275
  remove: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
@@ -19215,8 +19507,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19215
19507
  add: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
19216
19508
  name: zod.ZodString;
19217
19509
  kind: zod.ZodOptional<zod.ZodEnum<{
19218
- http: "http";
19219
19510
  codex: "codex";
19511
+ http: "http";
19220
19512
  antigravity: "antigravity";
19221
19513
  router: "router";
19222
19514
  }>>;
@@ -19279,8 +19571,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19279
19571
  value: zod.ZodObject<{
19280
19572
  name: zod.ZodString;
19281
19573
  kind: zod.ZodEnum<{
19282
- http: "http";
19283
19574
  codex: "codex";
19575
+ http: "http";
19284
19576
  antigravity: "antigravity";
19285
19577
  router: "router";
19286
19578
  }>;
@@ -19402,8 +19694,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19402
19694
  value: zod.ZodObject<{
19403
19695
  name: zod.ZodString;
19404
19696
  kind: zod.ZodEnum<{
19405
- http: "http";
19406
19697
  codex: "codex";
19698
+ http: "http";
19407
19699
  antigravity: "antigravity";
19408
19700
  router: "router";
19409
19701
  }>;
@@ -19558,8 +19850,55 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19558
19850
  key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
19559
19851
  }, zod_v4_core.$strip>], "kind">]>;
19560
19852
  }, zod_v4_core.$strict>]>>>;
19561
- extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
19853
+ models: zod.ZodOptional<zod.ZodObject<{
19854
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
19855
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
19856
+ mode: zod.ZodEnum<{
19857
+ ordered: "ordered";
19858
+ "most-allowance": "most-allowance";
19859
+ "soonest-reset": "soonest-reset";
19860
+ spread: "spread";
19861
+ adaptive: "adaptive";
19862
+ "lowest-latency": "lowest-latency";
19863
+ "highest-success": "highest-success";
19864
+ cheapest: "cheapest";
19865
+ }>;
19866
+ members: zod.ZodArray<zod.ZodString>;
19867
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
19868
+ tiers: zod.ZodOptional<zod.ZodObject<{
19869
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
19870
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
19871
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
19872
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
19873
+ }, zod_v4_core.$strict>>;
19874
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
19875
+ input: zod.ZodNumber;
19876
+ output: zod.ZodNumber;
19877
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
19878
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
19879
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
19880
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
19881
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
19882
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
19883
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
19884
+ mode: zod.ZodOptional<zod.ZodEnum<{
19885
+ ordered: "ordered";
19886
+ "most-allowance": "most-allowance";
19887
+ "soonest-reset": "soonest-reset";
19888
+ spread: "spread";
19889
+ adaptive: "adaptive";
19890
+ "lowest-latency": "lowest-latency";
19891
+ "highest-success": "highest-success";
19892
+ cheapest: "cheapest";
19893
+ }>>;
19894
+ context: zod.ZodOptional<zod.ZodNumber>;
19895
+ vision: zod.ZodOptional<zod.ZodBoolean>;
19896
+ tools: zod.ZodOptional<zod.ZodBoolean>;
19897
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
19898
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
19899
+ }, zod_v4_core.$strict>>;
19562
19900
  $schema: zod.ZodOptional<zod.ZodString>;
19901
+ extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
19563
19902
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
19564
19903
  all: zod.ZodOptional<zod.ZodBoolean>;
19565
19904
  runtime: zod.ZodOptional<zod.ZodBoolean>;
@@ -19602,30 +19941,30 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19602
19941
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
19603
19942
  identity: "identity";
19604
19943
  model: "model";
19944
+ route: "route";
19605
19945
  account: "account";
19606
19946
  provider: "provider";
19947
+ version: "version";
19607
19948
  headroom: "headroom";
19608
- route: "route";
19949
+ duration: "duration";
19609
19950
  project: "project";
19610
19951
  vcs: "vcs";
19611
19952
  effort: "effort";
19612
19953
  advisor: "advisor";
19613
- version: "version";
19614
19954
  outputStyle: "outputStyle";
19615
19955
  cost: "cost";
19616
19956
  dailyCost: "dailyCost";
19617
19957
  sessionName: "sessionName";
19618
- duration: "duration";
19619
19958
  speed: "speed";
19620
19959
  extra: "extra";
19621
19960
  }>>>;
19622
19961
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
19623
19962
  context: "context";
19624
19963
  quota: "quota";
19964
+ environment: "environment";
19625
19965
  addedDirs: "addedDirs";
19626
19966
  gitFiles: "gitFiles";
19627
19967
  memory: "memory";
19628
- environment: "environment";
19629
19968
  sessionTime: "sessionTime";
19630
19969
  promptCache: "promptCache";
19631
19970
  compactions: "compactions";
@@ -19648,10 +19987,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19648
19987
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
19649
19988
  context: "context";
19650
19989
  quota: "quota";
19990
+ environment: "environment";
19651
19991
  addedDirs: "addedDirs";
19652
19992
  gitFiles: "gitFiles";
19653
19993
  memory: "memory";
19654
- environment: "environment";
19655
19994
  sessionTime: "sessionTime";
19656
19995
  promptCache: "promptCache";
19657
19996
  compactions: "compactions";
@@ -19665,10 +20004,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19665
20004
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
19666
20005
  context: "context";
19667
20006
  quota: "quota";
20007
+ environment: "environment";
19668
20008
  addedDirs: "addedDirs";
19669
20009
  gitFiles: "gitFiles";
19670
20010
  memory: "memory";
19671
- environment: "environment";
19672
20011
  sessionTime: "sessionTime";
19673
20012
  promptCache: "promptCache";
19674
20013
  compactions: "compactions";
@@ -19727,10 +20066,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19727
20066
  hidden: "hidden";
19728
20067
  }>>;
19729
20068
  value: zod.ZodOptional<zod.ZodEnum<{
20069
+ remaining: "remaining";
19730
20070
  tokens: "tokens";
19731
20071
  both: "both";
19732
20072
  percent: "percent";
19733
- remaining: "remaining";
19734
20073
  }>>;
19735
20074
  estimate: zod.ZodOptional<zod.ZodEnum<{
19736
20075
  never: "never";
@@ -19772,8 +20111,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19772
20111
  }, zod_v4_core.$strict>>;
19773
20112
  usage: zod.ZodOptional<zod.ZodObject<{
19774
20113
  value: zod.ZodOptional<zod.ZodEnum<{
19775
- remaining: "remaining";
19776
20114
  used: "used";
20115
+ remaining: "remaining";
19777
20116
  }>>;
19778
20117
  bar: zod.ZodOptional<zod.ZodBoolean>;
19779
20118
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -20131,53 +20470,6 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20131
20470
  }, zod_v4_core.$strict>>;
20132
20471
  }, zod_v4_core.$strict>>;
20133
20472
  }, zod_v4_core.$strict>>;
20134
- models: zod.ZodOptional<zod.ZodObject<{
20135
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
20136
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20137
- mode: zod.ZodEnum<{
20138
- ordered: "ordered";
20139
- "most-allowance": "most-allowance";
20140
- "soonest-reset": "soonest-reset";
20141
- spread: "spread";
20142
- adaptive: "adaptive";
20143
- "lowest-latency": "lowest-latency";
20144
- "highest-success": "highest-success";
20145
- cheapest: "cheapest";
20146
- }>;
20147
- members: zod.ZodArray<zod.ZodString>;
20148
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20149
- tiers: zod.ZodOptional<zod.ZodObject<{
20150
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20151
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20152
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20153
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20154
- }, zod_v4_core.$strict>>;
20155
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20156
- input: zod.ZodNumber;
20157
- output: zod.ZodNumber;
20158
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20159
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20160
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20161
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
20162
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
20163
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20164
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20165
- mode: zod.ZodOptional<zod.ZodEnum<{
20166
- ordered: "ordered";
20167
- "most-allowance": "most-allowance";
20168
- "soonest-reset": "soonest-reset";
20169
- spread: "spread";
20170
- adaptive: "adaptive";
20171
- "lowest-latency": "lowest-latency";
20172
- "highest-success": "highest-success";
20173
- cheapest: "cheapest";
20174
- }>>;
20175
- context: zod.ZodOptional<zod.ZodNumber>;
20176
- vision: zod.ZodOptional<zod.ZodBoolean>;
20177
- tools: zod.ZodOptional<zod.ZodBoolean>;
20178
- thinking: zod.ZodOptional<zod.ZodBoolean>;
20179
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20180
- }, zod_v4_core.$strict>>;
20181
20473
  path: zod.ZodString;
20182
20474
  configProfile: zod.ZodOptional<zod.ZodString>;
20183
20475
  identity: zod.ZodOptional<zod.ZodString>;
@@ -20339,8 +20631,55 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20339
20631
  key: zod.ZodType<trilean.JsonValue, unknown, zod_v4_core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
20340
20632
  }, zod_v4_core.$strip>], "kind">]>;
20341
20633
  }, zod_v4_core.$strict>]>>>;
20342
- extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20634
+ models: zod.ZodOptional<zod.ZodObject<{
20635
+ pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
20636
+ virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20637
+ mode: zod.ZodEnum<{
20638
+ ordered: "ordered";
20639
+ "most-allowance": "most-allowance";
20640
+ "soonest-reset": "soonest-reset";
20641
+ spread: "spread";
20642
+ adaptive: "adaptive";
20643
+ "lowest-latency": "lowest-latency";
20644
+ "highest-success": "highest-success";
20645
+ cheapest: "cheapest";
20646
+ }>;
20647
+ members: zod.ZodArray<zod.ZodString>;
20648
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20649
+ tiers: zod.ZodOptional<zod.ZodObject<{
20650
+ fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20651
+ opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20652
+ sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20653
+ haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20654
+ }, zod_v4_core.$strict>>;
20655
+ prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20656
+ input: zod.ZodNumber;
20657
+ output: zod.ZodNumber;
20658
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20659
+ hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20660
+ show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20661
+ same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
20662
+ distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
20663
+ families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20664
+ names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20665
+ mode: zod.ZodOptional<zod.ZodEnum<{
20666
+ ordered: "ordered";
20667
+ "most-allowance": "most-allowance";
20668
+ "soonest-reset": "soonest-reset";
20669
+ spread: "spread";
20670
+ adaptive: "adaptive";
20671
+ "lowest-latency": "lowest-latency";
20672
+ "highest-success": "highest-success";
20673
+ cheapest: "cheapest";
20674
+ }>>;
20675
+ context: zod.ZodOptional<zod.ZodNumber>;
20676
+ vision: zod.ZodOptional<zod.ZodBoolean>;
20677
+ tools: zod.ZodOptional<zod.ZodBoolean>;
20678
+ thinking: zod.ZodOptional<zod.ZodBoolean>;
20679
+ }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20680
+ }, zod_v4_core.$strict>>;
20343
20681
  $schema: zod.ZodOptional<zod.ZodString>;
20682
+ extends: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20344
20683
  categories: zod.ZodOptional<zod.ZodPipe<zod.ZodObject<{
20345
20684
  all: zod.ZodOptional<zod.ZodBoolean>;
20346
20685
  runtime: zod.ZodOptional<zod.ZodBoolean>;
@@ -20383,30 +20722,30 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20383
20722
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
20384
20723
  identity: "identity";
20385
20724
  model: "model";
20725
+ route: "route";
20386
20726
  account: "account";
20387
20727
  provider: "provider";
20728
+ version: "version";
20388
20729
  headroom: "headroom";
20389
- route: "route";
20730
+ duration: "duration";
20390
20731
  project: "project";
20391
20732
  vcs: "vcs";
20392
20733
  effort: "effort";
20393
20734
  advisor: "advisor";
20394
- version: "version";
20395
20735
  outputStyle: "outputStyle";
20396
20736
  cost: "cost";
20397
20737
  dailyCost: "dailyCost";
20398
20738
  sessionName: "sessionName";
20399
- duration: "duration";
20400
20739
  speed: "speed";
20401
20740
  extra: "extra";
20402
20741
  }>>>;
20403
20742
  rows: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
20404
20743
  context: "context";
20405
20744
  quota: "quota";
20745
+ environment: "environment";
20406
20746
  addedDirs: "addedDirs";
20407
20747
  gitFiles: "gitFiles";
20408
20748
  memory: "memory";
20409
- environment: "environment";
20410
20749
  sessionTime: "sessionTime";
20411
20750
  promptCache: "promptCache";
20412
20751
  compactions: "compactions";
@@ -20429,10 +20768,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20429
20768
  merge: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodEnum<{
20430
20769
  context: "context";
20431
20770
  quota: "quota";
20771
+ environment: "environment";
20432
20772
  addedDirs: "addedDirs";
20433
20773
  gitFiles: "gitFiles";
20434
20774
  memory: "memory";
20435
- environment: "environment";
20436
20775
  sessionTime: "sessionTime";
20437
20776
  promptCache: "promptCache";
20438
20777
  compactions: "compactions";
@@ -20446,10 +20785,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20446
20785
  rightAlign: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
20447
20786
  context: "context";
20448
20787
  quota: "quota";
20788
+ environment: "environment";
20449
20789
  addedDirs: "addedDirs";
20450
20790
  gitFiles: "gitFiles";
20451
20791
  memory: "memory";
20452
- environment: "environment";
20453
20792
  sessionTime: "sessionTime";
20454
20793
  promptCache: "promptCache";
20455
20794
  compactions: "compactions";
@@ -20508,10 +20847,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20508
20847
  hidden: "hidden";
20509
20848
  }>>;
20510
20849
  value: zod.ZodOptional<zod.ZodEnum<{
20850
+ remaining: "remaining";
20511
20851
  tokens: "tokens";
20512
20852
  both: "both";
20513
20853
  percent: "percent";
20514
- remaining: "remaining";
20515
20854
  }>>;
20516
20855
  estimate: zod.ZodOptional<zod.ZodEnum<{
20517
20856
  never: "never";
@@ -20553,8 +20892,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20553
20892
  }, zod_v4_core.$strict>>;
20554
20893
  usage: zod.ZodOptional<zod.ZodObject<{
20555
20894
  value: zod.ZodOptional<zod.ZodEnum<{
20556
- remaining: "remaining";
20557
20895
  used: "used";
20896
+ remaining: "remaining";
20558
20897
  }>>;
20559
20898
  bar: zod.ZodOptional<zod.ZodBoolean>;
20560
20899
  compact: zod.ZodOptional<zod.ZodBoolean>;
@@ -20912,53 +21251,6 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20912
21251
  }, zod_v4_core.$strict>>;
20913
21252
  }, zod_v4_core.$strict>>;
20914
21253
  }, zod_v4_core.$strict>>;
20915
- models: zod.ZodOptional<zod.ZodObject<{
20916
- pickerLabelSpaces: zod.ZodOptional<zod.ZodBoolean>;
20917
- virtual: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20918
- mode: zod.ZodEnum<{
20919
- ordered: "ordered";
20920
- "most-allowance": "most-allowance";
20921
- "soonest-reset": "soonest-reset";
20922
- spread: "spread";
20923
- adaptive: "adaptive";
20924
- "lowest-latency": "lowest-latency";
20925
- "highest-success": "highest-success";
20926
- cheapest: "cheapest";
20927
- }>;
20928
- members: zod.ZodArray<zod.ZodString>;
20929
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20930
- tiers: zod.ZodOptional<zod.ZodObject<{
20931
- fable: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20932
- opus: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20933
- sonnet: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20934
- haiku: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodString, zod.ZodNull]>>;
20935
- }, zod_v4_core.$strict>>;
20936
- prices: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20937
- input: zod.ZodNumber;
20938
- output: zod.ZodNumber;
20939
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20940
- hide: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20941
- show: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20942
- same: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodString>>>;
20943
- distinct: zod.ZodOptional<zod.ZodArray<zod.ZodTuple<[zod.ZodString, zod.ZodString], null>>>;
20944
- families: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnion<readonly [zod.ZodObject<{
20945
- names: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
20946
- mode: zod.ZodOptional<zod.ZodEnum<{
20947
- ordered: "ordered";
20948
- "most-allowance": "most-allowance";
20949
- "soonest-reset": "soonest-reset";
20950
- spread: "spread";
20951
- adaptive: "adaptive";
20952
- "lowest-latency": "lowest-latency";
20953
- "highest-success": "highest-success";
20954
- cheapest: "cheapest";
20955
- }>>;
20956
- context: zod.ZodOptional<zod.ZodNumber>;
20957
- vision: zod.ZodOptional<zod.ZodBoolean>;
20958
- tools: zod.ZodOptional<zod.ZodBoolean>;
20959
- thinking: zod.ZodOptional<zod.ZodBoolean>;
20960
- }, zod_v4_core.$strict>, zod.ZodNull]>>>;
20961
- }, zod_v4_core.$strict>>;
20962
21254
  path: zod.ZodString;
20963
21255
  configProfile: zod.ZodOptional<zod.ZodString>;
20964
21256
  identity: zod.ZodOptional<zod.ZodString>;
@@ -21051,9 +21343,9 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21051
21343
  current: zod.ZodString;
21052
21344
  latest: zod.ZodString;
21053
21345
  action: zod.ZodEnum<{
21054
- updated: "updated";
21055
21346
  current: "current";
21056
21347
  available: "available";
21348
+ updated: "updated";
21057
21349
  }>;
21058
21350
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21059
21351
  };
@@ -21256,12 +21548,12 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21256
21548
  identity: zod.ZodObject<{
21257
21549
  name: zod.ZodNullable<zod.ZodString>;
21258
21550
  source: zod.ZodEnum<{
21259
- env: "env";
21260
- none: "none";
21261
21551
  "config-dir-escape-hatch": "config-dir-escape-hatch";
21262
21552
  argv: "argv";
21553
+ env: "env";
21263
21554
  "directory-pin": "directory-pin";
21264
21555
  "active-identity-file": "active-identity-file";
21556
+ none: "none";
21265
21557
  }>;
21266
21558
  }, zod_v4_core.$strict>;
21267
21559
  pool: zod.ZodOptional<zod.ZodObject<{
@@ -21339,11 +21631,11 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21339
21631
  "category-default": "category-default";
21340
21632
  }>;
21341
21633
  category: zod.ZodNullable<zod.ZodEnum<{
21634
+ secret: "secret";
21342
21635
  runtime: "runtime";
21343
21636
  history: "history";
21344
21637
  knowledge: "knowledge";
21345
21638
  settings: "settings";
21346
- secret: "secret";
21347
21639
  }>>;
21348
21640
  rule: zod.ZodOptional<zod.ZodObject<{
21349
21641
  key: zod.ZodString;
@@ -21543,8 +21835,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21543
21835
  pinned: zod.ZodOptional<zod.ZodObject<{
21544
21836
  version: zod.ZodString;
21545
21837
  source: zod.ZodEnum<{
21546
- environment: "environment";
21547
21838
  flag: "flag";
21839
+ environment: "environment";
21548
21840
  cascade: "cascade";
21549
21841
  }>;
21550
21842
  installed: zod.ZodBoolean;
@@ -21562,12 +21854,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21562
21854
  "global-config": "global-config";
21563
21855
  "config-profile": "config-profile";
21564
21856
  identity: "identity";
21565
- keychain: "keychain";
21566
21857
  provider: "provider";
21567
- headroom: "headroom";
21568
- models: "models";
21569
- pool: "pool";
21570
21858
  frontdoor: "frontdoor";
21859
+ pool: "pool";
21860
+ keychain: "keychain";
21571
21861
  "ambient-credential": "ambient-credential";
21572
21862
  "binary-discovery": "binary-discovery";
21573
21863
  "claude-shim": "claude-shim";
@@ -21577,6 +21867,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21577
21867
  "directory-rules": "directory-rules";
21578
21868
  "categories-local": "categories-local";
21579
21869
  "active-identity": "active-identity";
21870
+ headroom: "headroom";
21871
+ models: "models";
21580
21872
  }>;
21581
21873
  subject: zod.ZodOptional<zod.ZodString>;
21582
21874
  severity: zod.ZodEnum<{
@@ -21857,38 +22149,104 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21857
22149
  request: zod.ZodString;
21858
22150
  sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
21859
22151
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21860
- mcpReconnect: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22152
+ mcpReconnect: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22153
+ session: zod.ZodString;
22154
+ serverName: zod.ZodString;
22155
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22156
+ session: zod.ZodString;
22157
+ request: zod.ZodString;
22158
+ sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22159
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22160
+ mcpAuthenticate: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22161
+ session: zod.ZodString;
22162
+ serverName: zod.ZodString;
22163
+ redirectUri: zod.ZodString;
22164
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22165
+ session: zod.ZodString;
22166
+ request: zod.ZodString;
22167
+ sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22168
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22169
+ mcpOAuthCallbackUrl: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22170
+ session: zod.ZodString;
22171
+ serverName: zod.ZodString;
22172
+ callbackUrl: zod.ZodString;
22173
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22174
+ session: zod.ZodString;
22175
+ request: zod.ZodString;
22176
+ sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22177
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22178
+ teleport: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22179
+ session: zod.ZodString;
22180
+ marker: zod.ZodString;
22181
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22182
+ session: zod.ZodString;
22183
+ sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22184
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22185
+ goalGet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22186
+ session: zod.ZodString;
22187
+ waitMs: zod.ZodOptional<zod.ZodInt>;
22188
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22189
+ goal: zod.ZodNullable<zod.ZodObject<{
22190
+ condition: zod.ZodString;
22191
+ iterations: zod.ZodInt;
22192
+ lastCheck: zod.ZodOptional<zod.ZodString>;
22193
+ }, zod_v4_core.$strict>>;
22194
+ session: zod.ZodString;
22195
+ route: zod.ZodEnum<{
22196
+ supervised: "supervised";
22197
+ "self-hosted": "self-hosted";
22198
+ }>;
22199
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22200
+ goalSet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
21861
22201
  session: zod.ZodString;
21862
- serverName: zod.ZodString;
22202
+ condition: zod.ZodString;
22203
+ waitMs: zod.ZodOptional<zod.ZodInt>;
21863
22204
  }, zod_v4_core.$strict>, zod.ZodObject<{
22205
+ condition: zod.ZodString;
22206
+ superseded: zod.ZodNullable<zod.ZodString>;
21864
22207
  session: zod.ZodString;
21865
- request: zod.ZodString;
21866
- sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22208
+ route: zod.ZodEnum<{
22209
+ supervised: "supervised";
22210
+ "self-hosted": "self-hosted";
22211
+ }>;
21867
22212
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21868
- mcpAuthenticate: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22213
+ goalClear: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
21869
22214
  session: zod.ZodString;
21870
- serverName: zod.ZodString;
21871
- redirectUri: zod.ZodString;
22215
+ waitMs: zod.ZodOptional<zod.ZodInt>;
21872
22216
  }, zod_v4_core.$strict>, zod.ZodObject<{
22217
+ cleared: zod.ZodNullable<zod.ZodString>;
21873
22218
  session: zod.ZodString;
21874
- request: zod.ZodString;
21875
- sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22219
+ route: zod.ZodEnum<{
22220
+ supervised: "supervised";
22221
+ "self-hosted": "self-hosted";
22222
+ }>;
21876
22223
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21877
- mcpOAuthCallbackUrl: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22224
+ compact: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
21878
22225
  session: zod.ZodString;
21879
- serverName: zod.ZodString;
21880
- callbackUrl: zod.ZodString;
22226
+ waitMs: zod.ZodOptional<zod.ZodInt>;
21881
22227
  }, zod_v4_core.$strict>, zod.ZodObject<{
22228
+ trigger: zod.ZodString;
22229
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
22230
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
21882
22231
  session: zod.ZodString;
21883
- request: zod.ZodString;
21884
- sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22232
+ route: zod.ZodEnum<{
22233
+ supervised: "supervised";
22234
+ "self-hosted": "self-hosted";
22235
+ }>;
21885
22236
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21886
- teleport: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22237
+ compactWithInstructions: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
21887
22238
  session: zod.ZodString;
21888
- marker: zod.ZodString;
22239
+ instructions: zod.ZodString;
22240
+ waitMs: zod.ZodOptional<zod.ZodInt>;
21889
22241
  }, zod_v4_core.$strict>, zod.ZodObject<{
22242
+ trigger: zod.ZodString;
22243
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
22244
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
21890
22245
  session: zod.ZodString;
21891
- sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
22246
+ route: zod.ZodEnum<{
22247
+ supervised: "supervised";
22248
+ "self-hosted": "self-hosted";
22249
+ }>;
21892
22250
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21893
22251
  subscribe: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
21894
22252
  session: zod.ZodOptional<zod.ZodString>;
@@ -22245,6 +22603,53 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22245
22603
  }, z.core.$strip>], "kind">]>;
22246
22604
  }, z.core.$strict>]>>>;
22247
22605
  description: z.ZodOptional<z.ZodString>;
22606
+ models: z.ZodOptional<z.ZodObject<{
22607
+ pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
22608
+ virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
22609
+ mode: z.ZodEnum<{
22610
+ ordered: "ordered";
22611
+ "most-allowance": "most-allowance";
22612
+ "soonest-reset": "soonest-reset";
22613
+ spread: "spread";
22614
+ adaptive: "adaptive";
22615
+ "lowest-latency": "lowest-latency";
22616
+ "highest-success": "highest-success";
22617
+ cheapest: "cheapest";
22618
+ }>;
22619
+ members: z.ZodArray<z.ZodString>;
22620
+ }, z.core.$strict>, z.ZodNull]>>>;
22621
+ tiers: z.ZodOptional<z.ZodObject<{
22622
+ fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22623
+ opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22624
+ sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22625
+ haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22626
+ }, z.core.$strict>>;
22627
+ prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
22628
+ input: z.ZodNumber;
22629
+ output: z.ZodNumber;
22630
+ }, z.core.$strict>, z.ZodNull]>>>;
22631
+ hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
22632
+ show: z.ZodOptional<z.ZodArray<z.ZodString>>;
22633
+ same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
22634
+ distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
22635
+ families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
22636
+ names: z.ZodOptional<z.ZodArray<z.ZodString>>;
22637
+ mode: z.ZodOptional<z.ZodEnum<{
22638
+ ordered: "ordered";
22639
+ "most-allowance": "most-allowance";
22640
+ "soonest-reset": "soonest-reset";
22641
+ spread: "spread";
22642
+ adaptive: "adaptive";
22643
+ "lowest-latency": "lowest-latency";
22644
+ "highest-success": "highest-success";
22645
+ cheapest: "cheapest";
22646
+ }>>;
22647
+ context: z.ZodOptional<z.ZodNumber>;
22648
+ vision: z.ZodOptional<z.ZodBoolean>;
22649
+ tools: z.ZodOptional<z.ZodBoolean>;
22650
+ thinking: z.ZodOptional<z.ZodBoolean>;
22651
+ }, z.core.$strict>, z.ZodNull]>>>;
22652
+ }, z.core.$strict>>;
22248
22653
  extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
22249
22654
  categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
22250
22655
  all: z.ZodOptional<z.ZodBoolean>;
@@ -22288,30 +22693,30 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22288
22693
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
22289
22694
  identity: "identity";
22290
22695
  model: "model";
22696
+ route: "route";
22291
22697
  account: "account";
22292
22698
  provider: "provider";
22699
+ version: "version";
22293
22700
  headroom: "headroom";
22294
- route: "route";
22701
+ duration: "duration";
22295
22702
  project: "project";
22296
22703
  vcs: "vcs";
22297
22704
  effort: "effort";
22298
22705
  advisor: "advisor";
22299
- version: "version";
22300
22706
  outputStyle: "outputStyle";
22301
22707
  cost: "cost";
22302
22708
  dailyCost: "dailyCost";
22303
22709
  sessionName: "sessionName";
22304
- duration: "duration";
22305
22710
  speed: "speed";
22306
22711
  extra: "extra";
22307
22712
  }>>>;
22308
22713
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
22309
22714
  context: "context";
22310
22715
  quota: "quota";
22716
+ environment: "environment";
22311
22717
  addedDirs: "addedDirs";
22312
22718
  gitFiles: "gitFiles";
22313
22719
  memory: "memory";
22314
- environment: "environment";
22315
22720
  sessionTime: "sessionTime";
22316
22721
  promptCache: "promptCache";
22317
22722
  compactions: "compactions";
@@ -22334,10 +22739,10 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22334
22739
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
22335
22740
  context: "context";
22336
22741
  quota: "quota";
22742
+ environment: "environment";
22337
22743
  addedDirs: "addedDirs";
22338
22744
  gitFiles: "gitFiles";
22339
22745
  memory: "memory";
22340
- environment: "environment";
22341
22746
  sessionTime: "sessionTime";
22342
22747
  promptCache: "promptCache";
22343
22748
  compactions: "compactions";
@@ -22351,10 +22756,10 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22351
22756
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
22352
22757
  context: "context";
22353
22758
  quota: "quota";
22759
+ environment: "environment";
22354
22760
  addedDirs: "addedDirs";
22355
22761
  gitFiles: "gitFiles";
22356
22762
  memory: "memory";
22357
- environment: "environment";
22358
22763
  sessionTime: "sessionTime";
22359
22764
  promptCache: "promptCache";
22360
22765
  compactions: "compactions";
@@ -22413,10 +22818,10 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22413
22818
  hidden: "hidden";
22414
22819
  }>>;
22415
22820
  value: z.ZodOptional<z.ZodEnum<{
22821
+ remaining: "remaining";
22416
22822
  tokens: "tokens";
22417
22823
  both: "both";
22418
22824
  percent: "percent";
22419
- remaining: "remaining";
22420
22825
  }>>;
22421
22826
  estimate: z.ZodOptional<z.ZodEnum<{
22422
22827
  never: "never";
@@ -22458,8 +22863,8 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22458
22863
  }, z.core.$strict>>;
22459
22864
  usage: z.ZodOptional<z.ZodObject<{
22460
22865
  value: z.ZodOptional<z.ZodEnum<{
22461
- remaining: "remaining";
22462
22866
  used: "used";
22867
+ remaining: "remaining";
22463
22868
  }>>;
22464
22869
  bar: z.ZodOptional<z.ZodBoolean>;
22465
22870
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -22817,53 +23222,6 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22817
23222
  }, z.core.$strict>>;
22818
23223
  }, z.core.$strict>>;
22819
23224
  }, z.core.$strict>>;
22820
- models: z.ZodOptional<z.ZodObject<{
22821
- pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
22822
- virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
22823
- mode: z.ZodEnum<{
22824
- ordered: "ordered";
22825
- "most-allowance": "most-allowance";
22826
- "soonest-reset": "soonest-reset";
22827
- spread: "spread";
22828
- adaptive: "adaptive";
22829
- "lowest-latency": "lowest-latency";
22830
- "highest-success": "highest-success";
22831
- cheapest: "cheapest";
22832
- }>;
22833
- members: z.ZodArray<z.ZodString>;
22834
- }, z.core.$strict>, z.ZodNull]>>>;
22835
- tiers: z.ZodOptional<z.ZodObject<{
22836
- fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22837
- opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22838
- sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22839
- haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
22840
- }, z.core.$strict>>;
22841
- prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
22842
- input: z.ZodNumber;
22843
- output: z.ZodNumber;
22844
- }, z.core.$strict>, z.ZodNull]>>>;
22845
- hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
22846
- show: z.ZodOptional<z.ZodArray<z.ZodString>>;
22847
- same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
22848
- distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
22849
- families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
22850
- names: z.ZodOptional<z.ZodArray<z.ZodString>>;
22851
- mode: z.ZodOptional<z.ZodEnum<{
22852
- ordered: "ordered";
22853
- "most-allowance": "most-allowance";
22854
- "soonest-reset": "soonest-reset";
22855
- spread: "spread";
22856
- adaptive: "adaptive";
22857
- "lowest-latency": "lowest-latency";
22858
- "highest-success": "highest-success";
22859
- cheapest: "cheapest";
22860
- }>>;
22861
- context: z.ZodOptional<z.ZodNumber>;
22862
- vision: z.ZodOptional<z.ZodBoolean>;
22863
- tools: z.ZodOptional<z.ZodBoolean>;
22864
- thinking: z.ZodOptional<z.ZodBoolean>;
22865
- }, z.core.$strict>, z.ZodNull]>>>;
22866
- }, z.core.$strict>>;
22867
23225
  }, z.core.$strict>;
22868
23226
  }, z.core.$strict>;
22869
23227
  /** `category` and `entry` merge toggles into the profile's own maps; `extends` replaces the list (`false` clears it); `description` replaces the text (`false` clears it); `launch` merges the launch settings, each `provider` and `claudeVersion` clearable with `false`. At least one field must be present. */
@@ -22971,6 +23329,53 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
22971
23329
  }, z.core.$strip>], "kind">]>;
22972
23330
  }, z.core.$strict>]>>>;
22973
23331
  description: z.ZodOptional<z.ZodString>;
23332
+ models: z.ZodOptional<z.ZodObject<{
23333
+ pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
23334
+ virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
23335
+ mode: z.ZodEnum<{
23336
+ ordered: "ordered";
23337
+ "most-allowance": "most-allowance";
23338
+ "soonest-reset": "soonest-reset";
23339
+ spread: "spread";
23340
+ adaptive: "adaptive";
23341
+ "lowest-latency": "lowest-latency";
23342
+ "highest-success": "highest-success";
23343
+ cheapest: "cheapest";
23344
+ }>;
23345
+ members: z.ZodArray<z.ZodString>;
23346
+ }, z.core.$strict>, z.ZodNull]>>>;
23347
+ tiers: z.ZodOptional<z.ZodObject<{
23348
+ fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23349
+ opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23350
+ sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23351
+ haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23352
+ }, z.core.$strict>>;
23353
+ prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
23354
+ input: z.ZodNumber;
23355
+ output: z.ZodNumber;
23356
+ }, z.core.$strict>, z.ZodNull]>>>;
23357
+ hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
23358
+ show: z.ZodOptional<z.ZodArray<z.ZodString>>;
23359
+ same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
23360
+ distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
23361
+ families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
23362
+ names: z.ZodOptional<z.ZodArray<z.ZodString>>;
23363
+ mode: z.ZodOptional<z.ZodEnum<{
23364
+ ordered: "ordered";
23365
+ "most-allowance": "most-allowance";
23366
+ "soonest-reset": "soonest-reset";
23367
+ spread: "spread";
23368
+ adaptive: "adaptive";
23369
+ "lowest-latency": "lowest-latency";
23370
+ "highest-success": "highest-success";
23371
+ cheapest: "cheapest";
23372
+ }>>;
23373
+ context: z.ZodOptional<z.ZodNumber>;
23374
+ vision: z.ZodOptional<z.ZodBoolean>;
23375
+ tools: z.ZodOptional<z.ZodBoolean>;
23376
+ thinking: z.ZodOptional<z.ZodBoolean>;
23377
+ }, z.core.$strict>, z.ZodNull]>>>;
23378
+ }, z.core.$strict>>;
22974
23379
  extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
22975
23380
  categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
22976
23381
  all: z.ZodOptional<z.ZodBoolean>;
@@ -23014,30 +23419,30 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23014
23419
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
23015
23420
  identity: "identity";
23016
23421
  model: "model";
23422
+ route: "route";
23017
23423
  account: "account";
23018
23424
  provider: "provider";
23425
+ version: "version";
23019
23426
  headroom: "headroom";
23020
- route: "route";
23427
+ duration: "duration";
23021
23428
  project: "project";
23022
23429
  vcs: "vcs";
23023
23430
  effort: "effort";
23024
23431
  advisor: "advisor";
23025
- version: "version";
23026
23432
  outputStyle: "outputStyle";
23027
23433
  cost: "cost";
23028
23434
  dailyCost: "dailyCost";
23029
23435
  sessionName: "sessionName";
23030
- duration: "duration";
23031
23436
  speed: "speed";
23032
23437
  extra: "extra";
23033
23438
  }>>>;
23034
23439
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
23035
23440
  context: "context";
23036
23441
  quota: "quota";
23442
+ environment: "environment";
23037
23443
  addedDirs: "addedDirs";
23038
23444
  gitFiles: "gitFiles";
23039
23445
  memory: "memory";
23040
- environment: "environment";
23041
23446
  sessionTime: "sessionTime";
23042
23447
  promptCache: "promptCache";
23043
23448
  compactions: "compactions";
@@ -23060,10 +23465,10 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23060
23465
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
23061
23466
  context: "context";
23062
23467
  quota: "quota";
23468
+ environment: "environment";
23063
23469
  addedDirs: "addedDirs";
23064
23470
  gitFiles: "gitFiles";
23065
23471
  memory: "memory";
23066
- environment: "environment";
23067
23472
  sessionTime: "sessionTime";
23068
23473
  promptCache: "promptCache";
23069
23474
  compactions: "compactions";
@@ -23077,10 +23482,10 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23077
23482
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
23078
23483
  context: "context";
23079
23484
  quota: "quota";
23485
+ environment: "environment";
23080
23486
  addedDirs: "addedDirs";
23081
23487
  gitFiles: "gitFiles";
23082
23488
  memory: "memory";
23083
- environment: "environment";
23084
23489
  sessionTime: "sessionTime";
23085
23490
  promptCache: "promptCache";
23086
23491
  compactions: "compactions";
@@ -23139,10 +23544,10 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23139
23544
  hidden: "hidden";
23140
23545
  }>>;
23141
23546
  value: z.ZodOptional<z.ZodEnum<{
23547
+ remaining: "remaining";
23142
23548
  tokens: "tokens";
23143
23549
  both: "both";
23144
23550
  percent: "percent";
23145
- remaining: "remaining";
23146
23551
  }>>;
23147
23552
  estimate: z.ZodOptional<z.ZodEnum<{
23148
23553
  never: "never";
@@ -23184,8 +23589,8 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23184
23589
  }, z.core.$strict>>;
23185
23590
  usage: z.ZodOptional<z.ZodObject<{
23186
23591
  value: z.ZodOptional<z.ZodEnum<{
23187
- remaining: "remaining";
23188
23592
  used: "used";
23593
+ remaining: "remaining";
23189
23594
  }>>;
23190
23595
  bar: z.ZodOptional<z.ZodBoolean>;
23191
23596
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -23543,53 +23948,6 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23543
23948
  }, z.core.$strict>>;
23544
23949
  }, z.core.$strict>>;
23545
23950
  }, z.core.$strict>>;
23546
- models: z.ZodOptional<z.ZodObject<{
23547
- pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
23548
- virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
23549
- mode: z.ZodEnum<{
23550
- ordered: "ordered";
23551
- "most-allowance": "most-allowance";
23552
- "soonest-reset": "soonest-reset";
23553
- spread: "spread";
23554
- adaptive: "adaptive";
23555
- "lowest-latency": "lowest-latency";
23556
- "highest-success": "highest-success";
23557
- cheapest: "cheapest";
23558
- }>;
23559
- members: z.ZodArray<z.ZodString>;
23560
- }, z.core.$strict>, z.ZodNull]>>>;
23561
- tiers: z.ZodOptional<z.ZodObject<{
23562
- fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23563
- opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23564
- sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23565
- haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
23566
- }, z.core.$strict>>;
23567
- prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
23568
- input: z.ZodNumber;
23569
- output: z.ZodNumber;
23570
- }, z.core.$strict>, z.ZodNull]>>>;
23571
- hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
23572
- show: z.ZodOptional<z.ZodArray<z.ZodString>>;
23573
- same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
23574
- distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
23575
- families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
23576
- names: z.ZodOptional<z.ZodArray<z.ZodString>>;
23577
- mode: z.ZodOptional<z.ZodEnum<{
23578
- ordered: "ordered";
23579
- "most-allowance": "most-allowance";
23580
- "soonest-reset": "soonest-reset";
23581
- spread: "spread";
23582
- adaptive: "adaptive";
23583
- "lowest-latency": "lowest-latency";
23584
- "highest-success": "highest-success";
23585
- cheapest: "cheapest";
23586
- }>>;
23587
- context: z.ZodOptional<z.ZodNumber>;
23588
- vision: z.ZodOptional<z.ZodBoolean>;
23589
- tools: z.ZodOptional<z.ZodBoolean>;
23590
- thinking: z.ZodOptional<z.ZodBoolean>;
23591
- }, z.core.$strict>, z.ZodNull]>>>;
23592
- }, z.core.$strict>>;
23593
23951
  }, z.core.$strict>;
23594
23952
  }, z.core.$strict>;
23595
23953
  declare const ConfigProfileRemoveInputSchema: z.ZodObject<{
@@ -23825,8 +24183,8 @@ declare const ConfigPoolUseOutputSchema: z.ZodObject<{
23825
24183
  declare const ConfigProviderAddInputSchema: z.ZodObject<{
23826
24184
  name: z.ZodString;
23827
24185
  kind: z.ZodOptional<z.ZodEnum<{
23828
- http: "http";
23829
24186
  codex: "codex";
24187
+ http: "http";
23830
24188
  antigravity: "antigravity";
23831
24189
  router: "router";
23832
24190
  }>>;
@@ -23890,8 +24248,8 @@ declare const ConfigProviderAddOutputSchema: z.ZodObject<{
23890
24248
  value: z.ZodObject<{
23891
24249
  name: z.ZodString;
23892
24250
  kind: z.ZodEnum<{
23893
- http: "http";
23894
24251
  codex: "codex";
24252
+ http: "http";
23895
24253
  antigravity: "antigravity";
23896
24254
  router: "router";
23897
24255
  }>;
@@ -24015,8 +24373,8 @@ declare const ConfigProviderSetOutputSchema: z.ZodObject<{
24015
24373
  value: z.ZodObject<{
24016
24374
  name: z.ZodString;
24017
24375
  kind: z.ZodEnum<{
24018
- http: "http";
24019
24376
  codex: "codex";
24377
+ http: "http";
24020
24378
  antigravity: "antigravity";
24021
24379
  router: "router";
24022
24380
  }>;
@@ -24172,8 +24530,55 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24172
24530
  key: z.ZodType<trilean.JsonValue, unknown, z.core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
24173
24531
  }, z.core.$strip>], "kind">]>;
24174
24532
  }, z.core.$strict>]>>>;
24175
- extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
24533
+ models: z.ZodOptional<z.ZodObject<{
24534
+ pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
24535
+ virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
24536
+ mode: z.ZodEnum<{
24537
+ ordered: "ordered";
24538
+ "most-allowance": "most-allowance";
24539
+ "soonest-reset": "soonest-reset";
24540
+ spread: "spread";
24541
+ adaptive: "adaptive";
24542
+ "lowest-latency": "lowest-latency";
24543
+ "highest-success": "highest-success";
24544
+ cheapest: "cheapest";
24545
+ }>;
24546
+ members: z.ZodArray<z.ZodString>;
24547
+ }, z.core.$strict>, z.ZodNull]>>>;
24548
+ tiers: z.ZodOptional<z.ZodObject<{
24549
+ fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24550
+ opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24551
+ sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24552
+ haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24553
+ }, z.core.$strict>>;
24554
+ prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
24555
+ input: z.ZodNumber;
24556
+ output: z.ZodNumber;
24557
+ }, z.core.$strict>, z.ZodNull]>>>;
24558
+ hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
24559
+ show: z.ZodOptional<z.ZodArray<z.ZodString>>;
24560
+ same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
24561
+ distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
24562
+ families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
24563
+ names: z.ZodOptional<z.ZodArray<z.ZodString>>;
24564
+ mode: z.ZodOptional<z.ZodEnum<{
24565
+ ordered: "ordered";
24566
+ "most-allowance": "most-allowance";
24567
+ "soonest-reset": "soonest-reset";
24568
+ spread: "spread";
24569
+ adaptive: "adaptive";
24570
+ "lowest-latency": "lowest-latency";
24571
+ "highest-success": "highest-success";
24572
+ cheapest: "cheapest";
24573
+ }>>;
24574
+ context: z.ZodOptional<z.ZodNumber>;
24575
+ vision: z.ZodOptional<z.ZodBoolean>;
24576
+ tools: z.ZodOptional<z.ZodBoolean>;
24577
+ thinking: z.ZodOptional<z.ZodBoolean>;
24578
+ }, z.core.$strict>, z.ZodNull]>>>;
24579
+ }, z.core.$strict>>;
24176
24580
  $schema: z.ZodOptional<z.ZodString>;
24581
+ extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
24177
24582
  categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
24178
24583
  all: z.ZodOptional<z.ZodBoolean>;
24179
24584
  runtime: z.ZodOptional<z.ZodBoolean>;
@@ -24216,30 +24621,30 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24216
24621
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
24217
24622
  identity: "identity";
24218
24623
  model: "model";
24624
+ route: "route";
24219
24625
  account: "account";
24220
24626
  provider: "provider";
24627
+ version: "version";
24221
24628
  headroom: "headroom";
24222
- route: "route";
24629
+ duration: "duration";
24223
24630
  project: "project";
24224
24631
  vcs: "vcs";
24225
24632
  effort: "effort";
24226
24633
  advisor: "advisor";
24227
- version: "version";
24228
24634
  outputStyle: "outputStyle";
24229
24635
  cost: "cost";
24230
24636
  dailyCost: "dailyCost";
24231
24637
  sessionName: "sessionName";
24232
- duration: "duration";
24233
24638
  speed: "speed";
24234
24639
  extra: "extra";
24235
24640
  }>>>;
24236
24641
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
24237
24642
  context: "context";
24238
24643
  quota: "quota";
24644
+ environment: "environment";
24239
24645
  addedDirs: "addedDirs";
24240
24646
  gitFiles: "gitFiles";
24241
24647
  memory: "memory";
24242
- environment: "environment";
24243
24648
  sessionTime: "sessionTime";
24244
24649
  promptCache: "promptCache";
24245
24650
  compactions: "compactions";
@@ -24262,10 +24667,10 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24262
24667
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
24263
24668
  context: "context";
24264
24669
  quota: "quota";
24670
+ environment: "environment";
24265
24671
  addedDirs: "addedDirs";
24266
24672
  gitFiles: "gitFiles";
24267
24673
  memory: "memory";
24268
- environment: "environment";
24269
24674
  sessionTime: "sessionTime";
24270
24675
  promptCache: "promptCache";
24271
24676
  compactions: "compactions";
@@ -24279,10 +24684,10 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24279
24684
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
24280
24685
  context: "context";
24281
24686
  quota: "quota";
24687
+ environment: "environment";
24282
24688
  addedDirs: "addedDirs";
24283
24689
  gitFiles: "gitFiles";
24284
24690
  memory: "memory";
24285
- environment: "environment";
24286
24691
  sessionTime: "sessionTime";
24287
24692
  promptCache: "promptCache";
24288
24693
  compactions: "compactions";
@@ -24341,10 +24746,10 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24341
24746
  hidden: "hidden";
24342
24747
  }>>;
24343
24748
  value: z.ZodOptional<z.ZodEnum<{
24749
+ remaining: "remaining";
24344
24750
  tokens: "tokens";
24345
24751
  both: "both";
24346
24752
  percent: "percent";
24347
- remaining: "remaining";
24348
24753
  }>>;
24349
24754
  estimate: z.ZodOptional<z.ZodEnum<{
24350
24755
  never: "never";
@@ -24386,8 +24791,8 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24386
24791
  }, z.core.$strict>>;
24387
24792
  usage: z.ZodOptional<z.ZodObject<{
24388
24793
  value: z.ZodOptional<z.ZodEnum<{
24389
- remaining: "remaining";
24390
24794
  used: "used";
24795
+ remaining: "remaining";
24391
24796
  }>>;
24392
24797
  bar: z.ZodOptional<z.ZodBoolean>;
24393
24798
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -24745,53 +25150,6 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24745
25150
  }, z.core.$strict>>;
24746
25151
  }, z.core.$strict>>;
24747
25152
  }, z.core.$strict>>;
24748
- models: z.ZodOptional<z.ZodObject<{
24749
- pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
24750
- virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
24751
- mode: z.ZodEnum<{
24752
- ordered: "ordered";
24753
- "most-allowance": "most-allowance";
24754
- "soonest-reset": "soonest-reset";
24755
- spread: "spread";
24756
- adaptive: "adaptive";
24757
- "lowest-latency": "lowest-latency";
24758
- "highest-success": "highest-success";
24759
- cheapest: "cheapest";
24760
- }>;
24761
- members: z.ZodArray<z.ZodString>;
24762
- }, z.core.$strict>, z.ZodNull]>>>;
24763
- tiers: z.ZodOptional<z.ZodObject<{
24764
- fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24765
- opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24766
- sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24767
- haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
24768
- }, z.core.$strict>>;
24769
- prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
24770
- input: z.ZodNumber;
24771
- output: z.ZodNumber;
24772
- }, z.core.$strict>, z.ZodNull]>>>;
24773
- hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
24774
- show: z.ZodOptional<z.ZodArray<z.ZodString>>;
24775
- same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
24776
- distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
24777
- families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
24778
- names: z.ZodOptional<z.ZodArray<z.ZodString>>;
24779
- mode: z.ZodOptional<z.ZodEnum<{
24780
- ordered: "ordered";
24781
- "most-allowance": "most-allowance";
24782
- "soonest-reset": "soonest-reset";
24783
- spread: "spread";
24784
- adaptive: "adaptive";
24785
- "lowest-latency": "lowest-latency";
24786
- "highest-success": "highest-success";
24787
- cheapest: "cheapest";
24788
- }>>;
24789
- context: z.ZodOptional<z.ZodNumber>;
24790
- vision: z.ZodOptional<z.ZodBoolean>;
24791
- tools: z.ZodOptional<z.ZodBoolean>;
24792
- thinking: z.ZodOptional<z.ZodBoolean>;
24793
- }, z.core.$strict>, z.ZodNull]>>>;
24794
- }, z.core.$strict>>;
24795
25153
  path: z.ZodString;
24796
25154
  configProfile: z.ZodOptional<z.ZodString>;
24797
25155
  identity: z.ZodOptional<z.ZodString>;
@@ -24955,8 +25313,55 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
24955
25313
  key: z.ZodType<trilean.JsonValue, unknown, z.core.$ZodTypeInternals<trilean.JsonValue, unknown>>;
24956
25314
  }, z.core.$strip>], "kind">]>;
24957
25315
  }, z.core.$strict>]>>>;
24958
- extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
25316
+ models: z.ZodOptional<z.ZodObject<{
25317
+ pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
25318
+ virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
25319
+ mode: z.ZodEnum<{
25320
+ ordered: "ordered";
25321
+ "most-allowance": "most-allowance";
25322
+ "soonest-reset": "soonest-reset";
25323
+ spread: "spread";
25324
+ adaptive: "adaptive";
25325
+ "lowest-latency": "lowest-latency";
25326
+ "highest-success": "highest-success";
25327
+ cheapest: "cheapest";
25328
+ }>;
25329
+ members: z.ZodArray<z.ZodString>;
25330
+ }, z.core.$strict>, z.ZodNull]>>>;
25331
+ tiers: z.ZodOptional<z.ZodObject<{
25332
+ fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25333
+ opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25334
+ sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25335
+ haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25336
+ }, z.core.$strict>>;
25337
+ prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
25338
+ input: z.ZodNumber;
25339
+ output: z.ZodNumber;
25340
+ }, z.core.$strict>, z.ZodNull]>>>;
25341
+ hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
25342
+ show: z.ZodOptional<z.ZodArray<z.ZodString>>;
25343
+ same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
25344
+ distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
25345
+ families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
25346
+ names: z.ZodOptional<z.ZodArray<z.ZodString>>;
25347
+ mode: z.ZodOptional<z.ZodEnum<{
25348
+ ordered: "ordered";
25349
+ "most-allowance": "most-allowance";
25350
+ "soonest-reset": "soonest-reset";
25351
+ spread: "spread";
25352
+ adaptive: "adaptive";
25353
+ "lowest-latency": "lowest-latency";
25354
+ "highest-success": "highest-success";
25355
+ cheapest: "cheapest";
25356
+ }>>;
25357
+ context: z.ZodOptional<z.ZodNumber>;
25358
+ vision: z.ZodOptional<z.ZodBoolean>;
25359
+ tools: z.ZodOptional<z.ZodBoolean>;
25360
+ thinking: z.ZodOptional<z.ZodBoolean>;
25361
+ }, z.core.$strict>, z.ZodNull]>>>;
25362
+ }, z.core.$strict>>;
24959
25363
  $schema: z.ZodOptional<z.ZodString>;
25364
+ extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
24960
25365
  categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
24961
25366
  all: z.ZodOptional<z.ZodBoolean>;
24962
25367
  runtime: z.ZodOptional<z.ZodBoolean>;
@@ -24999,30 +25404,30 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
24999
25404
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
25000
25405
  identity: "identity";
25001
25406
  model: "model";
25407
+ route: "route";
25002
25408
  account: "account";
25003
25409
  provider: "provider";
25410
+ version: "version";
25004
25411
  headroom: "headroom";
25005
- route: "route";
25412
+ duration: "duration";
25006
25413
  project: "project";
25007
25414
  vcs: "vcs";
25008
25415
  effort: "effort";
25009
25416
  advisor: "advisor";
25010
- version: "version";
25011
25417
  outputStyle: "outputStyle";
25012
25418
  cost: "cost";
25013
25419
  dailyCost: "dailyCost";
25014
25420
  sessionName: "sessionName";
25015
- duration: "duration";
25016
25421
  speed: "speed";
25017
25422
  extra: "extra";
25018
25423
  }>>>;
25019
25424
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
25020
25425
  context: "context";
25021
25426
  quota: "quota";
25427
+ environment: "environment";
25022
25428
  addedDirs: "addedDirs";
25023
25429
  gitFiles: "gitFiles";
25024
25430
  memory: "memory";
25025
- environment: "environment";
25026
25431
  sessionTime: "sessionTime";
25027
25432
  promptCache: "promptCache";
25028
25433
  compactions: "compactions";
@@ -25045,10 +25450,10 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
25045
25450
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
25046
25451
  context: "context";
25047
25452
  quota: "quota";
25453
+ environment: "environment";
25048
25454
  addedDirs: "addedDirs";
25049
25455
  gitFiles: "gitFiles";
25050
25456
  memory: "memory";
25051
- environment: "environment";
25052
25457
  sessionTime: "sessionTime";
25053
25458
  promptCache: "promptCache";
25054
25459
  compactions: "compactions";
@@ -25062,10 +25467,10 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
25062
25467
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
25063
25468
  context: "context";
25064
25469
  quota: "quota";
25470
+ environment: "environment";
25065
25471
  addedDirs: "addedDirs";
25066
25472
  gitFiles: "gitFiles";
25067
25473
  memory: "memory";
25068
- environment: "environment";
25069
25474
  sessionTime: "sessionTime";
25070
25475
  promptCache: "promptCache";
25071
25476
  compactions: "compactions";
@@ -25124,10 +25529,10 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
25124
25529
  hidden: "hidden";
25125
25530
  }>>;
25126
25531
  value: z.ZodOptional<z.ZodEnum<{
25532
+ remaining: "remaining";
25127
25533
  tokens: "tokens";
25128
25534
  both: "both";
25129
25535
  percent: "percent";
25130
- remaining: "remaining";
25131
25536
  }>>;
25132
25537
  estimate: z.ZodOptional<z.ZodEnum<{
25133
25538
  never: "never";
@@ -25169,8 +25574,8 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
25169
25574
  }, z.core.$strict>>;
25170
25575
  usage: z.ZodOptional<z.ZodObject<{
25171
25576
  value: z.ZodOptional<z.ZodEnum<{
25172
- remaining: "remaining";
25173
25577
  used: "used";
25578
+ remaining: "remaining";
25174
25579
  }>>;
25175
25580
  bar: z.ZodOptional<z.ZodBoolean>;
25176
25581
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -25528,53 +25933,6 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
25528
25933
  }, z.core.$strict>>;
25529
25934
  }, z.core.$strict>>;
25530
25935
  }, z.core.$strict>>;
25531
- models: z.ZodOptional<z.ZodObject<{
25532
- pickerLabelSpaces: z.ZodOptional<z.ZodBoolean>;
25533
- virtual: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
25534
- mode: z.ZodEnum<{
25535
- ordered: "ordered";
25536
- "most-allowance": "most-allowance";
25537
- "soonest-reset": "soonest-reset";
25538
- spread: "spread";
25539
- adaptive: "adaptive";
25540
- "lowest-latency": "lowest-latency";
25541
- "highest-success": "highest-success";
25542
- cheapest: "cheapest";
25543
- }>;
25544
- members: z.ZodArray<z.ZodString>;
25545
- }, z.core.$strict>, z.ZodNull]>>>;
25546
- tiers: z.ZodOptional<z.ZodObject<{
25547
- fable: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25548
- opus: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25549
- sonnet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25550
- haiku: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
25551
- }, z.core.$strict>>;
25552
- prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
25553
- input: z.ZodNumber;
25554
- output: z.ZodNumber;
25555
- }, z.core.$strict>, z.ZodNull]>>>;
25556
- hide: z.ZodOptional<z.ZodArray<z.ZodString>>;
25557
- show: z.ZodOptional<z.ZodArray<z.ZodString>>;
25558
- same: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
25559
- distinct: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
25560
- families: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
25561
- names: z.ZodOptional<z.ZodArray<z.ZodString>>;
25562
- mode: z.ZodOptional<z.ZodEnum<{
25563
- ordered: "ordered";
25564
- "most-allowance": "most-allowance";
25565
- "soonest-reset": "soonest-reset";
25566
- spread: "spread";
25567
- adaptive: "adaptive";
25568
- "lowest-latency": "lowest-latency";
25569
- "highest-success": "highest-success";
25570
- cheapest: "cheapest";
25571
- }>>;
25572
- context: z.ZodOptional<z.ZodNumber>;
25573
- vision: z.ZodOptional<z.ZodBoolean>;
25574
- tools: z.ZodOptional<z.ZodBoolean>;
25575
- thinking: z.ZodOptional<z.ZodBoolean>;
25576
- }, z.core.$strict>, z.ZodNull]>>>;
25577
- }, z.core.$strict>>;
25578
25936
  path: z.ZodString;
25579
25937
  configProfile: z.ZodOptional<z.ZodString>;
25580
25938
  identity: z.ZodOptional<z.ZodString>;
@@ -25911,12 +26269,10 @@ declare const DoctorFindingSchema: z.ZodObject<{
25911
26269
  "global-config": "global-config";
25912
26270
  "config-profile": "config-profile";
25913
26271
  identity: "identity";
25914
- keychain: "keychain";
25915
26272
  provider: "provider";
25916
- headroom: "headroom";
25917
- models: "models";
25918
- pool: "pool";
25919
26273
  frontdoor: "frontdoor";
26274
+ pool: "pool";
26275
+ keychain: "keychain";
25920
26276
  "ambient-credential": "ambient-credential";
25921
26277
  "binary-discovery": "binary-discovery";
25922
26278
  "claude-shim": "claude-shim";
@@ -25926,6 +26282,8 @@ declare const DoctorFindingSchema: z.ZodObject<{
25926
26282
  "directory-rules": "directory-rules";
25927
26283
  "categories-local": "categories-local";
25928
26284
  "active-identity": "active-identity";
26285
+ headroom: "headroom";
26286
+ models: "models";
25929
26287
  }>;
25930
26288
  subject: z.ZodOptional<z.ZodString>;
25931
26289
  severity: z.ZodEnum<{
@@ -25943,12 +26301,10 @@ declare const DoctorRunOutputSchema: z.ZodObject<{
25943
26301
  "global-config": "global-config";
25944
26302
  "config-profile": "config-profile";
25945
26303
  identity: "identity";
25946
- keychain: "keychain";
25947
26304
  provider: "provider";
25948
- headroom: "headroom";
25949
- models: "models";
25950
- pool: "pool";
25951
26305
  frontdoor: "frontdoor";
26306
+ pool: "pool";
26307
+ keychain: "keychain";
25952
26308
  "ambient-credential": "ambient-credential";
25953
26309
  "binary-discovery": "binary-discovery";
25954
26310
  "claude-shim": "claude-shim";
@@ -25958,6 +26314,8 @@ declare const DoctorRunOutputSchema: z.ZodObject<{
25958
26314
  "directory-rules": "directory-rules";
25959
26315
  "categories-local": "categories-local";
25960
26316
  "active-identity": "active-identity";
26317
+ headroom: "headroom";
26318
+ models: "models";
25961
26319
  }>;
25962
26320
  subject: z.ZodOptional<z.ZodString>;
25963
26321
  severity: z.ZodEnum<{
@@ -25978,9 +26336,9 @@ declare const UpdateCheckOutputSchema: z.ZodObject<{
25978
26336
  current: z.ZodString;
25979
26337
  latest: z.ZodString;
25980
26338
  action: z.ZodEnum<{
25981
- updated: "updated";
25982
26339
  current: "current";
25983
26340
  available: "available";
26341
+ updated: "updated";
25984
26342
  }>;
25985
26343
  }, z.core.$strict>;
25986
26344
  /** The Sign in with ChatGPT login's state as `codex status` reports it: no sign-in yet, signed in (with who, whether the plan scope was granted, and when the access token lapses), or a file that cannot be read. */
@@ -26031,12 +26389,12 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26031
26389
  identity: z.ZodOptional<z.ZodString>;
26032
26390
  identityId: z.ZodOptional<z.ZodString>;
26033
26391
  identitySource: z.ZodEnum<{
26034
- env: "env";
26035
- none: "none";
26036
26392
  "config-dir-escape-hatch": "config-dir-escape-hatch";
26037
26393
  argv: "argv";
26394
+ env: "env";
26038
26395
  "directory-pin": "directory-pin";
26039
26396
  "active-identity-file": "active-identity-file";
26397
+ none: "none";
26040
26398
  }>;
26041
26399
  pool: z.ZodOptional<z.ZodObject<{
26042
26400
  name: z.ZodString;
@@ -26086,30 +26444,30 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26086
26444
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
26087
26445
  identity: "identity";
26088
26446
  model: "model";
26447
+ route: "route";
26089
26448
  account: "account";
26090
26449
  provider: "provider";
26450
+ version: "version";
26091
26451
  headroom: "headroom";
26092
- route: "route";
26452
+ duration: "duration";
26093
26453
  project: "project";
26094
26454
  vcs: "vcs";
26095
26455
  effort: "effort";
26096
26456
  advisor: "advisor";
26097
- version: "version";
26098
26457
  outputStyle: "outputStyle";
26099
26458
  cost: "cost";
26100
26459
  dailyCost: "dailyCost";
26101
26460
  sessionName: "sessionName";
26102
- duration: "duration";
26103
26461
  speed: "speed";
26104
26462
  extra: "extra";
26105
26463
  }>>>;
26106
26464
  rows: z.ZodOptional<z.ZodArray<z.ZodEnum<{
26107
26465
  context: "context";
26108
26466
  quota: "quota";
26467
+ environment: "environment";
26109
26468
  addedDirs: "addedDirs";
26110
26469
  gitFiles: "gitFiles";
26111
26470
  memory: "memory";
26112
- environment: "environment";
26113
26471
  sessionTime: "sessionTime";
26114
26472
  promptCache: "promptCache";
26115
26473
  compactions: "compactions";
@@ -26132,10 +26490,10 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26132
26490
  merge: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodEnum<{
26133
26491
  context: "context";
26134
26492
  quota: "quota";
26493
+ environment: "environment";
26135
26494
  addedDirs: "addedDirs";
26136
26495
  gitFiles: "gitFiles";
26137
26496
  memory: "memory";
26138
- environment: "environment";
26139
26497
  sessionTime: "sessionTime";
26140
26498
  promptCache: "promptCache";
26141
26499
  compactions: "compactions";
@@ -26149,10 +26507,10 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26149
26507
  rightAlign: z.ZodOptional<z.ZodArray<z.ZodEnum<{
26150
26508
  context: "context";
26151
26509
  quota: "quota";
26510
+ environment: "environment";
26152
26511
  addedDirs: "addedDirs";
26153
26512
  gitFiles: "gitFiles";
26154
26513
  memory: "memory";
26155
- environment: "environment";
26156
26514
  sessionTime: "sessionTime";
26157
26515
  promptCache: "promptCache";
26158
26516
  compactions: "compactions";
@@ -26211,10 +26569,10 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26211
26569
  hidden: "hidden";
26212
26570
  }>>;
26213
26571
  value: z.ZodOptional<z.ZodEnum<{
26572
+ remaining: "remaining";
26214
26573
  tokens: "tokens";
26215
26574
  both: "both";
26216
26575
  percent: "percent";
26217
- remaining: "remaining";
26218
26576
  }>>;
26219
26577
  estimate: z.ZodOptional<z.ZodEnum<{
26220
26578
  never: "never";
@@ -26256,8 +26614,8 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26256
26614
  }, z.core.$strict>>;
26257
26615
  usage: z.ZodOptional<z.ZodObject<{
26258
26616
  value: z.ZodOptional<z.ZodEnum<{
26259
- remaining: "remaining";
26260
26617
  used: "used";
26618
+ remaining: "remaining";
26261
26619
  }>>;
26262
26620
  bar: z.ZodOptional<z.ZodBoolean>;
26263
26621
  compact: z.ZodOptional<z.ZodBoolean>;
@@ -26618,8 +26976,8 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26618
26976
  claudeVersion: z.ZodOptional<z.ZodObject<{
26619
26977
  version: z.ZodString;
26620
26978
  source: z.ZodEnum<{
26621
- environment: "environment";
26622
26979
  flag: "flag";
26980
+ environment: "environment";
26623
26981
  cascade: "cascade";
26624
26982
  }>;
26625
26983
  }, z.core.$strict>>;
@@ -27275,7 +27633,7 @@ interface RankPoolInput {
27275
27633
  /** How members are ordered: "score" (the default when absent) by the use-it-or-lose-it ranking, "listed" strictly in `members` order. */
27276
27634
  readonly preference?: "score" | "listed";
27277
27635
  }
27278
- /** In pick order. `scored` has usable quota data; `unknown` has none (never recorded, or unreadable); `pay-per-use` bills by use instead of drawing on a plan; `ineligible` is refused right now. */
27636
+ /** In pick order. `scored` has usable quota data; `unknown` has none and no plan known to bill by use (never recorded, or unreadable); `pay-per-use` bills by use instead of drawing on a plan, whether or not any usage is recorded; `ineligible` is refused right now. */
27279
27637
  type CandidateClass = "scored" | "unknown" | "pay-per-use" | "ineligible";
27280
27638
  interface Candidate {
27281
27639
  readonly identity: string;
@@ -27290,6 +27648,8 @@ interface Candidate {
27290
27648
  readonly runsDryAtMs?: number;
27291
27649
  /** The fraction of the extra-usage allowance still unspent, for a `pay-per-use` member whose only budget is that allowance (an Enterprise account). A member reporting none ranks as having all of it: no cap is known to bind. */
27292
27650
  readonly headroom?: number;
27651
+ /** True for a `pay-per-use` member with no usage recorded: its account metadata says it bills by use, but its extra-usage meter has never been read, so its spend is invisible to `agent-shim usage` and its headroom is unknown rather than full. It ranks behind every `pay-per-use` member whose allowance is on record. */
27652
+ readonly usageUnrecorded?: boolean;
27293
27653
  /** When an `ineligible` candidate can be used again. */
27294
27654
  readonly blockedUntilMs?: number;
27295
27655
  /** When the exhausted plan window of a `pay-per-use` candidate that is only on extra usage because its plan ran out resets, so a launch can hold for it rather than spend. Absent for a candidate that bills by use with no plan allowance. */
@@ -27329,9 +27689,9 @@ interface PoolRanking {
27329
27689
  /**
27330
27690
  * Ranks `members` for a launch.
27331
27691
  *
27332
- * A member is `ineligible` while a window of its plan, or a refusal it last hit, still binds; it is `unknown` without recorded quota, `pay-per-use` when its usage bills by use, and otherwise `scored`. Scored members order by how much plan-size-weighted quota would expire unused per hour of runway, with any whose five-hour window would run dry at the observed pace (their own, or the person's pace on another member rescaled by plan size) or whose seven-day window would run dry at its own observed pace placed behind those that would not. The member last picked for this directory then moves to the front if it still serves on plan quota and is not projected to run dry, and either the launch resumes a conversation or its prompt cache is still warm; a resumed conversation that cannot keep its member re-ranks and continues on the pick, with the move named in `movedOff`.
27692
+ * A member is `ineligible` while a window of its plan, or a refusal it last hit, still binds; it is `pay-per-use` when its usage bills by use (including an account whose metadata says so and that has no usage recorded yet), `unknown` without recorded quota and no such plan, and otherwise `scored`. Scored members order by how much plan-size-weighted quota would expire unused per hour of runway, with any whose five-hour window would run dry at the observed pace (their own, or the person's pace on another member rescaled by plan size) or whose seven-day window would run dry at its own observed pace placed behind those that would not. The member last picked for this directory then moves to the front if it still serves on plan quota and is not projected to run dry, and either the launch resumes a conversation or its prompt cache is still warm; a resumed conversation that cannot keep its member re-ranks and continues on the pick, with the move named in `movedOff`.
27333
27693
  *
27334
- * How members are ordered depends on `preference`. The default, "score", is the order above: class first, then feasibility, then score, with ties by name. "listed" keeps the order of `members`, which callers build in pool member order, so member order, not class, decides: an `unknown` (no usage recorded) or `pay-per-use` member can be picked before a later `scored` one, which is the list owner's stated preference, and a `scored` member that is not feasible keeps its place and its reason line rather than being demoted. In both modes the pick is the first non-`ineligible` candidate, `earliestReturn` still reports the soonest returning refused member, and the sticky-pick promotion applies unchanged.
27694
+ * How members are ordered depends on `preference`. The default, "score", is the order above: class first, then feasibility, then (among members that bill by use) those whose usage is recorded before those whose is not, then headroom, then score, with ties by name. "listed" keeps the order of `members`, which callers build in pool member order, so member order, not class, decides: an `unknown` (no usage recorded) or `pay-per-use` member can be picked before a later `scored` one, which is the list owner's stated preference, and a `scored` member that is not feasible keeps its place and its reason line rather than being demoted. In both modes the pick is the first non-`ineligible` candidate, `earliestReturn` still reports the soonest returning refused member, and the sticky-pick promotion applies unchanged.
27335
27695
  */
27336
27696
  declare function rankPool(input: RankPoolInput): PoolRanking;
27337
27697
 
@@ -27928,5 +28288,5 @@ declare const OWN_CLI_FILE_NAME = "cli.cjs";
27928
28288
  */
27929
28289
  declare function agentShimCliPath(distDir?: string | undefined): string;
27930
28290
 
27931
- export { AMBIENT_CREDENTIAL_VARS, AgentKindSchema, AgentMetaSchema, AgentNodeSchema, AgentTreesListInputSchema, AgentTreesListOutputSchema, AgentTreesShowInputSchema, AgentTreesShowOutputSchema, CHECK_CREDENTIAL_APPLIES, CODEX_APP_SERVER_GENERATED_AGAINST, CODEX_APP_SERVER_TIMEOUT_MS, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CheckReportJsonSchema, CheckRunInputSchema, CliError, CodexAccountReadSchema, CodexAppServerProtocolError, CodexAppServerRequestError, CodexAppServerUnavailableError, CodexLogoutOutputSchema, CodexRateLimitsReadSchema, CodexSignInSchema, CodexStatusOutputSchema, ConfigIdentityAddInputSchema, ConfigIdentityAddOutputSchema, ConfigIdentityRemoveInputSchema, ConfigIdentityRemoveOutputSchema, ConfigIdentitySetInputSchema, ConfigIdentitySetOutputSchema, ConfigIdentityUseOutputSchema, ConfigNameInputSchema, ConfigPoolAddInputSchema, ConfigPoolAddOutputSchema, ConfigPoolRemoveInputSchema, ConfigPoolRemoveOutputSchema, ConfigPoolSetInputSchema, ConfigPoolSetOutputSchema, ConfigPoolUseOutputSchema, ConfigProfileAddInputSchema, ConfigProfileAddOutputSchema, ConfigProfileRemoveInputSchema, ConfigProfileRemoveOutputSchema, ConfigProfileSchema, ConfigProfileSetInputSchema, ConfigProfileSetOutputSchema, ConfigProfileUseOutputSchema, ConfigProviderAddInputSchema, ConfigProviderAddOutputSchema, ConfigProviderRemoveInputSchema, ConfigProviderRemoveOutputSchema, ConfigProviderSetInputSchema, ConfigProviderSetOutputSchema, ConfigRuleAddInputSchema, ConfigRuleAddOutputSchema, ConfigRuleRemoveInputSchema, ConfigRuleRemoveOutputSchema, ConfigRuleSetInputSchema, ConfigRuleSetOutputSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, CredentialSummarySchema, DOOR_EVENT_BUFFER_EVENTS, DOOR_EVENT_SOURCE_RC, DOOR_HEALTH_EVENT_SOURCE, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, DoctorFindingSchema, DoctorRunOutputSchema, DoorEventSchema, DoorEventSourceQuerySchema, DoorHealthEventSchema, DuplicateIdentityNameError, EXIT_FAILURE, EXIT_USAGE, EffectiveWindowSchema, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorControlMaterialError, FrontDoorNotServingError, FrontDoorRestartOutputSchema, FrontDoorSessionStatusSchema, FrontDoorSessionsOutputSchema, FrontDoorStartError, FrontDoorStateSchema, FrontDoorStatusOutputSchema, GlobalConfigSchema, HeadroomSocketTargetSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LAUNCH_EVENT_SOURCE, LIVE_TASK_CAP, LaunchLifecycleEventSchema, LaunchRefusedError, LaunchResolveInputSchema, LaunchResolveOutputSchema, LegacyProviderFileError, LiveTaskSchema, MergedAgentNodeSchema, MergedAgentTreeSchema, OWN_CLI_FILE_NAME, PROMPT_CACHE_TTL_MS, PlanClassSchema, PoolGraphError, PoolNameSchema, PoolNotFoundError, PoolPickReportSchema, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, QUOTA_EXPIRING_EVENT_SOURCE, QuotaExpiringEventSchema, RC_CONTEXT_USAGE_DETAILS, RC_IDLE_EXPIRY_MS, RC_ORPC_PATH_PREFIX, RC_PENDING_DEADLINE_MS, RC_PENDING_RETIRE_REASONS, RC_PERMISSION_MODES, RC_READ_FILE_ENCODINGS, RC_REQUEST_PARSE_CAP_BYTES, RC_SELF_HOST_ENV, RC_SELF_HOST_KEEPALIVE_MS, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE, RC_SELF_HOST_RETENTION_MS, RC_SELF_HOST_SCOPE_LIST, RC_SELF_HOST_WORKER_JWT_TTL_SECONDS, RC_SESSIONS_PATH_PREFIX, RC_SESSION_END_REASONS, RC_SESSION_EVENT_LOG_CAPACITY, RC_STREAM_BACKOFF_MS, RC_WEB_FETCH_ALLOW_PRIVATE_ENV, RC_WEB_FETCH_DEADLINE_MS, RC_WEB_FETCH_MAX_BYTES, RC_WEB_FETCH_MAX_REDIRECTS, ROUTED_PATH_PREFIX, RcLiveRateLimitSchema, RcPermissionModeSchema, RcRateLimitInfoSchema, RcRateLimitWindowSchema, RcSessionEventCursorExpiredError, RcSessionEventSchema, RcSessionEventsPageInputSchema, RcSessionEventsReadInputSchema, RcSessionEventsReadOutputSchema, RcSessionEventsStreamInputSchema, RcSessionTransitionSchema, RcStreamEnvelopeSchema, RcStreamEventSchema, ResetRowSchema, ResetScheduleSchema, SessionAgentTreeSchema, SessionLookupError, SessionSummarySchema, TaskItemSchema, USAGE_EVENT_SOURCE, UpdateCheckOutputSchema, UsageChangeEventSchema, UsageError, UsageListOutputSchema, UsageLiveOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, WorkflowRunSchema, addDirectoryRule, addIdentity, addPool, addProvider, agentShimCliPath, answerRcControlRequest, applyAgentTaskEvent, authenticateRcSessionMcpServer, buildEntryFacts, buildLayoutPaths, buildRcControlRequestPayload, buildRcControlResponsePayload, buildRcEndSessionPayload, buildRcEventWriteBody, buildRcFileSuggestionsPayload, buildRcGetContextUsagePayload, buildRcGetUsagePayload, buildRcInterruptPayload, buildRcKeepAlivePayload, buildRcMarkReadBody, buildRcMcpAuthenticatePayload, buildRcMcpOAuthCallbackUrlPayload, buildRcMcpReconnectPayload, buildRcMcpStatusPayload, buildRcReadFilePayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, changePool, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, collectResets, collectSessionList, createAgentTreesApiRouter, createCodexApiRouter, createConfigApiRouter, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createDoorHealthPublisher, createEventsApiRouter, createLaunchApiRouter, createLaunchEventPublisher, createLeafCache, createLifecycleApiRouter, createLiveSessionRegistry, createProfile, createQuotaExpiringPublisher, createRcApiNodeHandler, createRcApiRouter, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcLiveUsage, createRcSelfHostSurface, createRcSessionEventLog, createRcSessionEventsApiRouter, createRcSessionRegistryReader, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, endRcSession, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, fetchThroughWebProxy, followRcSessionEvents, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, formatFrontDoorStatus, forwardableHeaders, frontDoorApiClient, frontDoorApiFromState, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, getRcSessionContextUsage, getRcSessionMcpStatus, getRcSessionUsage, headroomSocketTarget, identityExists, identityIdOf, identityNameOf, identityRecords, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isPrivateAddress, isRcContextUsageDetail, isRcPermissionMode, isRcReadFileEncoding, lateRcEventDial, lateRcStreamDial, launchRequiredUpstreams, listDirectoryRules, listIdentities, listProfiles, listProviders, listSessions, listUsageSnapshots, locateSession, matchBranch, mergeLiveTasks, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, poolIdentities, poolSelectedByLaunch, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcObserverAsPassthrough, rcRateLimitInfoOf, rcSelfHostFromEnv, rcStatusWithRegistry, rcWebFetchAllowsPrivateFromEnv, readActiveIdentity, readCodexAccount, readCodexRateLimits, readDirectoryRules, readFarmManifest, readFrontDoorControlMaterial, readGlobalConfig, readIdentity, readIdentityById, readIdentityRecords, readPools, readProfile, readProvider, readRcSelfHostRecord, readRcSessionFile, readSessionAgentTree, readUsageSnapshot, realCodexAppServerPort, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, realRcWebFetch, realSessionFs, reconnectRcSessionMcpServer, recoverFarm, recoveryDiagnostics, refreshLaunchPoolUsage, refreshPoolUsage, refreshStalePoolMembers, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveClaudeLaunch, resolveDecisions, resolveLaunch, resolveLaunchSelection, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runClaudeLaunch, runDoctor, runFrontDoorSupervisor, runLaunchPlan, runLauncher, runSupervisor, sendRcKeepAlive, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, showSession, snapshotPath, spawnClaude, startConnectServer, submitRcSessionMcpOAuthCallbackUrl, suggestRcSessionFiles, summariseSession, teleportRcSession, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, watchedInstallEntry, withRegisteredSessionFacts, writeDirectoryRules };
27932
- export type { AddDirectoryRuleOptions, AddProviderInput, AgentKind, AgentNode, AgentReadFs, AgentTreesApiDeps, AgentTreesApiRouter, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, AnthropicUsageRefresher, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, ClaudeLaunchResolution, CodexAccountRead, CodexApiClient, CodexApiDeps, CodexApiRouter, CodexAppServerConnection, CodexAppServerPort, CodexAppServerReadOptions, CodexRateLimitsRead, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigApiDeps, ConfigApiRouter, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectLocalSurface, ConnectServerConfig, ConnectServerHandle, ConnectTarget, ControlApiClient, ControlApiDeps, ControlApiRouter, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, DoorApiClient, DoorApiContext, DoorApiDeps, DoorApiRouter, DoorEvent, DoorEventHub, DoorEventPublisher, DoorEventStream, DoorEventsApiDeps, DoorHealthEvent, DoorHealthPublisher, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorControlMaterial, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, IdentityNameRead, IdentityRecord, IdentityRecordsPort, IdentitySession, InjectedCredential, LaunchApiDeps, LaunchApiRouter, LaunchDecision, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, LaunchPoolDecision, LaunchResolution, LaunchSelection, Layer, LayerId, LayoutPaths, LeafCert, LifecycleApiClient, LifecycleApiDeps, LifecycleApiRouter, LiveSessionRegistry, LiveSessionRegistryPorts, LiveTask, LiveTaskBook, LocatedSession, MergedAgentNode, MergedAgentTree, NestedContribution, OwnExecutableStat, PlanClass, Pool, PoolChange, PoolMember, PoolPickReport, PoolPolicy, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, QuotaExpiringEvent, QuotaExpiringPublisher, RankPoolInput, RcAnswerDecision, RcAnswerDeps, RcApiClient, RcApiDeps, RcApiRouter, RcContextUsageDetail, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcLiveRateLimit, RcLiveUsage, RcLiveUsageDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPendingRetireReason, RcPermissionMode, RcPresenceAnswer, RcRateLimitInfo, RcRateLimitWindow, RcReadFileEncoding, RcReadFileOptions, RcRegisteredSession, RcRegistryIdentity, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionEndReason, RcSessionEvent, RcSessionEventLog, RcSessionEventLogDeps, RcSessionEventsApiDeps, RcSessionEventsApiRouter, RcSessionEventsRead, RcSessionEventsReadInput, RcSessionRegistryDeps, RcSessionRegistryFs, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcSessionTransition, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, RcWebFetchDeps, RcWebFetchHop, RcWebFetchOutcome, RcWebFetcher, RcWorkerFact, RcWriteHeaders, ReadSessionOptions, RecoverFarmParams, RecoveryResult, RefreshLaunchPoolUsageOptions, RefreshPoolUsageParams, RefreshStalePoolMembersParams, ResetRow, ResetSchedule, ResolveClaudeLaunchOptions, ResolveDecisionsInput, ResolveLaunchSelectionParams, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunClaudeLaunchOptions, RunDoctorParams, RunFrontDoorSupervisorOptions, RunLauncherParams, RunSupervisorOptions, SessionAgentTree, SessionCommandFs, SessionListFilters, SessionRef, SessionSummary, SessionView, SpawnClaudeParams, SseParsedEvent, StickyPick, SupervisorPorts, TaskItem, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageChangeEvent, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation, WorkflowRun };
28291
+ export { AMBIENT_CREDENTIAL_VARS, AgentKindSchema, AgentMetaSchema, AgentNodeSchema, AgentTreesListInputSchema, AgentTreesListOutputSchema, AgentTreesShowInputSchema, AgentTreesShowOutputSchema, CHECK_CREDENTIAL_APPLIES, CODEX_APP_SERVER_GENERATED_AGAINST, CODEX_APP_SERVER_TIMEOUT_MS, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CheckReportJsonSchema, CheckRunInputSchema, CliError, CodexAccountReadSchema, CodexAppServerProtocolError, CodexAppServerRequestError, CodexAppServerUnavailableError, CodexLogoutOutputSchema, CodexRateLimitsReadSchema, CodexSignInSchema, CodexStatusOutputSchema, ConfigIdentityAddInputSchema, ConfigIdentityAddOutputSchema, ConfigIdentityRemoveInputSchema, ConfigIdentityRemoveOutputSchema, ConfigIdentitySetInputSchema, ConfigIdentitySetOutputSchema, ConfigIdentityUseOutputSchema, ConfigNameInputSchema, ConfigPoolAddInputSchema, ConfigPoolAddOutputSchema, ConfigPoolRemoveInputSchema, ConfigPoolRemoveOutputSchema, ConfigPoolSetInputSchema, ConfigPoolSetOutputSchema, ConfigPoolUseOutputSchema, ConfigProfileAddInputSchema, ConfigProfileAddOutputSchema, ConfigProfileRemoveInputSchema, ConfigProfileRemoveOutputSchema, ConfigProfileSchema, ConfigProfileSetInputSchema, ConfigProfileSetOutputSchema, ConfigProfileUseOutputSchema, ConfigProviderAddInputSchema, ConfigProviderAddOutputSchema, ConfigProviderRemoveInputSchema, ConfigProviderRemoveOutputSchema, ConfigProviderSetInputSchema, ConfigProviderSetOutputSchema, ConfigRuleAddInputSchema, ConfigRuleAddOutputSchema, ConfigRuleRemoveInputSchema, ConfigRuleRemoveOutputSchema, ConfigRuleSetInputSchema, ConfigRuleSetOutputSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, CredentialSummarySchema, DOOR_EVENT_BUFFER_EVENTS, DOOR_EVENT_SOURCE_RC, DOOR_HEALTH_EVENT_SOURCE, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, DoctorFindingSchema, DoctorRunOutputSchema, DoorEventSchema, DoorEventSourceQuerySchema, DoorHealthEventSchema, DuplicateIdentityNameError, EXIT_FAILURE, EXIT_USAGE, EffectiveWindowSchema, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorControlMaterialError, FrontDoorNotServingError, FrontDoorRestartOutputSchema, FrontDoorSessionStatusSchema, FrontDoorSessionsOutputSchema, FrontDoorStartError, FrontDoorStateSchema, FrontDoorStatusOutputSchema, GlobalConfigSchema, HeadroomSocketTargetSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LAUNCH_EVENT_SOURCE, LIVE_TASK_CAP, LaunchLifecycleEventSchema, LaunchRefusedError, LaunchResolveInputSchema, LaunchResolveOutputSchema, LegacyProviderFileError, LiveTaskSchema, MergedAgentNodeSchema, MergedAgentTreeSchema, OWN_CLI_FILE_NAME, PROMPT_CACHE_TTL_MS, PlanClassSchema, PoolGraphError, PoolNameSchema, PoolNotFoundError, PoolPickReportSchema, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, QUOTA_EXPIRING_EVENT_SOURCE, QuotaExpiringEventSchema, RC_CONTEXT_USAGE_DETAILS, RC_GOAL_CLEAR_WORDS, RC_GOAL_CONDITION_MAX_CHARS, RC_IDLE_EXPIRY_MS, RC_ORPC_PATH_PREFIX, RC_PENDING_DEADLINE_MS, RC_PENDING_RETIRE_REASONS, RC_PERMISSION_MODES, RC_READ_FILE_ENCODINGS, RC_REQUEST_PARSE_CAP_BYTES, RC_SELF_HOST_ENV, RC_SELF_HOST_KEEPALIVE_MS, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE, RC_SELF_HOST_RETENTION_MS, RC_SELF_HOST_SCOPE_LIST, RC_SELF_HOST_WORKER_JWT_TTL_SECONDS, RC_SESSIONS_PATH_PREFIX, RC_SESSION_COMMAND_MAX_WAIT_MS, RC_SESSION_COMMAND_VERIFIED_VERSIONS, RC_SESSION_END_REASONS, RC_SESSION_EVENT_LOG_CAPACITY, RC_STREAM_BACKOFF_MS, RC_WEB_FETCH_ALLOW_PRIVATE_ENV, RC_WEB_FETCH_DEADLINE_MS, RC_WEB_FETCH_MAX_BYTES, RC_WEB_FETCH_MAX_REDIRECTS, ROUTED_PATH_PREFIX, RcLiveRateLimitSchema, RcPermissionModeSchema, RcRateLimitInfoSchema, RcRateLimitWindowSchema, RcSessionEventCursorExpiredError, RcSessionEventSchema, RcSessionEventsPageInputSchema, RcSessionEventsReadInputSchema, RcSessionEventsReadOutputSchema, RcSessionEventsStreamInputSchema, RcSessionTransitionSchema, RcStreamEnvelopeSchema, RcStreamEventSchema, ResetRowSchema, ResetScheduleSchema, SessionAgentTreeSchema, SessionLookupError, SessionSummarySchema, TaskItemSchema, USAGE_EVENT_SOURCE, UpdateCheckOutputSchema, UsageChangeEventSchema, UsageError, UsageListOutputSchema, UsageLiveOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, WorkflowRunSchema, addDirectoryRule, addIdentity, addPool, addProvider, agentShimCliPath, answerRcControlRequest, applyAgentTaskEvent, authenticateRcSessionMcpServer, buildEntryFacts, buildLayoutPaths, buildRcControlRequestPayload, buildRcControlResponsePayload, buildRcEndSessionPayload, buildRcEventWriteBody, buildRcFileSuggestionsPayload, buildRcGetContextUsagePayload, buildRcGetUsagePayload, buildRcInterruptPayload, buildRcKeepAlivePayload, buildRcMarkReadBody, buildRcMcpAuthenticatePayload, buildRcMcpOAuthCallbackUrlPayload, buildRcMcpReconnectPayload, buildRcMcpStatusPayload, buildRcReadFilePayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, changePool, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, collectResets, collectSessionList, createAgentTreesApiRouter, createCodexApiRouter, createConfigApiRouter, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createDoorHealthPublisher, createEventsApiRouter, createLaunchApiRouter, createLaunchEventPublisher, createLeafCache, createLifecycleApiRouter, createLiveSessionRegistry, createProfile, createQuotaExpiringPublisher, createRcApiNodeHandler, createRcApiRouter, createRcClaudeCodeVersions, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcLiveUsage, createRcSelfHostSurface, createRcSessionCommands, createRcSessionEventLog, createRcSessionEventsApiRouter, createRcSessionRegistryReader, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, endRcSession, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, fetchThroughWebProxy, followRcSessionEvents, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, formatFrontDoorStatus, forwardableHeaders, frontDoorApiClient, frontDoorApiFromState, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, getRcSessionContextUsage, getRcSessionMcpStatus, getRcSessionUsage, headroomSocketTarget, identityExists, identityIdOf, identityNameOf, identityRecords, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isPrivateAddress, isRcContextUsageDetail, isRcPermissionMode, isRcReadFileEncoding, lateRcEventDial, lateRcStreamDial, launchRequiredUpstreams, listDirectoryRules, listIdentities, listProfiles, listProviders, listSessions, listUsageSnapshots, locateSession, matchBranch, mergeLiveTasks, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcGoalOutput, parseRcStreamEnvelope, planOf, poolIdentities, poolSelectedByLaunch, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcLocalCommandAnswerOf, rcManualCompactBoundaryOf, rcObserverAsPassthrough, rcRateLimitInfoOf, rcSelfHostFromEnv, rcStatusWithRegistry, rcWebFetchAllowsPrivateFromEnv, readActiveIdentity, readCodexAccount, readCodexRateLimits, readDirectoryRules, readFarmManifest, readFrontDoorControlMaterial, readGlobalConfig, readIdentity, readIdentityById, readIdentityRecords, readPools, readProfile, readProvider, readRcSelfHostRecord, readRcSessionFile, readSessionAgentTree, readUsageSnapshot, realCodexAppServerPort, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, realRcWebFetch, realSessionFs, reconnectRcSessionMcpServer, recoverFarm, recoveryDiagnostics, refreshLaunchPoolUsage, refreshPoolUsage, refreshStalePoolMembers, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveClaudeLaunch, resolveDecisions, resolveLaunch, resolveLaunchSelection, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runClaudeLaunch, runDoctor, runFrontDoorSupervisor, runLaunchPlan, runLauncher, runSupervisor, sendRcKeepAlive, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, showSession, snapshotPath, spawnClaude, startConnectServer, submitRcSessionMcpOAuthCallbackUrl, suggestRcSessionFiles, summariseSession, teleportRcSession, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, watchedInstallEntry, withRegisteredSessionFacts, writeDirectoryRules };
28292
+ export type { AddDirectoryRuleOptions, AddProviderInput, AgentKind, AgentNode, AgentReadFs, AgentTreesApiDeps, AgentTreesApiRouter, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, AnthropicUsageRefresher, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, ClaudeLaunchResolution, CodexAccountRead, CodexApiClient, CodexApiDeps, CodexApiRouter, CodexAppServerConnection, CodexAppServerPort, CodexAppServerReadOptions, CodexRateLimitsRead, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigApiDeps, ConfigApiRouter, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectLocalSurface, ConnectServerConfig, ConnectServerHandle, ConnectTarget, ControlApiClient, ControlApiDeps, ControlApiRouter, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, DoorApiClient, DoorApiContext, DoorApiDeps, DoorApiRouter, DoorEvent, DoorEventHub, DoorEventPublisher, DoorEventStream, DoorEventsApiDeps, DoorHealthEvent, DoorHealthPublisher, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorControlMaterial, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, IdentityNameRead, IdentityRecord, IdentityRecordsPort, IdentitySession, InjectedCredential, LaunchApiDeps, LaunchApiRouter, LaunchDecision, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, LaunchPoolDecision, LaunchResolution, LaunchSelection, Layer, LayerId, LayoutPaths, LeafCert, LifecycleApiClient, LifecycleApiDeps, LifecycleApiRouter, LiveSessionRegistry, LiveSessionRegistryPorts, LiveTask, LiveTaskBook, LocatedSession, MergedAgentNode, MergedAgentTree, NestedContribution, OwnExecutableStat, PlanClass, Pool, PoolChange, PoolMember, PoolPickReport, PoolPolicy, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, QuotaExpiringEvent, QuotaExpiringPublisher, RankPoolInput, RcAnswerDecision, RcAnswerDeps, RcApiClient, RcApiDeps, RcApiRouter, RcClaudeCodeVersions, RcCompactOptions, RcCompactReport, RcContextUsageDetail, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcGoal, RcGoalClearReport, RcGoalReport, RcGoalSetReport, RcInjectDeps, RcLiveRateLimit, RcLiveUsage, RcLiveUsageDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPendingRetireReason, RcPermissionMode, RcPresenceAnswer, RcRateLimitInfo, RcRateLimitWindow, RcReadFileEncoding, RcReadFileOptions, RcRegisteredSession, RcRegistryIdentity, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionCommandDeps, RcSessionCommandOptions, RcSessionCommandResult, RcSessionCommandRoute, RcSessionCommands, RcSessionEndReason, RcSessionEvent, RcSessionEventLog, RcSessionEventLogDeps, RcSessionEventsApiDeps, RcSessionEventsApiRouter, RcSessionEventsRead, RcSessionEventsReadInput, RcSessionRegistryDeps, RcSessionRegistryFs, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcSessionTransition, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, RcSupervisedTarget, RcWebFetchDeps, RcWebFetchHop, RcWebFetchOutcome, RcWebFetcher, RcWorkerFact, RcWriteHeaders, ReadSessionOptions, RecoverFarmParams, RecoveryResult, RefreshLaunchPoolUsageOptions, RefreshPoolUsageParams, RefreshStalePoolMembersParams, ResetRow, ResetSchedule, ResolveClaudeLaunchOptions, ResolveDecisionsInput, ResolveLaunchSelectionParams, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunClaudeLaunchOptions, RunDoctorParams, RunFrontDoorSupervisorOptions, RunLauncherParams, RunSupervisorOptions, SessionAgentTree, SessionCommandFs, SessionListFilters, SessionRef, SessionSummary, SessionView, SpawnClaudeParams, SseParsedEvent, StickyPick, SupervisorPorts, TaskItem, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageChangeEvent, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation, WorkflowRun };