@mossbear/protocol 0.1.0-alpha.108 → 0.1.0-alpha.110

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.
package/dist/schemas.d.ts CHANGED
@@ -1299,6 +1299,17 @@ export declare const ArtifactCommentSchema: v.ObjectSchema<{
1299
1299
  readonly start: v.NumberSchema<undefined>;
1300
1300
  readonly end: v.NumberSchema<undefined>;
1301
1301
  }, undefined>, undefined>;
1302
+ /**
1303
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
1304
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
1305
+ * the passage has no source lines, so an agent can find a block the
1306
+ * page's script built.
1307
+ */
1308
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
1309
+ readonly selector: v.StringSchema<undefined>;
1310
+ readonly tag: v.StringSchema<undefined>;
1311
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
1312
+ }, undefined>, undefined>;
1302
1313
  }, undefined>, undefined>;
1303
1314
  /** The comment's text, already wrapped in the response's untrusted markers. */
1304
1315
  readonly body: v.StringSchema<undefined>;
@@ -1317,22 +1328,25 @@ export declare const ArtifactCommentSchema: v.ObjectSchema<{
1317
1328
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1318
1329
  }, undefined>, undefined>;
1319
1330
  /**
1320
- * Whether the person approved a comment Mossbear drafted. Present on every
1321
- * Mossbear comment and absent on a person's or an agent's, which are
1322
- * requests as written. `false` is a draft nobody has read yet: a reader shows
1323
- * it to the user and acts only on their go-ahead. Only a client that reports
1324
- * a version able to mark drafts is ever listed one, so an older reader that
1325
- * strips this field never receives a draft it would print as a request.
1331
+ * Whether the person handed a comment Mossbear drafted to their agent from
1332
+ * the comments panel. Present on every Mossbear comment and absent on a
1333
+ * person's or an agent's. It does not say whether the agent may act: read
1334
+ * `findingState` for that, and fall back to `approved: false` meaning "not
1335
+ * yet accepted" only when `findingState` is absent, from a server that
1336
+ * predates it. Only a client that reports a version able to mark drafts is
1337
+ * listed an unaccepted finding, so an older reader that strips this field
1338
+ * never receives one it would misread.
1326
1339
  */
1327
1340
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
1328
1341
  /**
1329
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
1330
- * person accepted it, or its evidence spans enough separate days to need no
1331
- * Accept. `waiting` means it waits on the person: show it to the user and
1332
- * change nothing unless they say so. Present only on an open Mossbear comment.
1333
- * A server that predates the field omits it, and a reader then falls back to
1334
- * `approved`. This is a new name rather than a new meaning for `state`,
1335
- * which already says open or resolved.
1342
+ * Whether an open Mossbear finding is the agent's to act on. A current server
1343
+ * sends `ready` on every open finding: it is the agent's unless the person
1344
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
1345
+ * an older server, means it waits on the person: show it to the user and
1346
+ * change nothing unless they say so. Present only on an open Mossbear
1347
+ * comment. A server that predates the field omits it, and a reader then
1348
+ * falls back to `approved`. This is a new name rather than a new meaning for
1349
+ * `state`, which already says open or resolved.
1336
1350
  */
1337
1351
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
1338
1352
  /**
@@ -1430,6 +1444,17 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
1430
1444
  readonly start: v.NumberSchema<undefined>;
1431
1445
  readonly end: v.NumberSchema<undefined>;
1432
1446
  }, undefined>, undefined>;
1447
+ /**
1448
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
1449
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
1450
+ * the passage has no source lines, so an agent can find a block the
1451
+ * page's script built.
1452
+ */
1453
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
1454
+ readonly selector: v.StringSchema<undefined>;
1455
+ readonly tag: v.StringSchema<undefined>;
1456
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
1457
+ }, undefined>, undefined>;
1433
1458
  }, undefined>, undefined>;
1434
1459
  /** The comment's text, already wrapped in the response's untrusted markers. */
1435
1460
  readonly body: v.StringSchema<undefined>;
@@ -1448,22 +1473,25 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
1448
1473
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1449
1474
  }, undefined>, undefined>;
1450
1475
  /**
1451
- * Whether the person approved a comment Mossbear drafted. Present on every
1452
- * Mossbear comment and absent on a person's or an agent's, which are
1453
- * requests as written. `false` is a draft nobody has read yet: a reader shows
1454
- * it to the user and acts only on their go-ahead. Only a client that reports
1455
- * a version able to mark drafts is ever listed one, so an older reader that
1456
- * strips this field never receives a draft it would print as a request.
1476
+ * Whether the person handed a comment Mossbear drafted to their agent from
1477
+ * the comments panel. Present on every Mossbear comment and absent on a
1478
+ * person's or an agent's. It does not say whether the agent may act: read
1479
+ * `findingState` for that, and fall back to `approved: false` meaning "not
1480
+ * yet accepted" only when `findingState` is absent, from a server that
1481
+ * predates it. Only a client that reports a version able to mark drafts is
1482
+ * listed an unaccepted finding, so an older reader that strips this field
1483
+ * never receives one it would misread.
1457
1484
  */
1458
1485
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
1459
1486
  /**
1460
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
1461
- * person accepted it, or its evidence spans enough separate days to need no
1462
- * Accept. `waiting` means it waits on the person: show it to the user and
1463
- * change nothing unless they say so. Present only on an open Mossbear comment.
1464
- * A server that predates the field omits it, and a reader then falls back to
1465
- * `approved`. This is a new name rather than a new meaning for `state`,
1466
- * which already says open or resolved.
1487
+ * Whether an open Mossbear finding is the agent's to act on. A current server
1488
+ * sends `ready` on every open finding: it is the agent's unless the person
1489
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
1490
+ * an older server, means it waits on the person: show it to the user and
1491
+ * change nothing unless they say so. Present only on an open Mossbear
1492
+ * comment. A server that predates the field omits it, and a reader then
1493
+ * falls back to `approved`. This is a new name rather than a new meaning for
1494
+ * `state`, which already says open or resolved.
1467
1495
  */
1468
1496
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
1469
1497
  /**
@@ -1726,6 +1754,17 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
1726
1754
  readonly start: v.NumberSchema<undefined>;
1727
1755
  readonly end: v.NumberSchema<undefined>;
1728
1756
  }, undefined>, undefined>;
1757
+ /**
1758
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
1759
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
1760
+ * the passage has no source lines, so an agent can find a block the
1761
+ * page's script built.
1762
+ */
1763
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
1764
+ readonly selector: v.StringSchema<undefined>;
1765
+ readonly tag: v.StringSchema<undefined>;
1766
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
1767
+ }, undefined>, undefined>;
1729
1768
  }, undefined>, undefined>;
1730
1769
  /** The comment's text, already wrapped in the response's untrusted markers. */
1731
1770
  readonly body: v.StringSchema<undefined>;
@@ -1744,22 +1783,25 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
1744
1783
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1745
1784
  }, undefined>, undefined>;
1746
1785
  /**
1747
- * Whether the person approved a comment Mossbear drafted. Present on every
1748
- * Mossbear comment and absent on a person's or an agent's, which are
1749
- * requests as written. `false` is a draft nobody has read yet: a reader shows
1750
- * it to the user and acts only on their go-ahead. Only a client that reports
1751
- * a version able to mark drafts is ever listed one, so an older reader that
1752
- * strips this field never receives a draft it would print as a request.
1786
+ * Whether the person handed a comment Mossbear drafted to their agent from
1787
+ * the comments panel. Present on every Mossbear comment and absent on a
1788
+ * person's or an agent's. It does not say whether the agent may act: read
1789
+ * `findingState` for that, and fall back to `approved: false` meaning "not
1790
+ * yet accepted" only when `findingState` is absent, from a server that
1791
+ * predates it. Only a client that reports a version able to mark drafts is
1792
+ * listed an unaccepted finding, so an older reader that strips this field
1793
+ * never receives one it would misread.
1753
1794
  */
1754
1795
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
1755
1796
  /**
1756
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
1757
- * person accepted it, or its evidence spans enough separate days to need no
1758
- * Accept. `waiting` means it waits on the person: show it to the user and
1759
- * change nothing unless they say so. Present only on an open Mossbear comment.
1760
- * A server that predates the field omits it, and a reader then falls back to
1761
- * `approved`. This is a new name rather than a new meaning for `state`,
1762
- * which already says open or resolved.
1797
+ * Whether an open Mossbear finding is the agent's to act on. A current server
1798
+ * sends `ready` on every open finding: it is the agent's unless the person
1799
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
1800
+ * an older server, means it waits on the person: show it to the user and
1801
+ * change nothing unless they say so. Present only on an open Mossbear
1802
+ * comment. A server that predates the field omits it, and a reader then
1803
+ * falls back to `approved`. This is a new name rather than a new meaning for
1804
+ * `state`, which already says open or resolved.
1763
1805
  */
1764
1806
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
1765
1807
  /**
@@ -1853,6 +1895,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
1853
1895
  start: number;
1854
1896
  end: number;
1855
1897
  } | null;
1898
+ element?: {
1899
+ selector: string;
1900
+ tag: string;
1901
+ label?: string | undefined;
1902
+ } | undefined;
1856
1903
  } | undefined;
1857
1904
  body: string;
1858
1905
  finding?: {
@@ -2007,6 +2054,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
2007
2054
  start: number;
2008
2055
  end: number;
2009
2056
  } | null;
2057
+ element?: {
2058
+ selector: string;
2059
+ tag: string;
2060
+ label?: string | undefined;
2061
+ } | undefined;
2010
2062
  } | undefined;
2011
2063
  body: string;
2012
2064
  finding?: {
@@ -2084,6 +2136,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
2084
2136
  start: number;
2085
2137
  end: number;
2086
2138
  } | null;
2139
+ element?: {
2140
+ selector: string;
2141
+ tag: string;
2142
+ label?: string | undefined;
2143
+ } | undefined;
2087
2144
  } | undefined;
2088
2145
  body: string;
2089
2146
  finding?: {
@@ -2246,6 +2303,17 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2246
2303
  readonly start: v.NumberSchema<undefined>;
2247
2304
  readonly end: v.NumberSchema<undefined>;
2248
2305
  }, undefined>, undefined>;
2306
+ /**
2307
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
2308
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
2309
+ * the passage has no source lines, so an agent can find a block the
2310
+ * page's script built.
2311
+ */
2312
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
2313
+ readonly selector: v.StringSchema<undefined>;
2314
+ readonly tag: v.StringSchema<undefined>;
2315
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
2316
+ }, undefined>, undefined>;
2249
2317
  }, undefined>, undefined>;
2250
2318
  /** The comment's text, already wrapped in the response's untrusted markers. */
2251
2319
  readonly body: v.StringSchema<undefined>;
@@ -2264,22 +2332,25 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2264
2332
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
2265
2333
  }, undefined>, undefined>;
2266
2334
  /**
2267
- * Whether the person approved a comment Mossbear drafted. Present on every
2268
- * Mossbear comment and absent on a person's or an agent's, which are
2269
- * requests as written. `false` is a draft nobody has read yet: a reader shows
2270
- * it to the user and acts only on their go-ahead. Only a client that reports
2271
- * a version able to mark drafts is ever listed one, so an older reader that
2272
- * strips this field never receives a draft it would print as a request.
2335
+ * Whether the person handed a comment Mossbear drafted to their agent from
2336
+ * the comments panel. Present on every Mossbear comment and absent on a
2337
+ * person's or an agent's. It does not say whether the agent may act: read
2338
+ * `findingState` for that, and fall back to `approved: false` meaning "not
2339
+ * yet accepted" only when `findingState` is absent, from a server that
2340
+ * predates it. Only a client that reports a version able to mark drafts is
2341
+ * listed an unaccepted finding, so an older reader that strips this field
2342
+ * never receives one it would misread.
2273
2343
  */
2274
2344
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
2275
2345
  /**
2276
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
2277
- * person accepted it, or its evidence spans enough separate days to need no
2278
- * Accept. `waiting` means it waits on the person: show it to the user and
2279
- * change nothing unless they say so. Present only on an open Mossbear comment.
2280
- * A server that predates the field omits it, and a reader then falls back to
2281
- * `approved`. This is a new name rather than a new meaning for `state`,
2282
- * which already says open or resolved.
2346
+ * Whether an open Mossbear finding is the agent's to act on. A current server
2347
+ * sends `ready` on every open finding: it is the agent's unless the person
2348
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
2349
+ * an older server, means it waits on the person: show it to the user and
2350
+ * change nothing unless they say so. Present only on an open Mossbear
2351
+ * comment. A server that predates the field omits it, and a reader then
2352
+ * falls back to `approved`. This is a new name rather than a new meaning for
2353
+ * `state`, which already says open or resolved.
2283
2354
  */
2284
2355
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
2285
2356
  /**
@@ -2373,6 +2444,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2373
2444
  start: number;
2374
2445
  end: number;
2375
2446
  } | null;
2447
+ element?: {
2448
+ selector: string;
2449
+ tag: string;
2450
+ label?: string | undefined;
2451
+ } | undefined;
2376
2452
  } | undefined;
2377
2453
  body: string;
2378
2454
  finding?: {
@@ -2527,6 +2603,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2527
2603
  start: number;
2528
2604
  end: number;
2529
2605
  } | null;
2606
+ element?: {
2607
+ selector: string;
2608
+ tag: string;
2609
+ label?: string | undefined;
2610
+ } | undefined;
2530
2611
  } | undefined;
2531
2612
  body: string;
2532
2613
  finding?: {
@@ -2604,6 +2685,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2604
2685
  start: number;
2605
2686
  end: number;
2606
2687
  } | null;
2688
+ element?: {
2689
+ selector: string;
2690
+ tag: string;
2691
+ label?: string | undefined;
2692
+ } | undefined;
2607
2693
  } | undefined;
2608
2694
  body: string;
2609
2695
  finding?: {
@@ -2784,6 +2870,17 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
2784
2870
  readonly start: v.NumberSchema<undefined>;
2785
2871
  readonly end: v.NumberSchema<undefined>;
2786
2872
  }, undefined>, undefined>;
2873
+ /**
2874
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
2875
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
2876
+ * the passage has no source lines, so an agent can find a block the
2877
+ * page's script built.
2878
+ */
2879
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
2880
+ readonly selector: v.StringSchema<undefined>;
2881
+ readonly tag: v.StringSchema<undefined>;
2882
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
2883
+ }, undefined>, undefined>;
2787
2884
  }, undefined>, undefined>;
2788
2885
  /** The comment's text, already wrapped in the response's untrusted markers. */
2789
2886
  readonly body: v.StringSchema<undefined>;
@@ -2802,22 +2899,25 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
2802
2899
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
2803
2900
  }, undefined>, undefined>;
2804
2901
  /**
2805
- * Whether the person approved a comment Mossbear drafted. Present on every
2806
- * Mossbear comment and absent on a person's or an agent's, which are
2807
- * requests as written. `false` is a draft nobody has read yet: a reader shows
2808
- * it to the user and acts only on their go-ahead. Only a client that reports
2809
- * a version able to mark drafts is ever listed one, so an older reader that
2810
- * strips this field never receives a draft it would print as a request.
2902
+ * Whether the person handed a comment Mossbear drafted to their agent from
2903
+ * the comments panel. Present on every Mossbear comment and absent on a
2904
+ * person's or an agent's. It does not say whether the agent may act: read
2905
+ * `findingState` for that, and fall back to `approved: false` meaning "not
2906
+ * yet accepted" only when `findingState` is absent, from a server that
2907
+ * predates it. Only a client that reports a version able to mark drafts is
2908
+ * listed an unaccepted finding, so an older reader that strips this field
2909
+ * never receives one it would misread.
2811
2910
  */
2812
2911
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
2813
2912
  /**
2814
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
2815
- * person accepted it, or its evidence spans enough separate days to need no
2816
- * Accept. `waiting` means it waits on the person: show it to the user and
2817
- * change nothing unless they say so. Present only on an open Mossbear comment.
2818
- * A server that predates the field omits it, and a reader then falls back to
2819
- * `approved`. This is a new name rather than a new meaning for `state`,
2820
- * which already says open or resolved.
2913
+ * Whether an open Mossbear finding is the agent's to act on. A current server
2914
+ * sends `ready` on every open finding: it is the agent's unless the person
2915
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
2916
+ * an older server, means it waits on the person: show it to the user and
2917
+ * change nothing unless they say so. Present only on an open Mossbear
2918
+ * comment. A server that predates the field omits it, and a reader then
2919
+ * falls back to `approved`. This is a new name rather than a new meaning for
2920
+ * `state`, which already says open or resolved.
2821
2921
  */
2822
2922
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
2823
2923
  /**
@@ -2911,6 +3011,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
2911
3011
  start: number;
2912
3012
  end: number;
2913
3013
  } | null;
3014
+ element?: {
3015
+ selector: string;
3016
+ tag: string;
3017
+ label?: string | undefined;
3018
+ } | undefined;
2914
3019
  } | undefined;
2915
3020
  body: string;
2916
3021
  finding?: {
@@ -3065,6 +3170,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
3065
3170
  start: number;
3066
3171
  end: number;
3067
3172
  } | null;
3173
+ element?: {
3174
+ selector: string;
3175
+ tag: string;
3176
+ label?: string | undefined;
3177
+ } | undefined;
3068
3178
  } | undefined;
3069
3179
  body: string;
3070
3180
  finding?: {
@@ -3142,6 +3252,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
3142
3252
  start: number;
3143
3253
  end: number;
3144
3254
  } | null;
3255
+ element?: {
3256
+ selector: string;
3257
+ tag: string;
3258
+ label?: string | undefined;
3259
+ } | undefined;
3145
3260
  } | undefined;
3146
3261
  body: string;
3147
3262
  finding?: {
@@ -3428,6 +3543,17 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
3428
3543
  readonly start: v.NumberSchema<undefined>;
3429
3544
  readonly end: v.NumberSchema<undefined>;
3430
3545
  }, undefined>, undefined>;
3546
+ /**
3547
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
3548
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
3549
+ * the passage has no source lines, so an agent can find a block the
3550
+ * page's script built.
3551
+ */
3552
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
3553
+ readonly selector: v.StringSchema<undefined>;
3554
+ readonly tag: v.StringSchema<undefined>;
3555
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
3556
+ }, undefined>, undefined>;
3431
3557
  }, undefined>, undefined>;
3432
3558
  /** The comment's text, already wrapped in the response's untrusted markers. */
3433
3559
  readonly body: v.StringSchema<undefined>;
@@ -3446,22 +3572,25 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
3446
3572
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
3447
3573
  }, undefined>, undefined>;
3448
3574
  /**
3449
- * Whether the person approved a comment Mossbear drafted. Present on every
3450
- * Mossbear comment and absent on a person's or an agent's, which are
3451
- * requests as written. `false` is a draft nobody has read yet: a reader shows
3452
- * it to the user and acts only on their go-ahead. Only a client that reports
3453
- * a version able to mark drafts is ever listed one, so an older reader that
3454
- * strips this field never receives a draft it would print as a request.
3575
+ * Whether the person handed a comment Mossbear drafted to their agent from
3576
+ * the comments panel. Present on every Mossbear comment and absent on a
3577
+ * person's or an agent's. It does not say whether the agent may act: read
3578
+ * `findingState` for that, and fall back to `approved: false` meaning "not
3579
+ * yet accepted" only when `findingState` is absent, from a server that
3580
+ * predates it. Only a client that reports a version able to mark drafts is
3581
+ * listed an unaccepted finding, so an older reader that strips this field
3582
+ * never receives one it would misread.
3455
3583
  */
3456
3584
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
3457
3585
  /**
3458
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
3459
- * person accepted it, or its evidence spans enough separate days to need no
3460
- * Accept. `waiting` means it waits on the person: show it to the user and
3461
- * change nothing unless they say so. Present only on an open Mossbear comment.
3462
- * A server that predates the field omits it, and a reader then falls back to
3463
- * `approved`. This is a new name rather than a new meaning for `state`,
3464
- * which already says open or resolved.
3586
+ * Whether an open Mossbear finding is the agent's to act on. A current server
3587
+ * sends `ready` on every open finding: it is the agent's unless the person
3588
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
3589
+ * an older server, means it waits on the person: show it to the user and
3590
+ * change nothing unless they say so. Present only on an open Mossbear
3591
+ * comment. A server that predates the field omits it, and a reader then
3592
+ * falls back to `approved`. This is a new name rather than a new meaning for
3593
+ * `state`, which already says open or resolved.
3465
3594
  */
3466
3595
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
3467
3596
  /**
@@ -3575,6 +3704,17 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
3575
3704
  readonly start: v.NumberSchema<undefined>;
3576
3705
  readonly end: v.NumberSchema<undefined>;
3577
3706
  }, undefined>, undefined>;
3707
+ /**
3708
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
3709
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
3710
+ * the passage has no source lines, so an agent can find a block the
3711
+ * page's script built.
3712
+ */
3713
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
3714
+ readonly selector: v.StringSchema<undefined>;
3715
+ readonly tag: v.StringSchema<undefined>;
3716
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
3717
+ }, undefined>, undefined>;
3578
3718
  }, undefined>, undefined>;
3579
3719
  /** The comment's text, already wrapped in the response's untrusted markers. */
3580
3720
  readonly body: v.StringSchema<undefined>;
@@ -3593,22 +3733,25 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
3593
3733
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
3594
3734
  }, undefined>, undefined>;
3595
3735
  /**
3596
- * Whether the person approved a comment Mossbear drafted. Present on every
3597
- * Mossbear comment and absent on a person's or an agent's, which are
3598
- * requests as written. `false` is a draft nobody has read yet: a reader shows
3599
- * it to the user and acts only on their go-ahead. Only a client that reports
3600
- * a version able to mark drafts is ever listed one, so an older reader that
3601
- * strips this field never receives a draft it would print as a request.
3736
+ * Whether the person handed a comment Mossbear drafted to their agent from
3737
+ * the comments panel. Present on every Mossbear comment and absent on a
3738
+ * person's or an agent's. It does not say whether the agent may act: read
3739
+ * `findingState` for that, and fall back to `approved: false` meaning "not
3740
+ * yet accepted" only when `findingState` is absent, from a server that
3741
+ * predates it. Only a client that reports a version able to mark drafts is
3742
+ * listed an unaccepted finding, so an older reader that strips this field
3743
+ * never receives one it would misread.
3602
3744
  */
3603
3745
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
3604
3746
  /**
3605
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
3606
- * person accepted it, or its evidence spans enough separate days to need no
3607
- * Accept. `waiting` means it waits on the person: show it to the user and
3608
- * change nothing unless they say so. Present only on an open Mossbear comment.
3609
- * A server that predates the field omits it, and a reader then falls back to
3610
- * `approved`. This is a new name rather than a new meaning for `state`,
3611
- * which already says open or resolved.
3747
+ * Whether an open Mossbear finding is the agent's to act on. A current server
3748
+ * sends `ready` on every open finding: it is the agent's unless the person
3749
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
3750
+ * an older server, means it waits on the person: show it to the user and
3751
+ * change nothing unless they say so. Present only on an open Mossbear
3752
+ * comment. A server that predates the field omits it, and a reader then
3753
+ * falls back to `approved`. This is a new name rather than a new meaning for
3754
+ * `state`, which already says open or resolved.
3612
3755
  */
3613
3756
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
3614
3757
  /**
@@ -4319,6 +4462,17 @@ export declare const ArtifactSchema: v.ObjectSchema<{
4319
4462
  readonly start: v.NumberSchema<undefined>;
4320
4463
  readonly end: v.NumberSchema<undefined>;
4321
4464
  }, undefined>, undefined>;
4465
+ /**
4466
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
4467
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
4468
+ * the passage has no source lines, so an agent can find a block the
4469
+ * page's script built.
4470
+ */
4471
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
4472
+ readonly selector: v.StringSchema<undefined>;
4473
+ readonly tag: v.StringSchema<undefined>;
4474
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
4475
+ }, undefined>, undefined>;
4322
4476
  }, undefined>, undefined>;
4323
4477
  /** The comment's text, already wrapped in the response's untrusted markers. */
4324
4478
  readonly body: v.StringSchema<undefined>;
@@ -4337,22 +4491,25 @@ export declare const ArtifactSchema: v.ObjectSchema<{
4337
4491
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
4338
4492
  }, undefined>, undefined>;
4339
4493
  /**
4340
- * Whether the person approved a comment Mossbear drafted. Present on every
4341
- * Mossbear comment and absent on a person's or an agent's, which are
4342
- * requests as written. `false` is a draft nobody has read yet: a reader shows
4343
- * it to the user and acts only on their go-ahead. Only a client that reports
4344
- * a version able to mark drafts is ever listed one, so an older reader that
4345
- * strips this field never receives a draft it would print as a request.
4494
+ * Whether the person handed a comment Mossbear drafted to their agent from
4495
+ * the comments panel. Present on every Mossbear comment and absent on a
4496
+ * person's or an agent's. It does not say whether the agent may act: read
4497
+ * `findingState` for that, and fall back to `approved: false` meaning "not
4498
+ * yet accepted" only when `findingState` is absent, from a server that
4499
+ * predates it. Only a client that reports a version able to mark drafts is
4500
+ * listed an unaccepted finding, so an older reader that strips this field
4501
+ * never receives one it would misread.
4346
4502
  */
4347
4503
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
4348
4504
  /**
4349
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
4350
- * person accepted it, or its evidence spans enough separate days to need no
4351
- * Accept. `waiting` means it waits on the person: show it to the user and
4352
- * change nothing unless they say so. Present only on an open Mossbear comment.
4353
- * A server that predates the field omits it, and a reader then falls back to
4354
- * `approved`. This is a new name rather than a new meaning for `state`,
4355
- * which already says open or resolved.
4505
+ * Whether an open Mossbear finding is the agent's to act on. A current server
4506
+ * sends `ready` on every open finding: it is the agent's unless the person
4507
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
4508
+ * an older server, means it waits on the person: show it to the user and
4509
+ * change nothing unless they say so. Present only on an open Mossbear
4510
+ * comment. A server that predates the field omits it, and a reader then
4511
+ * falls back to `approved`. This is a new name rather than a new meaning for
4512
+ * `state`, which already says open or resolved.
4356
4513
  */
4357
4514
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
4358
4515
  /**
@@ -4446,6 +4603,11 @@ export declare const ArtifactSchema: v.ObjectSchema<{
4446
4603
  start: number;
4447
4604
  end: number;
4448
4605
  } | null;
4606
+ element?: {
4607
+ selector: string;
4608
+ tag: string;
4609
+ label?: string | undefined;
4610
+ } | undefined;
4449
4611
  } | undefined;
4450
4612
  body: string;
4451
4613
  finding?: {
@@ -4559,6 +4721,17 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
4559
4721
  readonly start: v.NumberSchema<undefined>;
4560
4722
  readonly end: v.NumberSchema<undefined>;
4561
4723
  }, undefined>, undefined>;
4724
+ /**
4725
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
4726
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
4727
+ * the passage has no source lines, so an agent can find a block the
4728
+ * page's script built.
4729
+ */
4730
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
4731
+ readonly selector: v.StringSchema<undefined>;
4732
+ readonly tag: v.StringSchema<undefined>;
4733
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
4734
+ }, undefined>, undefined>;
4562
4735
  }, undefined>, undefined>;
4563
4736
  /** The comment's text, already wrapped in the response's untrusted markers. */
4564
4737
  readonly body: v.StringSchema<undefined>;
@@ -4577,22 +4750,25 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
4577
4750
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
4578
4751
  }, undefined>, undefined>;
4579
4752
  /**
4580
- * Whether the person approved a comment Mossbear drafted. Present on every
4581
- * Mossbear comment and absent on a person's or an agent's, which are
4582
- * requests as written. `false` is a draft nobody has read yet: a reader shows
4583
- * it to the user and acts only on their go-ahead. Only a client that reports
4584
- * a version able to mark drafts is ever listed one, so an older reader that
4585
- * strips this field never receives a draft it would print as a request.
4753
+ * Whether the person handed a comment Mossbear drafted to their agent from
4754
+ * the comments panel. Present on every Mossbear comment and absent on a
4755
+ * person's or an agent's. It does not say whether the agent may act: read
4756
+ * `findingState` for that, and fall back to `approved: false` meaning "not
4757
+ * yet accepted" only when `findingState` is absent, from a server that
4758
+ * predates it. Only a client that reports a version able to mark drafts is
4759
+ * listed an unaccepted finding, so an older reader that strips this field
4760
+ * never receives one it would misread.
4586
4761
  */
4587
4762
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
4588
4763
  /**
4589
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
4590
- * person accepted it, or its evidence spans enough separate days to need no
4591
- * Accept. `waiting` means it waits on the person: show it to the user and
4592
- * change nothing unless they say so. Present only on an open Mossbear comment.
4593
- * A server that predates the field omits it, and a reader then falls back to
4594
- * `approved`. This is a new name rather than a new meaning for `state`,
4595
- * which already says open or resolved.
4764
+ * Whether an open Mossbear finding is the agent's to act on. A current server
4765
+ * sends `ready` on every open finding: it is the agent's unless the person
4766
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
4767
+ * an older server, means it waits on the person: show it to the user and
4768
+ * change nothing unless they say so. Present only on an open Mossbear
4769
+ * comment. A server that predates the field omits it, and a reader then
4770
+ * falls back to `approved`. This is a new name rather than a new meaning for
4771
+ * `state`, which already says open or resolved.
4596
4772
  */
4597
4773
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
4598
4774
  /**
@@ -4686,6 +4862,11 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
4686
4862
  start: number;
4687
4863
  end: number;
4688
4864
  } | null;
4865
+ element?: {
4866
+ selector: string;
4867
+ tag: string;
4868
+ label?: string | undefined;
4869
+ } | undefined;
4689
4870
  } | undefined;
4690
4871
  body: string;
4691
4872
  finding?: {
@@ -5576,6 +5757,17 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
5576
5757
  readonly start: v.NumberSchema<undefined>;
5577
5758
  readonly end: v.NumberSchema<undefined>;
5578
5759
  }, undefined>, undefined>;
5760
+ /**
5761
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
5762
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
5763
+ * the passage has no source lines, so an agent can find a block the
5764
+ * page's script built.
5765
+ */
5766
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
5767
+ readonly selector: v.StringSchema<undefined>;
5768
+ readonly tag: v.StringSchema<undefined>;
5769
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
5770
+ }, undefined>, undefined>;
5579
5771
  }, undefined>, undefined>;
5580
5772
  /** The comment's text, already wrapped in the response's untrusted markers. */
5581
5773
  readonly body: v.StringSchema<undefined>;
@@ -5594,22 +5786,25 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
5594
5786
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
5595
5787
  }, undefined>, undefined>;
5596
5788
  /**
5597
- * Whether the person approved a comment Mossbear drafted. Present on every
5598
- * Mossbear comment and absent on a person's or an agent's, which are
5599
- * requests as written. `false` is a draft nobody has read yet: a reader shows
5600
- * it to the user and acts only on their go-ahead. Only a client that reports
5601
- * a version able to mark drafts is ever listed one, so an older reader that
5602
- * strips this field never receives a draft it would print as a request.
5789
+ * Whether the person handed a comment Mossbear drafted to their agent from
5790
+ * the comments panel. Present on every Mossbear comment and absent on a
5791
+ * person's or an agent's. It does not say whether the agent may act: read
5792
+ * `findingState` for that, and fall back to `approved: false` meaning "not
5793
+ * yet accepted" only when `findingState` is absent, from a server that
5794
+ * predates it. Only a client that reports a version able to mark drafts is
5795
+ * listed an unaccepted finding, so an older reader that strips this field
5796
+ * never receives one it would misread.
5603
5797
  */
5604
5798
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
5605
5799
  /**
5606
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
5607
- * person accepted it, or its evidence spans enough separate days to need no
5608
- * Accept. `waiting` means it waits on the person: show it to the user and
5609
- * change nothing unless they say so. Present only on an open Mossbear comment.
5610
- * A server that predates the field omits it, and a reader then falls back to
5611
- * `approved`. This is a new name rather than a new meaning for `state`,
5612
- * which already says open or resolved.
5800
+ * Whether an open Mossbear finding is the agent's to act on. A current server
5801
+ * sends `ready` on every open finding: it is the agent's unless the person
5802
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
5803
+ * an older server, means it waits on the person: show it to the user and
5804
+ * change nothing unless they say so. Present only on an open Mossbear
5805
+ * comment. A server that predates the field omits it, and a reader then
5806
+ * falls back to `approved`. This is a new name rather than a new meaning for
5807
+ * `state`, which already says open or resolved.
5613
5808
  */
5614
5809
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
5615
5810
  /**
@@ -5703,6 +5898,11 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
5703
5898
  start: number;
5704
5899
  end: number;
5705
5900
  } | null;
5901
+ element?: {
5902
+ selector: string;
5903
+ tag: string;
5904
+ label?: string | undefined;
5905
+ } | undefined;
5706
5906
  } | undefined;
5707
5907
  body: string;
5708
5908
  finding?: {
@@ -5855,6 +6055,17 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
5855
6055
  readonly start: v.NumberSchema<undefined>;
5856
6056
  readonly end: v.NumberSchema<undefined>;
5857
6057
  }, undefined>, undefined>;
6058
+ /**
6059
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
6060
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
6061
+ * the passage has no source lines, so an agent can find a block the
6062
+ * page's script built.
6063
+ */
6064
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
6065
+ readonly selector: v.StringSchema<undefined>;
6066
+ readonly tag: v.StringSchema<undefined>;
6067
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
6068
+ }, undefined>, undefined>;
5858
6069
  }, undefined>, undefined>;
5859
6070
  /** The comment's text, already wrapped in the response's untrusted markers. */
5860
6071
  readonly body: v.StringSchema<undefined>;
@@ -5873,22 +6084,25 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
5873
6084
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
5874
6085
  }, undefined>, undefined>;
5875
6086
  /**
5876
- * Whether the person approved a comment Mossbear drafted. Present on every
5877
- * Mossbear comment and absent on a person's or an agent's, which are
5878
- * requests as written. `false` is a draft nobody has read yet: a reader shows
5879
- * it to the user and acts only on their go-ahead. Only a client that reports
5880
- * a version able to mark drafts is ever listed one, so an older reader that
5881
- * strips this field never receives a draft it would print as a request.
6087
+ * Whether the person handed a comment Mossbear drafted to their agent from
6088
+ * the comments panel. Present on every Mossbear comment and absent on a
6089
+ * person's or an agent's. It does not say whether the agent may act: read
6090
+ * `findingState` for that, and fall back to `approved: false` meaning "not
6091
+ * yet accepted" only when `findingState` is absent, from a server that
6092
+ * predates it. Only a client that reports a version able to mark drafts is
6093
+ * listed an unaccepted finding, so an older reader that strips this field
6094
+ * never receives one it would misread.
5882
6095
  */
5883
6096
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
5884
6097
  /**
5885
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
5886
- * person accepted it, or its evidence spans enough separate days to need no
5887
- * Accept. `waiting` means it waits on the person: show it to the user and
5888
- * change nothing unless they say so. Present only on an open Mossbear comment.
5889
- * A server that predates the field omits it, and a reader then falls back to
5890
- * `approved`. This is a new name rather than a new meaning for `state`,
5891
- * which already says open or resolved.
6098
+ * Whether an open Mossbear finding is the agent's to act on. A current server
6099
+ * sends `ready` on every open finding: it is the agent's unless the person
6100
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
6101
+ * an older server, means it waits on the person: show it to the user and
6102
+ * change nothing unless they say so. Present only on an open Mossbear
6103
+ * comment. A server that predates the field omits it, and a reader then
6104
+ * falls back to `approved`. This is a new name rather than a new meaning for
6105
+ * `state`, which already says open or resolved.
5892
6106
  */
5893
6107
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
5894
6108
  /**
@@ -5982,6 +6196,11 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
5982
6196
  start: number;
5983
6197
  end: number;
5984
6198
  } | null;
6199
+ element?: {
6200
+ selector: string;
6201
+ tag: string;
6202
+ label?: string | undefined;
6203
+ } | undefined;
5985
6204
  } | undefined;
5986
6205
  body: string;
5987
6206
  finding?: {
@@ -6096,6 +6315,17 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
6096
6315
  readonly start: v.NumberSchema<undefined>;
6097
6316
  readonly end: v.NumberSchema<undefined>;
6098
6317
  }, undefined>, undefined>;
6318
+ /**
6319
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
6320
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
6321
+ * the passage has no source lines, so an agent can find a block the
6322
+ * page's script built.
6323
+ */
6324
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
6325
+ readonly selector: v.StringSchema<undefined>;
6326
+ readonly tag: v.StringSchema<undefined>;
6327
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
6328
+ }, undefined>, undefined>;
6099
6329
  }, undefined>, undefined>;
6100
6330
  /** The comment's text, already wrapped in the response's untrusted markers. */
6101
6331
  readonly body: v.StringSchema<undefined>;
@@ -6114,22 +6344,25 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
6114
6344
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
6115
6345
  }, undefined>, undefined>;
6116
6346
  /**
6117
- * Whether the person approved a comment Mossbear drafted. Present on every
6118
- * Mossbear comment and absent on a person's or an agent's, which are
6119
- * requests as written. `false` is a draft nobody has read yet: a reader shows
6120
- * it to the user and acts only on their go-ahead. Only a client that reports
6121
- * a version able to mark drafts is ever listed one, so an older reader that
6122
- * strips this field never receives a draft it would print as a request.
6347
+ * Whether the person handed a comment Mossbear drafted to their agent from
6348
+ * the comments panel. Present on every Mossbear comment and absent on a
6349
+ * person's or an agent's. It does not say whether the agent may act: read
6350
+ * `findingState` for that, and fall back to `approved: false` meaning "not
6351
+ * yet accepted" only when `findingState` is absent, from a server that
6352
+ * predates it. Only a client that reports a version able to mark drafts is
6353
+ * listed an unaccepted finding, so an older reader that strips this field
6354
+ * never receives one it would misread.
6123
6355
  */
6124
6356
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
6125
6357
  /**
6126
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
6127
- * person accepted it, or its evidence spans enough separate days to need no
6128
- * Accept. `waiting` means it waits on the person: show it to the user and
6129
- * change nothing unless they say so. Present only on an open Mossbear comment.
6130
- * A server that predates the field omits it, and a reader then falls back to
6131
- * `approved`. This is a new name rather than a new meaning for `state`,
6132
- * which already says open or resolved.
6358
+ * Whether an open Mossbear finding is the agent's to act on. A current server
6359
+ * sends `ready` on every open finding: it is the agent's unless the person
6360
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
6361
+ * an older server, means it waits on the person: show it to the user and
6362
+ * change nothing unless they say so. Present only on an open Mossbear
6363
+ * comment. A server that predates the field omits it, and a reader then
6364
+ * falls back to `approved`. This is a new name rather than a new meaning for
6365
+ * `state`, which already says open or resolved.
6133
6366
  */
6134
6367
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
6135
6368
  /**
@@ -6223,6 +6456,11 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
6223
6456
  start: number;
6224
6457
  end: number;
6225
6458
  } | null;
6459
+ element?: {
6460
+ selector: string;
6461
+ tag: string;
6462
+ label?: string | undefined;
6463
+ } | undefined;
6226
6464
  } | undefined;
6227
6465
  body: string;
6228
6466
  finding?: {
@@ -6403,6 +6641,17 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
6403
6641
  readonly start: v.NumberSchema<undefined>;
6404
6642
  readonly end: v.NumberSchema<undefined>;
6405
6643
  }, undefined>, undefined>;
6644
+ /**
6645
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
6646
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
6647
+ * the passage has no source lines, so an agent can find a block the
6648
+ * page's script built.
6649
+ */
6650
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
6651
+ readonly selector: v.StringSchema<undefined>;
6652
+ readonly tag: v.StringSchema<undefined>;
6653
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
6654
+ }, undefined>, undefined>;
6406
6655
  }, undefined>, undefined>;
6407
6656
  /** The comment's text, already wrapped in the response's untrusted markers. */
6408
6657
  readonly body: v.StringSchema<undefined>;
@@ -6421,22 +6670,25 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
6421
6670
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
6422
6671
  }, undefined>, undefined>;
6423
6672
  /**
6424
- * Whether the person approved a comment Mossbear drafted. Present on every
6425
- * Mossbear comment and absent on a person's or an agent's, which are
6426
- * requests as written. `false` is a draft nobody has read yet: a reader shows
6427
- * it to the user and acts only on their go-ahead. Only a client that reports
6428
- * a version able to mark drafts is ever listed one, so an older reader that
6429
- * strips this field never receives a draft it would print as a request.
6673
+ * Whether the person handed a comment Mossbear drafted to their agent from
6674
+ * the comments panel. Present on every Mossbear comment and absent on a
6675
+ * person's or an agent's. It does not say whether the agent may act: read
6676
+ * `findingState` for that, and fall back to `approved: false` meaning "not
6677
+ * yet accepted" only when `findingState` is absent, from a server that
6678
+ * predates it. Only a client that reports a version able to mark drafts is
6679
+ * listed an unaccepted finding, so an older reader that strips this field
6680
+ * never receives one it would misread.
6430
6681
  */
6431
6682
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
6432
6683
  /**
6433
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
6434
- * person accepted it, or its evidence spans enough separate days to need no
6435
- * Accept. `waiting` means it waits on the person: show it to the user and
6436
- * change nothing unless they say so. Present only on an open Mossbear comment.
6437
- * A server that predates the field omits it, and a reader then falls back to
6438
- * `approved`. This is a new name rather than a new meaning for `state`,
6439
- * which already says open or resolved.
6684
+ * Whether an open Mossbear finding is the agent's to act on. A current server
6685
+ * sends `ready` on every open finding: it is the agent's unless the person
6686
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
6687
+ * an older server, means it waits on the person: show it to the user and
6688
+ * change nothing unless they say so. Present only on an open Mossbear
6689
+ * comment. A server that predates the field omits it, and a reader then
6690
+ * falls back to `approved`. This is a new name rather than a new meaning for
6691
+ * `state`, which already says open or resolved.
6440
6692
  */
6441
6693
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
6442
6694
  /**
@@ -6530,6 +6782,11 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
6530
6782
  start: number;
6531
6783
  end: number;
6532
6784
  } | null;
6785
+ element?: {
6786
+ selector: string;
6787
+ tag: string;
6788
+ label?: string | undefined;
6789
+ } | undefined;
6533
6790
  } | undefined;
6534
6791
  body: string;
6535
6792
  finding?: {
@@ -6654,6 +6911,17 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
6654
6911
  readonly start: v.NumberSchema<undefined>;
6655
6912
  readonly end: v.NumberSchema<undefined>;
6656
6913
  }, undefined>, undefined>;
6914
+ /**
6915
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
6916
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
6917
+ * the passage has no source lines, so an agent can find a block the
6918
+ * page's script built.
6919
+ */
6920
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
6921
+ readonly selector: v.StringSchema<undefined>;
6922
+ readonly tag: v.StringSchema<undefined>;
6923
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
6924
+ }, undefined>, undefined>;
6657
6925
  }, undefined>, undefined>;
6658
6926
  /** The comment's text, already wrapped in the response's untrusted markers. */
6659
6927
  readonly body: v.StringSchema<undefined>;
@@ -6672,22 +6940,25 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
6672
6940
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
6673
6941
  }, undefined>, undefined>;
6674
6942
  /**
6675
- * Whether the person approved a comment Mossbear drafted. Present on every
6676
- * Mossbear comment and absent on a person's or an agent's, which are
6677
- * requests as written. `false` is a draft nobody has read yet: a reader shows
6678
- * it to the user and acts only on their go-ahead. Only a client that reports
6679
- * a version able to mark drafts is ever listed one, so an older reader that
6680
- * strips this field never receives a draft it would print as a request.
6943
+ * Whether the person handed a comment Mossbear drafted to their agent from
6944
+ * the comments panel. Present on every Mossbear comment and absent on a
6945
+ * person's or an agent's. It does not say whether the agent may act: read
6946
+ * `findingState` for that, and fall back to `approved: false` meaning "not
6947
+ * yet accepted" only when `findingState` is absent, from a server that
6948
+ * predates it. Only a client that reports a version able to mark drafts is
6949
+ * listed an unaccepted finding, so an older reader that strips this field
6950
+ * never receives one it would misread.
6681
6951
  */
6682
6952
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
6683
6953
  /**
6684
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
6685
- * person accepted it, or its evidence spans enough separate days to need no
6686
- * Accept. `waiting` means it waits on the person: show it to the user and
6687
- * change nothing unless they say so. Present only on an open Mossbear comment.
6688
- * A server that predates the field omits it, and a reader then falls back to
6689
- * `approved`. This is a new name rather than a new meaning for `state`,
6690
- * which already says open or resolved.
6954
+ * Whether an open Mossbear finding is the agent's to act on. A current server
6955
+ * sends `ready` on every open finding: it is the agent's unless the person
6956
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
6957
+ * an older server, means it waits on the person: show it to the user and
6958
+ * change nothing unless they say so. Present only on an open Mossbear
6959
+ * comment. A server that predates the field omits it, and a reader then
6960
+ * falls back to `approved`. This is a new name rather than a new meaning for
6961
+ * `state`, which already says open or resolved.
6691
6962
  */
6692
6963
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
6693
6964
  /**
@@ -6781,6 +7052,11 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
6781
7052
  start: number;
6782
7053
  end: number;
6783
7054
  } | null;
7055
+ element?: {
7056
+ selector: string;
7057
+ tag: string;
7058
+ label?: string | undefined;
7059
+ } | undefined;
6784
7060
  } | undefined;
6785
7061
  body: string;
6786
7062
  finding?: {
@@ -7067,6 +7343,17 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
7067
7343
  readonly start: v.NumberSchema<undefined>;
7068
7344
  readonly end: v.NumberSchema<undefined>;
7069
7345
  }, undefined>, undefined>;
7346
+ /**
7347
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
7348
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
7349
+ * the passage has no source lines, so an agent can find a block the
7350
+ * page's script built.
7351
+ */
7352
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
7353
+ readonly selector: v.StringSchema<undefined>;
7354
+ readonly tag: v.StringSchema<undefined>;
7355
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7356
+ }, undefined>, undefined>;
7070
7357
  }, undefined>, undefined>;
7071
7358
  /** The comment's text, already wrapped in the response's untrusted markers. */
7072
7359
  readonly body: v.StringSchema<undefined>;
@@ -7085,22 +7372,25 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
7085
7372
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
7086
7373
  }, undefined>, undefined>;
7087
7374
  /**
7088
- * Whether the person approved a comment Mossbear drafted. Present on every
7089
- * Mossbear comment and absent on a person's or an agent's, which are
7090
- * requests as written. `false` is a draft nobody has read yet: a reader shows
7091
- * it to the user and acts only on their go-ahead. Only a client that reports
7092
- * a version able to mark drafts is ever listed one, so an older reader that
7093
- * strips this field never receives a draft it would print as a request.
7375
+ * Whether the person handed a comment Mossbear drafted to their agent from
7376
+ * the comments panel. Present on every Mossbear comment and absent on a
7377
+ * person's or an agent's. It does not say whether the agent may act: read
7378
+ * `findingState` for that, and fall back to `approved: false` meaning "not
7379
+ * yet accepted" only when `findingState` is absent, from a server that
7380
+ * predates it. Only a client that reports a version able to mark drafts is
7381
+ * listed an unaccepted finding, so an older reader that strips this field
7382
+ * never receives one it would misread.
7094
7383
  */
7095
7384
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
7096
7385
  /**
7097
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
7098
- * person accepted it, or its evidence spans enough separate days to need no
7099
- * Accept. `waiting` means it waits on the person: show it to the user and
7100
- * change nothing unless they say so. Present only on an open Mossbear comment.
7101
- * A server that predates the field omits it, and a reader then falls back to
7102
- * `approved`. This is a new name rather than a new meaning for `state`,
7103
- * which already says open or resolved.
7386
+ * Whether an open Mossbear finding is the agent's to act on. A current server
7387
+ * sends `ready` on every open finding: it is the agent's unless the person
7388
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
7389
+ * an older server, means it waits on the person: show it to the user and
7390
+ * change nothing unless they say so. Present only on an open Mossbear
7391
+ * comment. A server that predates the field omits it, and a reader then
7392
+ * falls back to `approved`. This is a new name rather than a new meaning for
7393
+ * `state`, which already says open or resolved.
7104
7394
  */
7105
7395
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
7106
7396
  /**
@@ -7194,6 +7484,11 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
7194
7484
  start: number;
7195
7485
  end: number;
7196
7486
  } | null;
7487
+ element?: {
7488
+ selector: string;
7489
+ tag: string;
7490
+ label?: string | undefined;
7491
+ } | undefined;
7197
7492
  } | undefined;
7198
7493
  body: string;
7199
7494
  finding?: {
@@ -7310,6 +7605,17 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
7310
7605
  readonly start: v.NumberSchema<undefined>;
7311
7606
  readonly end: v.NumberSchema<undefined>;
7312
7607
  }, undefined>, undefined>;
7608
+ /**
7609
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
7610
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
7611
+ * the passage has no source lines, so an agent can find a block the
7612
+ * page's script built.
7613
+ */
7614
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
7615
+ readonly selector: v.StringSchema<undefined>;
7616
+ readonly tag: v.StringSchema<undefined>;
7617
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7618
+ }, undefined>, undefined>;
7313
7619
  }, undefined>, undefined>;
7314
7620
  /** The comment's text, already wrapped in the response's untrusted markers. */
7315
7621
  readonly body: v.StringSchema<undefined>;
@@ -7328,22 +7634,25 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
7328
7634
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
7329
7635
  }, undefined>, undefined>;
7330
7636
  /**
7331
- * Whether the person approved a comment Mossbear drafted. Present on every
7332
- * Mossbear comment and absent on a person's or an agent's, which are
7333
- * requests as written. `false` is a draft nobody has read yet: a reader shows
7334
- * it to the user and acts only on their go-ahead. Only a client that reports
7335
- * a version able to mark drafts is ever listed one, so an older reader that
7336
- * strips this field never receives a draft it would print as a request.
7637
+ * Whether the person handed a comment Mossbear drafted to their agent from
7638
+ * the comments panel. Present on every Mossbear comment and absent on a
7639
+ * person's or an agent's. It does not say whether the agent may act: read
7640
+ * `findingState` for that, and fall back to `approved: false` meaning "not
7641
+ * yet accepted" only when `findingState` is absent, from a server that
7642
+ * predates it. Only a client that reports a version able to mark drafts is
7643
+ * listed an unaccepted finding, so an older reader that strips this field
7644
+ * never receives one it would misread.
7337
7645
  */
7338
7646
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
7339
7647
  /**
7340
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
7341
- * person accepted it, or its evidence spans enough separate days to need no
7342
- * Accept. `waiting` means it waits on the person: show it to the user and
7343
- * change nothing unless they say so. Present only on an open Mossbear comment.
7344
- * A server that predates the field omits it, and a reader then falls back to
7345
- * `approved`. This is a new name rather than a new meaning for `state`,
7346
- * which already says open or resolved.
7648
+ * Whether an open Mossbear finding is the agent's to act on. A current server
7649
+ * sends `ready` on every open finding: it is the agent's unless the person
7650
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
7651
+ * an older server, means it waits on the person: show it to the user and
7652
+ * change nothing unless they say so. Present only on an open Mossbear
7653
+ * comment. A server that predates the field omits it, and a reader then
7654
+ * falls back to `approved`. This is a new name rather than a new meaning for
7655
+ * `state`, which already says open or resolved.
7347
7656
  */
7348
7657
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
7349
7658
  /**
@@ -7437,6 +7746,11 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
7437
7746
  start: number;
7438
7747
  end: number;
7439
7748
  } | null;
7749
+ element?: {
7750
+ selector: string;
7751
+ tag: string;
7752
+ label?: string | undefined;
7753
+ } | undefined;
7440
7754
  } | undefined;
7441
7755
  body: string;
7442
7756
  finding?: {
@@ -7552,6 +7866,17 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
7552
7866
  readonly start: v.NumberSchema<undefined>;
7553
7867
  readonly end: v.NumberSchema<undefined>;
7554
7868
  }, undefined>, undefined>;
7869
+ /**
7870
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
7871
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
7872
+ * the passage has no source lines, so an agent can find a block the
7873
+ * page's script built.
7874
+ */
7875
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
7876
+ readonly selector: v.StringSchema<undefined>;
7877
+ readonly tag: v.StringSchema<undefined>;
7878
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7879
+ }, undefined>, undefined>;
7555
7880
  }, undefined>, undefined>;
7556
7881
  /** The comment's text, already wrapped in the response's untrusted markers. */
7557
7882
  readonly body: v.StringSchema<undefined>;
@@ -7570,22 +7895,25 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
7570
7895
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
7571
7896
  }, undefined>, undefined>;
7572
7897
  /**
7573
- * Whether the person approved a comment Mossbear drafted. Present on every
7574
- * Mossbear comment and absent on a person's or an agent's, which are
7575
- * requests as written. `false` is a draft nobody has read yet: a reader shows
7576
- * it to the user and acts only on their go-ahead. Only a client that reports
7577
- * a version able to mark drafts is ever listed one, so an older reader that
7578
- * strips this field never receives a draft it would print as a request.
7898
+ * Whether the person handed a comment Mossbear drafted to their agent from
7899
+ * the comments panel. Present on every Mossbear comment and absent on a
7900
+ * person's or an agent's. It does not say whether the agent may act: read
7901
+ * `findingState` for that, and fall back to `approved: false` meaning "not
7902
+ * yet accepted" only when `findingState` is absent, from a server that
7903
+ * predates it. Only a client that reports a version able to mark drafts is
7904
+ * listed an unaccepted finding, so an older reader that strips this field
7905
+ * never receives one it would misread.
7579
7906
  */
7580
7907
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
7581
7908
  /**
7582
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
7583
- * person accepted it, or its evidence spans enough separate days to need no
7584
- * Accept. `waiting` means it waits on the person: show it to the user and
7585
- * change nothing unless they say so. Present only on an open Mossbear comment.
7586
- * A server that predates the field omits it, and a reader then falls back to
7587
- * `approved`. This is a new name rather than a new meaning for `state`,
7588
- * which already says open or resolved.
7909
+ * Whether an open Mossbear finding is the agent's to act on. A current server
7910
+ * sends `ready` on every open finding: it is the agent's unless the person
7911
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
7912
+ * an older server, means it waits on the person: show it to the user and
7913
+ * change nothing unless they say so. Present only on an open Mossbear
7914
+ * comment. A server that predates the field omits it, and a reader then
7915
+ * falls back to `approved`. This is a new name rather than a new meaning for
7916
+ * `state`, which already says open or resolved.
7589
7917
  */
7590
7918
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
7591
7919
  /**
@@ -7679,6 +8007,11 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
7679
8007
  start: number;
7680
8008
  end: number;
7681
8009
  } | null;
8010
+ element?: {
8011
+ selector: string;
8012
+ tag: string;
8013
+ label?: string | undefined;
8014
+ } | undefined;
7682
8015
  } | undefined;
7683
8016
  body: string;
7684
8017
  finding?: {
@@ -9574,6 +9907,17 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
9574
9907
  readonly start: v.NumberSchema<undefined>;
9575
9908
  readonly end: v.NumberSchema<undefined>;
9576
9909
  }, undefined>, undefined>;
9910
+ /**
9911
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
9912
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
9913
+ * the passage has no source lines, so an agent can find a block the
9914
+ * page's script built.
9915
+ */
9916
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
9917
+ readonly selector: v.StringSchema<undefined>;
9918
+ readonly tag: v.StringSchema<undefined>;
9919
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
9920
+ }, undefined>, undefined>;
9577
9921
  }, undefined>, undefined>;
9578
9922
  /** The comment's text, already wrapped in the response's untrusted markers. */
9579
9923
  readonly body: v.StringSchema<undefined>;
@@ -9592,22 +9936,25 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
9592
9936
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
9593
9937
  }, undefined>, undefined>;
9594
9938
  /**
9595
- * Whether the person approved a comment Mossbear drafted. Present on every
9596
- * Mossbear comment and absent on a person's or an agent's, which are
9597
- * requests as written. `false` is a draft nobody has read yet: a reader shows
9598
- * it to the user and acts only on their go-ahead. Only a client that reports
9599
- * a version able to mark drafts is ever listed one, so an older reader that
9600
- * strips this field never receives a draft it would print as a request.
9939
+ * Whether the person handed a comment Mossbear drafted to their agent from
9940
+ * the comments panel. Present on every Mossbear comment and absent on a
9941
+ * person's or an agent's. It does not say whether the agent may act: read
9942
+ * `findingState` for that, and fall back to `approved: false` meaning "not
9943
+ * yet accepted" only when `findingState` is absent, from a server that
9944
+ * predates it. Only a client that reports a version able to mark drafts is
9945
+ * listed an unaccepted finding, so an older reader that strips this field
9946
+ * never receives one it would misread.
9601
9947
  */
9602
9948
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
9603
9949
  /**
9604
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
9605
- * person accepted it, or its evidence spans enough separate days to need no
9606
- * Accept. `waiting` means it waits on the person: show it to the user and
9607
- * change nothing unless they say so. Present only on an open Mossbear comment.
9608
- * A server that predates the field omits it, and a reader then falls back to
9609
- * `approved`. This is a new name rather than a new meaning for `state`,
9610
- * which already says open or resolved.
9950
+ * Whether an open Mossbear finding is the agent's to act on. A current server
9951
+ * sends `ready` on every open finding: it is the agent's unless the person
9952
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
9953
+ * an older server, means it waits on the person: show it to the user and
9954
+ * change nothing unless they say so. Present only on an open Mossbear
9955
+ * comment. A server that predates the field omits it, and a reader then
9956
+ * falls back to `approved`. This is a new name rather than a new meaning for
9957
+ * `state`, which already says open or resolved.
9611
9958
  */
9612
9959
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
9613
9960
  /**
@@ -9935,6 +10282,17 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
9935
10282
  readonly start: v.NumberSchema<undefined>;
9936
10283
  readonly end: v.NumberSchema<undefined>;
9937
10284
  }, undefined>, undefined>;
10285
+ /**
10286
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
10287
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
10288
+ * the passage has no source lines, so an agent can find a block the
10289
+ * page's script built.
10290
+ */
10291
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
10292
+ readonly selector: v.StringSchema<undefined>;
10293
+ readonly tag: v.StringSchema<undefined>;
10294
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
10295
+ }, undefined>, undefined>;
9938
10296
  }, undefined>, undefined>;
9939
10297
  /** The comment's text, already wrapped in the response's untrusted markers. */
9940
10298
  readonly body: v.StringSchema<undefined>;
@@ -9953,22 +10311,25 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
9953
10311
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
9954
10312
  }, undefined>, undefined>;
9955
10313
  /**
9956
- * Whether the person approved a comment Mossbear drafted. Present on every
9957
- * Mossbear comment and absent on a person's or an agent's, which are
9958
- * requests as written. `false` is a draft nobody has read yet: a reader shows
9959
- * it to the user and acts only on their go-ahead. Only a client that reports
9960
- * a version able to mark drafts is ever listed one, so an older reader that
9961
- * strips this field never receives a draft it would print as a request.
10314
+ * Whether the person handed a comment Mossbear drafted to their agent from
10315
+ * the comments panel. Present on every Mossbear comment and absent on a
10316
+ * person's or an agent's. It does not say whether the agent may act: read
10317
+ * `findingState` for that, and fall back to `approved: false` meaning "not
10318
+ * yet accepted" only when `findingState` is absent, from a server that
10319
+ * predates it. Only a client that reports a version able to mark drafts is
10320
+ * listed an unaccepted finding, so an older reader that strips this field
10321
+ * never receives one it would misread.
9962
10322
  */
9963
10323
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
9964
10324
  /**
9965
- * Whether an open Mossbear finding is the agent's to act on. `ready` means the
9966
- * person accepted it, or its evidence spans enough separate days to need no
9967
- * Accept. `waiting` means it waits on the person: show it to the user and
9968
- * change nothing unless they say so. Present only on an open Mossbear comment.
9969
- * A server that predates the field omits it, and a reader then falls back to
9970
- * `approved`. This is a new name rather than a new meaning for `state`,
9971
- * which already says open or resolved.
10325
+ * Whether an open Mossbear finding is the agent's to act on. A current server
10326
+ * sends `ready` on every open finding: it is the agent's unless the person
10327
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
10328
+ * an older server, means it waits on the person: show it to the user and
10329
+ * change nothing unless they say so. Present only on an open Mossbear
10330
+ * comment. A server that predates the field omits it, and a reader then
10331
+ * falls back to `approved`. This is a new name rather than a new meaning for
10332
+ * `state`, which already says open or resolved.
9972
10333
  */
9973
10334
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
9974
10335
  /**
@@ -10253,6 +10614,51 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
10253
10614
  }, undefined>, undefined>;
10254
10615
  }, undefined>;
10255
10616
  export type ArtifactFeedbackBatchResponse = v.InferOutput<typeof ArtifactFeedbackBatchResponseSchema>;
10617
+ /**
10618
+ * How many artifacts one prompt-time announcement names. The rest are counted
10619
+ * in one line and named on a later prompt, so a session that wrote many
10620
+ * artifacts prints a few lines in front of a turn rather than a list.
10621
+ */
10622
+ export declare const MAX_SESSION_COMMENT_ANNOUNCEMENT_ARTIFACTS = 5;
10623
+ /**
10624
+ * Ask which artifacts this agent session wrote carry open comments, and which
10625
+ * (`agent-hears-new-artifact-comments` slice 3).
10626
+ *
10627
+ * **A read, not a write.** Which of those comments the session has already been
10628
+ * told about is kept beside the session, by comment id. Not by creation time:
10629
+ * a comment can become readable long after it was created (a finding its owner
10630
+ * approves, an artifact restored from the Trash), and a time cursor would have
10631
+ * passed it by. The session-start announcement's per-repo count is a different
10632
+ * question and is not touched.
10633
+ */
10634
+ export declare const AnnounceSessionCommentsRequestSchema: v.ObjectSchema<{
10635
+ /**
10636
+ * The harness's own id for the session, as artifact writes record it in a
10637
+ * version's metadata. Matched only against versions the caller's account
10638
+ * wrote, so naming another account's session finds nothing.
10639
+ */
10640
+ readonly agentSessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
10641
+ /** The repo asking, as its committed config declares it, for repo-scoped findings. */
10642
+ readonly projectId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "projectId must contain only letters, digits, underscore, dot or hyphen">]>, undefined>;
10643
+ }, undefined>;
10644
+ export type AnnounceSessionCommentsRequest = v.InferOutput<typeof AnnounceSessionCommentsRequestSchema>;
10645
+ export declare const AnnounceSessionCommentsResponseSchema: v.ObjectSchema<{
10646
+ /**
10647
+ * The session's artifacts that carry open comments, most recently commented
10648
+ * first; at most as many as one batch feedback read takes.
10649
+ */
10650
+ readonly artifacts: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
10651
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
10652
+ readonly name: v.StringSchema<undefined>;
10653
+ /** Its open comments, newest first, at most one wire allowance of them. */
10654
+ readonly commentIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>, v.MaxLengthAction<string[], 20, undefined>]>;
10655
+ }, undefined>, undefined>, v.MaxLengthAction<{
10656
+ id: string;
10657
+ name: string;
10658
+ commentIds: string[];
10659
+ }[], 25, undefined>]>;
10660
+ }, undefined>;
10661
+ export type AnnounceSessionCommentsResponse = v.InferOutput<typeof AnnounceSessionCommentsResponseSchema>;
10256
10662
  export declare const SessionGradeRequestSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
10257
10663
  readonly session: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>, v.CheckAction<string, "identifier must not contain control characters">]>, undefined>;
10258
10664
  readonly agent_session: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>, v.CheckAction<string, "identifier must not contain control characters">]>, undefined>;
@@ -10962,8 +11368,10 @@ export declare const SearchArtifactCommentHitSchema: v.ObjectSchema<{
10962
11368
  */
10963
11369
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
10964
11370
  /**
10965
- * A Mossbear suggestion's draft state: whether its owner has handed it to
10966
- * their agents. Absent on a person's or an agent's comment and on a reply.
11371
+ * Whether a Mossbear finding's owner handed it to their agents from the
11372
+ * comments panel. It does not say whether an agent may act on it: every open
11373
+ * finding is ready unless dismissed. Absent on a person's or an agent's
11374
+ * comment and on a reply.
10967
11375
  */
10968
11376
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
10969
11377
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11015,8 +11423,10 @@ export declare const SearchCommentHitSchema: v.VariantSchema<"subjectKind", [v.O
11015
11423
  */
11016
11424
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
11017
11425
  /**
11018
- * A Mossbear suggestion's draft state: whether its owner has handed it to
11019
- * their agents. Absent on a person's or an agent's comment and on a reply.
11426
+ * Whether a Mossbear finding's owner handed it to their agents from the
11427
+ * comments panel. It does not say whether an agent may act on it: every open
11428
+ * finding is ready unless dismissed. Absent on a person's or an agent's
11429
+ * comment and on a reply.
11020
11430
  */
11021
11431
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
11022
11432
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11233,8 +11643,10 @@ export declare const SearchCommentsReportSchema: v.VariantSchema<"status", [v.Ob
11233
11643
  */
11234
11644
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
11235
11645
  /**
11236
- * A Mossbear suggestion's draft state: whether its owner has handed it to
11237
- * their agents. Absent on a person's or an agent's comment and on a reply.
11646
+ * Whether a Mossbear finding's owner handed it to their agents from the
11647
+ * comments panel. It does not say whether an agent may act on it: every open
11648
+ * finding is ready unless dismissed. Absent on a person's or an agent's
11649
+ * comment and on a reply.
11238
11650
  */
11239
11651
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
11240
11652
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11477,8 +11889,10 @@ export declare const SearchResponseSchema: v.ObjectSchema<{
11477
11889
  */
11478
11890
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
11479
11891
  /**
11480
- * A Mossbear suggestion's draft state: whether its owner has handed it to
11481
- * their agents. Absent on a person's or an agent's comment and on a reply.
11892
+ * Whether a Mossbear finding's owner handed it to their agents from the
11893
+ * comments panel. It does not say whether an agent may act on it: every open
11894
+ * finding is ready unless dismissed. Absent on a person's or an agent's
11895
+ * comment and on a reply.
11482
11896
  */
11483
11897
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
11484
11898
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11805,6 +12219,11 @@ export declare function parseContextItemsResponse(data: unknown): {
11805
12219
  start: number;
11806
12220
  end: number;
11807
12221
  } | null;
12222
+ element?: {
12223
+ selector: string;
12224
+ tag: string;
12225
+ label?: string | undefined;
12226
+ } | undefined;
11808
12227
  } | undefined;
11809
12228
  body: string;
11810
12229
  finding?: {
@@ -11892,6 +12311,11 @@ export declare function parseBundleArtifactsResponse(data: unknown): {
11892
12311
  start: number;
11893
12312
  end: number;
11894
12313
  } | null;
12314
+ element?: {
12315
+ selector: string;
12316
+ tag: string;
12317
+ label?: string | undefined;
12318
+ } | undefined;
11895
12319
  } | undefined;
11896
12320
  body: string;
11897
12321
  finding?: {
@@ -12222,6 +12646,13 @@ export declare function parseAnnounceItemCommentsResponse(data: unknown): {
12222
12646
  open: number;
12223
12647
  announced: number;
12224
12648
  };
12649
+ export declare function parseAnnounceSessionCommentsResponse(data: unknown): {
12650
+ artifacts: {
12651
+ id: string;
12652
+ name: string;
12653
+ commentIds: string[];
12654
+ }[];
12655
+ };
12225
12656
  export declare function parseAgentCommentResponse(data: unknown): {
12226
12657
  created: boolean;
12227
12658
  comment: {
@@ -12248,6 +12679,11 @@ export declare function parseItemCommentsResponse(data: unknown): {
12248
12679
  start: number;
12249
12680
  end: number;
12250
12681
  } | null;
12682
+ element?: {
12683
+ selector: string;
12684
+ tag: string;
12685
+ label?: string | undefined;
12686
+ } | undefined;
12251
12687
  } | undefined;
12252
12688
  body: string;
12253
12689
  finding?: {