@mossbear/protocol 0.1.0-alpha.109 → 0.1.0-alpha.111

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,26 @@ 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. Nothing
1332
+ * hands one over any more, so a current server sends `false` on every Mossbear
1333
+ * comment and omits it on a person's or an agent's; the field stays for
1334
+ * readers that predate `findingState`. It does not say whether the agent may
1335
+ * act: read `findingState` for that, and fall back to `approved: false`
1336
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
1337
+ * that predates it. Only a client that reports a version able to mark drafts
1338
+ * is listed a finding at all, so an older reader that strips this field never
1339
+ * receives one it would misread.
1326
1340
  */
1327
1341
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
1328
1342
  /**
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.
1343
+ * Whether an open Mossbear finding is the agent's to act on. A current server
1344
+ * sends `ready` on every open finding: it is the agent's unless the person
1345
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
1346
+ * an older server, means it waits on the person: show it to the user and
1347
+ * change nothing unless they say so. Present only on an open Mossbear
1348
+ * comment. A server that predates the field omits it, and a reader then
1349
+ * falls back to `approved`. This is a new name rather than a new meaning for
1350
+ * `state`, which already says open or resolved.
1336
1351
  */
1337
1352
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
1338
1353
  /**
@@ -1430,6 +1445,17 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
1430
1445
  readonly start: v.NumberSchema<undefined>;
1431
1446
  readonly end: v.NumberSchema<undefined>;
1432
1447
  }, undefined>, undefined>;
1448
+ /**
1449
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
1450
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
1451
+ * the passage has no source lines, so an agent can find a block the
1452
+ * page's script built.
1453
+ */
1454
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
1455
+ readonly selector: v.StringSchema<undefined>;
1456
+ readonly tag: v.StringSchema<undefined>;
1457
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
1458
+ }, undefined>, undefined>;
1433
1459
  }, undefined>, undefined>;
1434
1460
  /** The comment's text, already wrapped in the response's untrusted markers. */
1435
1461
  readonly body: v.StringSchema<undefined>;
@@ -1448,22 +1474,26 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
1448
1474
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1449
1475
  }, undefined>, undefined>;
1450
1476
  /**
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.
1477
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
1478
+ * hands one over any more, so a current server sends `false` on every Mossbear
1479
+ * comment and omits it on a person's or an agent's; the field stays for
1480
+ * readers that predate `findingState`. It does not say whether the agent may
1481
+ * act: read `findingState` for that, and fall back to `approved: false`
1482
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
1483
+ * that predates it. Only a client that reports a version able to mark drafts
1484
+ * is listed a finding at all, so an older reader that strips this field never
1485
+ * receives one it would misread.
1457
1486
  */
1458
1487
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
1459
1488
  /**
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.
1489
+ * Whether an open Mossbear finding is the agent's to act on. A current server
1490
+ * sends `ready` on every open finding: it is the agent's unless the person
1491
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
1492
+ * an older server, means it waits on the person: show it to the user and
1493
+ * change nothing unless they say so. Present only on an open Mossbear
1494
+ * comment. A server that predates the field omits it, and a reader then
1495
+ * falls back to `approved`. This is a new name rather than a new meaning for
1496
+ * `state`, which already says open or resolved.
1467
1497
  */
1468
1498
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
1469
1499
  /**
@@ -1726,6 +1756,17 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
1726
1756
  readonly start: v.NumberSchema<undefined>;
1727
1757
  readonly end: v.NumberSchema<undefined>;
1728
1758
  }, undefined>, undefined>;
1759
+ /**
1760
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
1761
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
1762
+ * the passage has no source lines, so an agent can find a block the
1763
+ * page's script built.
1764
+ */
1765
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
1766
+ readonly selector: v.StringSchema<undefined>;
1767
+ readonly tag: v.StringSchema<undefined>;
1768
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
1769
+ }, undefined>, undefined>;
1729
1770
  }, undefined>, undefined>;
1730
1771
  /** The comment's text, already wrapped in the response's untrusted markers. */
1731
1772
  readonly body: v.StringSchema<undefined>;
@@ -1744,22 +1785,26 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
1744
1785
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1745
1786
  }, undefined>, undefined>;
1746
1787
  /**
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.
1788
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
1789
+ * hands one over any more, so a current server sends `false` on every Mossbear
1790
+ * comment and omits it on a person's or an agent's; the field stays for
1791
+ * readers that predate `findingState`. It does not say whether the agent may
1792
+ * act: read `findingState` for that, and fall back to `approved: false`
1793
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
1794
+ * that predates it. Only a client that reports a version able to mark drafts
1795
+ * is listed a finding at all, so an older reader that strips this field never
1796
+ * receives one it would misread.
1753
1797
  */
1754
1798
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
1755
1799
  /**
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.
1800
+ * Whether an open Mossbear finding is the agent's to act on. A current server
1801
+ * sends `ready` on every open finding: it is the agent's unless the person
1802
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
1803
+ * an older server, means it waits on the person: show it to the user and
1804
+ * change nothing unless they say so. Present only on an open Mossbear
1805
+ * comment. A server that predates the field omits it, and a reader then
1806
+ * falls back to `approved`. This is a new name rather than a new meaning for
1807
+ * `state`, which already says open or resolved.
1763
1808
  */
1764
1809
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
1765
1810
  /**
@@ -1853,6 +1898,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
1853
1898
  start: number;
1854
1899
  end: number;
1855
1900
  } | null;
1901
+ element?: {
1902
+ selector: string;
1903
+ tag: string;
1904
+ label?: string | undefined;
1905
+ } | undefined;
1856
1906
  } | undefined;
1857
1907
  body: string;
1858
1908
  finding?: {
@@ -2007,6 +2057,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
2007
2057
  start: number;
2008
2058
  end: number;
2009
2059
  } | null;
2060
+ element?: {
2061
+ selector: string;
2062
+ tag: string;
2063
+ label?: string | undefined;
2064
+ } | undefined;
2010
2065
  } | undefined;
2011
2066
  body: string;
2012
2067
  finding?: {
@@ -2084,6 +2139,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
2084
2139
  start: number;
2085
2140
  end: number;
2086
2141
  } | null;
2142
+ element?: {
2143
+ selector: string;
2144
+ tag: string;
2145
+ label?: string | undefined;
2146
+ } | undefined;
2087
2147
  } | undefined;
2088
2148
  body: string;
2089
2149
  finding?: {
@@ -2246,6 +2306,17 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2246
2306
  readonly start: v.NumberSchema<undefined>;
2247
2307
  readonly end: v.NumberSchema<undefined>;
2248
2308
  }, undefined>, undefined>;
2309
+ /**
2310
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
2311
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
2312
+ * the passage has no source lines, so an agent can find a block the
2313
+ * page's script built.
2314
+ */
2315
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
2316
+ readonly selector: v.StringSchema<undefined>;
2317
+ readonly tag: v.StringSchema<undefined>;
2318
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
2319
+ }, undefined>, undefined>;
2249
2320
  }, undefined>, undefined>;
2250
2321
  /** The comment's text, already wrapped in the response's untrusted markers. */
2251
2322
  readonly body: v.StringSchema<undefined>;
@@ -2264,22 +2335,26 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2264
2335
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
2265
2336
  }, undefined>, undefined>;
2266
2337
  /**
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.
2338
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
2339
+ * hands one over any more, so a current server sends `false` on every Mossbear
2340
+ * comment and omits it on a person's or an agent's; the field stays for
2341
+ * readers that predate `findingState`. It does not say whether the agent may
2342
+ * act: read `findingState` for that, and fall back to `approved: false`
2343
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
2344
+ * that predates it. Only a client that reports a version able to mark drafts
2345
+ * is listed a finding at all, so an older reader that strips this field never
2346
+ * receives one it would misread.
2273
2347
  */
2274
2348
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
2275
2349
  /**
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.
2350
+ * Whether an open Mossbear finding is the agent's to act on. A current server
2351
+ * sends `ready` on every open finding: it is the agent's unless the person
2352
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
2353
+ * an older server, means it waits on the person: show it to the user and
2354
+ * change nothing unless they say so. Present only on an open Mossbear
2355
+ * comment. A server that predates the field omits it, and a reader then
2356
+ * falls back to `approved`. This is a new name rather than a new meaning for
2357
+ * `state`, which already says open or resolved.
2283
2358
  */
2284
2359
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
2285
2360
  /**
@@ -2373,6 +2448,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2373
2448
  start: number;
2374
2449
  end: number;
2375
2450
  } | null;
2451
+ element?: {
2452
+ selector: string;
2453
+ tag: string;
2454
+ label?: string | undefined;
2455
+ } | undefined;
2376
2456
  } | undefined;
2377
2457
  body: string;
2378
2458
  finding?: {
@@ -2527,6 +2607,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2527
2607
  start: number;
2528
2608
  end: number;
2529
2609
  } | null;
2610
+ element?: {
2611
+ selector: string;
2612
+ tag: string;
2613
+ label?: string | undefined;
2614
+ } | undefined;
2530
2615
  } | undefined;
2531
2616
  body: string;
2532
2617
  finding?: {
@@ -2604,6 +2689,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
2604
2689
  start: number;
2605
2690
  end: number;
2606
2691
  } | null;
2692
+ element?: {
2693
+ selector: string;
2694
+ tag: string;
2695
+ label?: string | undefined;
2696
+ } | undefined;
2607
2697
  } | undefined;
2608
2698
  body: string;
2609
2699
  finding?: {
@@ -2784,6 +2874,17 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
2784
2874
  readonly start: v.NumberSchema<undefined>;
2785
2875
  readonly end: v.NumberSchema<undefined>;
2786
2876
  }, undefined>, undefined>;
2877
+ /**
2878
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
2879
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
2880
+ * the passage has no source lines, so an agent can find a block the
2881
+ * page's script built.
2882
+ */
2883
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
2884
+ readonly selector: v.StringSchema<undefined>;
2885
+ readonly tag: v.StringSchema<undefined>;
2886
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
2887
+ }, undefined>, undefined>;
2787
2888
  }, undefined>, undefined>;
2788
2889
  /** The comment's text, already wrapped in the response's untrusted markers. */
2789
2890
  readonly body: v.StringSchema<undefined>;
@@ -2802,22 +2903,26 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
2802
2903
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
2803
2904
  }, undefined>, undefined>;
2804
2905
  /**
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.
2906
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
2907
+ * hands one over any more, so a current server sends `false` on every Mossbear
2908
+ * comment and omits it on a person's or an agent's; the field stays for
2909
+ * readers that predate `findingState`. It does not say whether the agent may
2910
+ * act: read `findingState` for that, and fall back to `approved: false`
2911
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
2912
+ * that predates it. Only a client that reports a version able to mark drafts
2913
+ * is listed a finding at all, so an older reader that strips this field never
2914
+ * receives one it would misread.
2811
2915
  */
2812
2916
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
2813
2917
  /**
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.
2918
+ * Whether an open Mossbear finding is the agent's to act on. A current server
2919
+ * sends `ready` on every open finding: it is the agent's unless the person
2920
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
2921
+ * an older server, means it waits on the person: show it to the user and
2922
+ * change nothing unless they say so. Present only on an open Mossbear
2923
+ * comment. A server that predates the field omits it, and a reader then
2924
+ * falls back to `approved`. This is a new name rather than a new meaning for
2925
+ * `state`, which already says open or resolved.
2821
2926
  */
2822
2927
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
2823
2928
  /**
@@ -2911,6 +3016,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
2911
3016
  start: number;
2912
3017
  end: number;
2913
3018
  } | null;
3019
+ element?: {
3020
+ selector: string;
3021
+ tag: string;
3022
+ label?: string | undefined;
3023
+ } | undefined;
2914
3024
  } | undefined;
2915
3025
  body: string;
2916
3026
  finding?: {
@@ -3065,6 +3175,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
3065
3175
  start: number;
3066
3176
  end: number;
3067
3177
  } | null;
3178
+ element?: {
3179
+ selector: string;
3180
+ tag: string;
3181
+ label?: string | undefined;
3182
+ } | undefined;
3068
3183
  } | undefined;
3069
3184
  body: string;
3070
3185
  finding?: {
@@ -3142,6 +3257,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
3142
3257
  start: number;
3143
3258
  end: number;
3144
3259
  } | null;
3260
+ element?: {
3261
+ selector: string;
3262
+ tag: string;
3263
+ label?: string | undefined;
3264
+ } | undefined;
3145
3265
  } | undefined;
3146
3266
  body: string;
3147
3267
  finding?: {
@@ -3385,6 +3505,110 @@ export declare const AgentCommentRequestSchema: v.ObjectSchema<{
3385
3505
  readonly bundleIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
3386
3506
  }, undefined>;
3387
3507
  export type AgentCommentRequest = v.InferOutput<typeof AgentCommentRequestSchema>;
3508
+ /** A batch may cover findings across several guides without one write per finding. */
3509
+ export declare const MAX_FINDING_DISMISSALS_PER_REQUEST = 100;
3510
+ export declare const FindingDismissalInputSchema: v.ObjectSchema<{
3511
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3512
+ readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000, undefined>, v.CheckAction<string, "Use one line for the reason.">]>;
3513
+ }, undefined>;
3514
+ export declare const FindingDismissalInputsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
3515
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3516
+ readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000, undefined>, v.CheckAction<string, "Use one line for the reason.">]>;
3517
+ }, undefined>, undefined>, v.MinLengthAction<{
3518
+ id: string;
3519
+ reason: string;
3520
+ }[], 1, undefined>, v.MaxLengthAction<{
3521
+ id: string;
3522
+ reason: string;
3523
+ }[], 100, undefined>, v.CheckAction<{
3524
+ id: string;
3525
+ reason: string;
3526
+ }[], "Name each finding only once.">]>;
3527
+ export declare const SuggestFindingDismissalsRequestSchema: v.ObjectSchema<{
3528
+ readonly suggestions: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
3529
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3530
+ readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000, undefined>, v.CheckAction<string, "Use one line for the reason.">]>;
3531
+ }, undefined>, undefined>, v.MinLengthAction<{
3532
+ id: string;
3533
+ reason: string;
3534
+ }[], 1, undefined>, v.MaxLengthAction<{
3535
+ id: string;
3536
+ reason: string;
3537
+ }[], 100, undefined>, v.CheckAction<{
3538
+ id: string;
3539
+ reason: string;
3540
+ }[], "Name each finding only once.">]>;
3541
+ readonly agent: v.ObjectSchema<{
3542
+ readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3543
+ readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
3544
+ /** The agent's own statement of its model, when it knows it. */
3545
+ readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
3546
+ readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
3547
+ }, undefined>;
3548
+ }, undefined>;
3549
+ export type SuggestFindingDismissalsRequest = v.InferOutput<typeof SuggestFindingDismissalsRequestSchema>;
3550
+ /** Recommendations are separate from the finding's open/resolved state. */
3551
+ export declare const FindingDismissalSuggestionSchema: v.ObjectSchema<{
3552
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3553
+ readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3554
+ readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3555
+ readonly agent: v.ObjectSchema<{
3556
+ readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3557
+ readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
3558
+ /** The agent's own statement of its model, when it knows it. */
3559
+ readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
3560
+ readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
3561
+ }, undefined>;
3562
+ readonly guideVersion: v.NumberSchema<undefined>;
3563
+ readonly createdAt: v.StringSchema<undefined>;
3564
+ }, undefined>;
3565
+ export type FindingDismissalSuggestion = v.InferOutput<typeof FindingDismissalSuggestionSchema>;
3566
+ export declare const SuggestFindingDismissalsResponseSchema: v.ObjectSchema<{
3567
+ readonly results: v.ArraySchema<v.ObjectSchema<{
3568
+ readonly suggestion: v.ObjectSchema<{
3569
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3570
+ readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3571
+ readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3572
+ readonly agent: v.ObjectSchema<{
3573
+ readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3574
+ readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
3575
+ /** The agent's own statement of its model, when it knows it. */
3576
+ readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
3577
+ readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
3578
+ }, undefined>;
3579
+ readonly guideVersion: v.NumberSchema<undefined>;
3580
+ readonly createdAt: v.StringSchema<undefined>;
3581
+ }, undefined>;
3582
+ readonly created: v.BooleanSchema<undefined>;
3583
+ readonly valid: v.BooleanSchema<undefined>;
3584
+ }, undefined>, undefined>;
3585
+ }, undefined>;
3586
+ export type SuggestFindingDismissalsResponse = v.InferOutput<typeof SuggestFindingDismissalsResponseSchema>;
3587
+ export declare const FindingDismissalSuggestionsCursorSchema: v.ObjectSchema<{
3588
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3589
+ readonly createdAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
3590
+ }, undefined>;
3591
+ export type FindingDismissalSuggestionsCursor = v.InferOutput<typeof FindingDismissalSuggestionsCursorSchema>;
3592
+ export declare const FindingDismissalSuggestionsResponseSchema: v.ObjectSchema<{
3593
+ readonly suggestions: v.ArraySchema<v.ObjectSchema<{
3594
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3595
+ readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3596
+ readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
3597
+ readonly agent: v.ObjectSchema<{
3598
+ readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3599
+ readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
3600
+ /** The agent's own statement of its model, when it knows it. */
3601
+ readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
3602
+ readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
3603
+ }, undefined>;
3604
+ readonly guideVersion: v.NumberSchema<undefined>;
3605
+ readonly createdAt: v.StringSchema<undefined>;
3606
+ }, undefined>, undefined>;
3607
+ readonly nextCursor: v.NullableSchema<v.ObjectSchema<{
3608
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
3609
+ readonly createdAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
3610
+ }, undefined>, undefined>;
3611
+ }, undefined>;
3388
3612
  /**
3389
3613
  * The comment a create settled on. `created` is false when this agent session
3390
3614
  * already had a whole-subject comment on the subject: that comment comes back
@@ -3428,6 +3652,17 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
3428
3652
  readonly start: v.NumberSchema<undefined>;
3429
3653
  readonly end: v.NumberSchema<undefined>;
3430
3654
  }, undefined>, undefined>;
3655
+ /**
3656
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
3657
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
3658
+ * the passage has no source lines, so an agent can find a block the
3659
+ * page's script built.
3660
+ */
3661
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
3662
+ readonly selector: v.StringSchema<undefined>;
3663
+ readonly tag: v.StringSchema<undefined>;
3664
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
3665
+ }, undefined>, undefined>;
3431
3666
  }, undefined>, undefined>;
3432
3667
  /** The comment's text, already wrapped in the response's untrusted markers. */
3433
3668
  readonly body: v.StringSchema<undefined>;
@@ -3446,22 +3681,26 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
3446
3681
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
3447
3682
  }, undefined>, undefined>;
3448
3683
  /**
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.
3684
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
3685
+ * hands one over any more, so a current server sends `false` on every Mossbear
3686
+ * comment and omits it on a person's or an agent's; the field stays for
3687
+ * readers that predate `findingState`. It does not say whether the agent may
3688
+ * act: read `findingState` for that, and fall back to `approved: false`
3689
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
3690
+ * that predates it. Only a client that reports a version able to mark drafts
3691
+ * is listed a finding at all, so an older reader that strips this field never
3692
+ * receives one it would misread.
3455
3693
  */
3456
3694
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
3457
3695
  /**
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.
3696
+ * Whether an open Mossbear finding is the agent's to act on. A current server
3697
+ * sends `ready` on every open finding: it is the agent's unless the person
3698
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
3699
+ * an older server, means it waits on the person: show it to the user and
3700
+ * change nothing unless they say so. Present only on an open Mossbear
3701
+ * comment. A server that predates the field omits it, and a reader then
3702
+ * falls back to `approved`. This is a new name rather than a new meaning for
3703
+ * `state`, which already says open or resolved.
3465
3704
  */
3466
3705
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
3467
3706
  /**
@@ -3575,6 +3814,17 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
3575
3814
  readonly start: v.NumberSchema<undefined>;
3576
3815
  readonly end: v.NumberSchema<undefined>;
3577
3816
  }, undefined>, undefined>;
3817
+ /**
3818
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
3819
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
3820
+ * the passage has no source lines, so an agent can find a block the
3821
+ * page's script built.
3822
+ */
3823
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
3824
+ readonly selector: v.StringSchema<undefined>;
3825
+ readonly tag: v.StringSchema<undefined>;
3826
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
3827
+ }, undefined>, undefined>;
3578
3828
  }, undefined>, undefined>;
3579
3829
  /** The comment's text, already wrapped in the response's untrusted markers. */
3580
3830
  readonly body: v.StringSchema<undefined>;
@@ -3593,22 +3843,26 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
3593
3843
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
3594
3844
  }, undefined>, undefined>;
3595
3845
  /**
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.
3846
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
3847
+ * hands one over any more, so a current server sends `false` on every Mossbear
3848
+ * comment and omits it on a person's or an agent's; the field stays for
3849
+ * readers that predate `findingState`. It does not say whether the agent may
3850
+ * act: read `findingState` for that, and fall back to `approved: false`
3851
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
3852
+ * that predates it. Only a client that reports a version able to mark drafts
3853
+ * is listed a finding at all, so an older reader that strips this field never
3854
+ * receives one it would misread.
3602
3855
  */
3603
3856
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
3604
3857
  /**
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.
3858
+ * Whether an open Mossbear finding is the agent's to act on. A current server
3859
+ * sends `ready` on every open finding: it is the agent's unless the person
3860
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
3861
+ * an older server, means it waits on the person: show it to the user and
3862
+ * change nothing unless they say so. Present only on an open Mossbear
3863
+ * comment. A server that predates the field omits it, and a reader then
3864
+ * falls back to `approved`. This is a new name rather than a new meaning for
3865
+ * `state`, which already says open or resolved.
3612
3866
  */
3613
3867
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
3614
3868
  /**
@@ -4319,6 +4573,17 @@ export declare const ArtifactSchema: v.ObjectSchema<{
4319
4573
  readonly start: v.NumberSchema<undefined>;
4320
4574
  readonly end: v.NumberSchema<undefined>;
4321
4575
  }, undefined>, undefined>;
4576
+ /**
4577
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
4578
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
4579
+ * the passage has no source lines, so an agent can find a block the
4580
+ * page's script built.
4581
+ */
4582
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
4583
+ readonly selector: v.StringSchema<undefined>;
4584
+ readonly tag: v.StringSchema<undefined>;
4585
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
4586
+ }, undefined>, undefined>;
4322
4587
  }, undefined>, undefined>;
4323
4588
  /** The comment's text, already wrapped in the response's untrusted markers. */
4324
4589
  readonly body: v.StringSchema<undefined>;
@@ -4337,22 +4602,26 @@ export declare const ArtifactSchema: v.ObjectSchema<{
4337
4602
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
4338
4603
  }, undefined>, undefined>;
4339
4604
  /**
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.
4605
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
4606
+ * hands one over any more, so a current server sends `false` on every Mossbear
4607
+ * comment and omits it on a person's or an agent's; the field stays for
4608
+ * readers that predate `findingState`. It does not say whether the agent may
4609
+ * act: read `findingState` for that, and fall back to `approved: false`
4610
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
4611
+ * that predates it. Only a client that reports a version able to mark drafts
4612
+ * is listed a finding at all, so an older reader that strips this field never
4613
+ * receives one it would misread.
4346
4614
  */
4347
4615
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
4348
4616
  /**
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.
4617
+ * Whether an open Mossbear finding is the agent's to act on. A current server
4618
+ * sends `ready` on every open finding: it is the agent's unless the person
4619
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
4620
+ * an older server, means it waits on the person: show it to the user and
4621
+ * change nothing unless they say so. Present only on an open Mossbear
4622
+ * comment. A server that predates the field omits it, and a reader then
4623
+ * falls back to `approved`. This is a new name rather than a new meaning for
4624
+ * `state`, which already says open or resolved.
4356
4625
  */
4357
4626
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
4358
4627
  /**
@@ -4446,6 +4715,11 @@ export declare const ArtifactSchema: v.ObjectSchema<{
4446
4715
  start: number;
4447
4716
  end: number;
4448
4717
  } | null;
4718
+ element?: {
4719
+ selector: string;
4720
+ tag: string;
4721
+ label?: string | undefined;
4722
+ } | undefined;
4449
4723
  } | undefined;
4450
4724
  body: string;
4451
4725
  finding?: {
@@ -4559,6 +4833,17 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
4559
4833
  readonly start: v.NumberSchema<undefined>;
4560
4834
  readonly end: v.NumberSchema<undefined>;
4561
4835
  }, undefined>, undefined>;
4836
+ /**
4837
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
4838
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
4839
+ * the passage has no source lines, so an agent can find a block the
4840
+ * page's script built.
4841
+ */
4842
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
4843
+ readonly selector: v.StringSchema<undefined>;
4844
+ readonly tag: v.StringSchema<undefined>;
4845
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
4846
+ }, undefined>, undefined>;
4562
4847
  }, undefined>, undefined>;
4563
4848
  /** The comment's text, already wrapped in the response's untrusted markers. */
4564
4849
  readonly body: v.StringSchema<undefined>;
@@ -4577,22 +4862,26 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
4577
4862
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
4578
4863
  }, undefined>, undefined>;
4579
4864
  /**
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.
4865
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
4866
+ * hands one over any more, so a current server sends `false` on every Mossbear
4867
+ * comment and omits it on a person's or an agent's; the field stays for
4868
+ * readers that predate `findingState`. It does not say whether the agent may
4869
+ * act: read `findingState` for that, and fall back to `approved: false`
4870
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
4871
+ * that predates it. Only a client that reports a version able to mark drafts
4872
+ * is listed a finding at all, so an older reader that strips this field never
4873
+ * receives one it would misread.
4586
4874
  */
4587
4875
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
4588
4876
  /**
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.
4877
+ * Whether an open Mossbear finding is the agent's to act on. A current server
4878
+ * sends `ready` on every open finding: it is the agent's unless the person
4879
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
4880
+ * an older server, means it waits on the person: show it to the user and
4881
+ * change nothing unless they say so. Present only on an open Mossbear
4882
+ * comment. A server that predates the field omits it, and a reader then
4883
+ * falls back to `approved`. This is a new name rather than a new meaning for
4884
+ * `state`, which already says open or resolved.
4596
4885
  */
4597
4886
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
4598
4887
  /**
@@ -4686,6 +4975,11 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
4686
4975
  start: number;
4687
4976
  end: number;
4688
4977
  } | null;
4978
+ element?: {
4979
+ selector: string;
4980
+ tag: string;
4981
+ label?: string | undefined;
4982
+ } | undefined;
4689
4983
  } | undefined;
4690
4984
  body: string;
4691
4985
  finding?: {
@@ -5576,6 +5870,17 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
5576
5870
  readonly start: v.NumberSchema<undefined>;
5577
5871
  readonly end: v.NumberSchema<undefined>;
5578
5872
  }, undefined>, undefined>;
5873
+ /**
5874
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
5875
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
5876
+ * the passage has no source lines, so an agent can find a block the
5877
+ * page's script built.
5878
+ */
5879
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
5880
+ readonly selector: v.StringSchema<undefined>;
5881
+ readonly tag: v.StringSchema<undefined>;
5882
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
5883
+ }, undefined>, undefined>;
5579
5884
  }, undefined>, undefined>;
5580
5885
  /** The comment's text, already wrapped in the response's untrusted markers. */
5581
5886
  readonly body: v.StringSchema<undefined>;
@@ -5594,22 +5899,26 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
5594
5899
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
5595
5900
  }, undefined>, undefined>;
5596
5901
  /**
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.
5902
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
5903
+ * hands one over any more, so a current server sends `false` on every Mossbear
5904
+ * comment and omits it on a person's or an agent's; the field stays for
5905
+ * readers that predate `findingState`. It does not say whether the agent may
5906
+ * act: read `findingState` for that, and fall back to `approved: false`
5907
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
5908
+ * that predates it. Only a client that reports a version able to mark drafts
5909
+ * is listed a finding at all, so an older reader that strips this field never
5910
+ * receives one it would misread.
5603
5911
  */
5604
5912
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
5605
5913
  /**
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.
5914
+ * Whether an open Mossbear finding is the agent's to act on. A current server
5915
+ * sends `ready` on every open finding: it is the agent's unless the person
5916
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
5917
+ * an older server, means it waits on the person: show it to the user and
5918
+ * change nothing unless they say so. Present only on an open Mossbear
5919
+ * comment. A server that predates the field omits it, and a reader then
5920
+ * falls back to `approved`. This is a new name rather than a new meaning for
5921
+ * `state`, which already says open or resolved.
5613
5922
  */
5614
5923
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
5615
5924
  /**
@@ -5703,6 +6012,11 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
5703
6012
  start: number;
5704
6013
  end: number;
5705
6014
  } | null;
6015
+ element?: {
6016
+ selector: string;
6017
+ tag: string;
6018
+ label?: string | undefined;
6019
+ } | undefined;
5706
6020
  } | undefined;
5707
6021
  body: string;
5708
6022
  finding?: {
@@ -5855,6 +6169,17 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
5855
6169
  readonly start: v.NumberSchema<undefined>;
5856
6170
  readonly end: v.NumberSchema<undefined>;
5857
6171
  }, undefined>, undefined>;
6172
+ /**
6173
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
6174
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
6175
+ * the passage has no source lines, so an agent can find a block the
6176
+ * page's script built.
6177
+ */
6178
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
6179
+ readonly selector: v.StringSchema<undefined>;
6180
+ readonly tag: v.StringSchema<undefined>;
6181
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
6182
+ }, undefined>, undefined>;
5858
6183
  }, undefined>, undefined>;
5859
6184
  /** The comment's text, already wrapped in the response's untrusted markers. */
5860
6185
  readonly body: v.StringSchema<undefined>;
@@ -5873,22 +6198,26 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
5873
6198
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
5874
6199
  }, undefined>, undefined>;
5875
6200
  /**
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.
6201
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
6202
+ * hands one over any more, so a current server sends `false` on every Mossbear
6203
+ * comment and omits it on a person's or an agent's; the field stays for
6204
+ * readers that predate `findingState`. It does not say whether the agent may
6205
+ * act: read `findingState` for that, and fall back to `approved: false`
6206
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
6207
+ * that predates it. Only a client that reports a version able to mark drafts
6208
+ * is listed a finding at all, so an older reader that strips this field never
6209
+ * receives one it would misread.
5882
6210
  */
5883
6211
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
5884
6212
  /**
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.
6213
+ * Whether an open Mossbear finding is the agent's to act on. A current server
6214
+ * sends `ready` on every open finding: it is the agent's unless the person
6215
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
6216
+ * an older server, means it waits on the person: show it to the user and
6217
+ * change nothing unless they say so. Present only on an open Mossbear
6218
+ * comment. A server that predates the field omits it, and a reader then
6219
+ * falls back to `approved`. This is a new name rather than a new meaning for
6220
+ * `state`, which already says open or resolved.
5892
6221
  */
5893
6222
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
5894
6223
  /**
@@ -5982,6 +6311,11 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
5982
6311
  start: number;
5983
6312
  end: number;
5984
6313
  } | null;
6314
+ element?: {
6315
+ selector: string;
6316
+ tag: string;
6317
+ label?: string | undefined;
6318
+ } | undefined;
5985
6319
  } | undefined;
5986
6320
  body: string;
5987
6321
  finding?: {
@@ -6096,6 +6430,17 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
6096
6430
  readonly start: v.NumberSchema<undefined>;
6097
6431
  readonly end: v.NumberSchema<undefined>;
6098
6432
  }, undefined>, undefined>;
6433
+ /**
6434
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
6435
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
6436
+ * the passage has no source lines, so an agent can find a block the
6437
+ * page's script built.
6438
+ */
6439
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
6440
+ readonly selector: v.StringSchema<undefined>;
6441
+ readonly tag: v.StringSchema<undefined>;
6442
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
6443
+ }, undefined>, undefined>;
6099
6444
  }, undefined>, undefined>;
6100
6445
  /** The comment's text, already wrapped in the response's untrusted markers. */
6101
6446
  readonly body: v.StringSchema<undefined>;
@@ -6114,22 +6459,26 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
6114
6459
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
6115
6460
  }, undefined>, undefined>;
6116
6461
  /**
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.
6462
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
6463
+ * hands one over any more, so a current server sends `false` on every Mossbear
6464
+ * comment and omits it on a person's or an agent's; the field stays for
6465
+ * readers that predate `findingState`. It does not say whether the agent may
6466
+ * act: read `findingState` for that, and fall back to `approved: false`
6467
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
6468
+ * that predates it. Only a client that reports a version able to mark drafts
6469
+ * is listed a finding at all, so an older reader that strips this field never
6470
+ * receives one it would misread.
6123
6471
  */
6124
6472
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
6125
6473
  /**
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.
6474
+ * Whether an open Mossbear finding is the agent's to act on. A current server
6475
+ * sends `ready` on every open finding: it is the agent's unless the person
6476
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
6477
+ * an older server, means it waits on the person: show it to the user and
6478
+ * change nothing unless they say so. Present only on an open Mossbear
6479
+ * comment. A server that predates the field omits it, and a reader then
6480
+ * falls back to `approved`. This is a new name rather than a new meaning for
6481
+ * `state`, which already says open or resolved.
6133
6482
  */
6134
6483
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
6135
6484
  /**
@@ -6223,6 +6572,11 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
6223
6572
  start: number;
6224
6573
  end: number;
6225
6574
  } | null;
6575
+ element?: {
6576
+ selector: string;
6577
+ tag: string;
6578
+ label?: string | undefined;
6579
+ } | undefined;
6226
6580
  } | undefined;
6227
6581
  body: string;
6228
6582
  finding?: {
@@ -6403,6 +6757,17 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
6403
6757
  readonly start: v.NumberSchema<undefined>;
6404
6758
  readonly end: v.NumberSchema<undefined>;
6405
6759
  }, undefined>, undefined>;
6760
+ /**
6761
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
6762
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
6763
+ * the passage has no source lines, so an agent can find a block the
6764
+ * page's script built.
6765
+ */
6766
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
6767
+ readonly selector: v.StringSchema<undefined>;
6768
+ readonly tag: v.StringSchema<undefined>;
6769
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
6770
+ }, undefined>, undefined>;
6406
6771
  }, undefined>, undefined>;
6407
6772
  /** The comment's text, already wrapped in the response's untrusted markers. */
6408
6773
  readonly body: v.StringSchema<undefined>;
@@ -6421,22 +6786,26 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
6421
6786
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
6422
6787
  }, undefined>, undefined>;
6423
6788
  /**
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.
6789
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
6790
+ * hands one over any more, so a current server sends `false` on every Mossbear
6791
+ * comment and omits it on a person's or an agent's; the field stays for
6792
+ * readers that predate `findingState`. It does not say whether the agent may
6793
+ * act: read `findingState` for that, and fall back to `approved: false`
6794
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
6795
+ * that predates it. Only a client that reports a version able to mark drafts
6796
+ * is listed a finding at all, so an older reader that strips this field never
6797
+ * receives one it would misread.
6430
6798
  */
6431
6799
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
6432
6800
  /**
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.
6801
+ * Whether an open Mossbear finding is the agent's to act on. A current server
6802
+ * sends `ready` on every open finding: it is the agent's unless the person
6803
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
6804
+ * an older server, means it waits on the person: show it to the user and
6805
+ * change nothing unless they say so. Present only on an open Mossbear
6806
+ * comment. A server that predates the field omits it, and a reader then
6807
+ * falls back to `approved`. This is a new name rather than a new meaning for
6808
+ * `state`, which already says open or resolved.
6440
6809
  */
6441
6810
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
6442
6811
  /**
@@ -6530,6 +6899,11 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
6530
6899
  start: number;
6531
6900
  end: number;
6532
6901
  } | null;
6902
+ element?: {
6903
+ selector: string;
6904
+ tag: string;
6905
+ label?: string | undefined;
6906
+ } | undefined;
6533
6907
  } | undefined;
6534
6908
  body: string;
6535
6909
  finding?: {
@@ -6654,6 +7028,17 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
6654
7028
  readonly start: v.NumberSchema<undefined>;
6655
7029
  readonly end: v.NumberSchema<undefined>;
6656
7030
  }, undefined>, undefined>;
7031
+ /**
7032
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
7033
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
7034
+ * the passage has no source lines, so an agent can find a block the
7035
+ * page's script built.
7036
+ */
7037
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
7038
+ readonly selector: v.StringSchema<undefined>;
7039
+ readonly tag: v.StringSchema<undefined>;
7040
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7041
+ }, undefined>, undefined>;
6657
7042
  }, undefined>, undefined>;
6658
7043
  /** The comment's text, already wrapped in the response's untrusted markers. */
6659
7044
  readonly body: v.StringSchema<undefined>;
@@ -6672,22 +7057,26 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
6672
7057
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
6673
7058
  }, undefined>, undefined>;
6674
7059
  /**
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.
7060
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
7061
+ * hands one over any more, so a current server sends `false` on every Mossbear
7062
+ * comment and omits it on a person's or an agent's; the field stays for
7063
+ * readers that predate `findingState`. It does not say whether the agent may
7064
+ * act: read `findingState` for that, and fall back to `approved: false`
7065
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
7066
+ * that predates it. Only a client that reports a version able to mark drafts
7067
+ * is listed a finding at all, so an older reader that strips this field never
7068
+ * receives one it would misread.
6681
7069
  */
6682
7070
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
6683
7071
  /**
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.
7072
+ * Whether an open Mossbear finding is the agent's to act on. A current server
7073
+ * sends `ready` on every open finding: it is the agent's unless the person
7074
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
7075
+ * an older server, means it waits on the person: show it to the user and
7076
+ * change nothing unless they say so. Present only on an open Mossbear
7077
+ * comment. A server that predates the field omits it, and a reader then
7078
+ * falls back to `approved`. This is a new name rather than a new meaning for
7079
+ * `state`, which already says open or resolved.
6691
7080
  */
6692
7081
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
6693
7082
  /**
@@ -6781,6 +7170,11 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
6781
7170
  start: number;
6782
7171
  end: number;
6783
7172
  } | null;
7173
+ element?: {
7174
+ selector: string;
7175
+ tag: string;
7176
+ label?: string | undefined;
7177
+ } | undefined;
6784
7178
  } | undefined;
6785
7179
  body: string;
6786
7180
  finding?: {
@@ -7067,6 +7461,17 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
7067
7461
  readonly start: v.NumberSchema<undefined>;
7068
7462
  readonly end: v.NumberSchema<undefined>;
7069
7463
  }, undefined>, undefined>;
7464
+ /**
7465
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
7466
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
7467
+ * the passage has no source lines, so an agent can find a block the
7468
+ * page's script built.
7469
+ */
7470
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
7471
+ readonly selector: v.StringSchema<undefined>;
7472
+ readonly tag: v.StringSchema<undefined>;
7473
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7474
+ }, undefined>, undefined>;
7070
7475
  }, undefined>, undefined>;
7071
7476
  /** The comment's text, already wrapped in the response's untrusted markers. */
7072
7477
  readonly body: v.StringSchema<undefined>;
@@ -7085,22 +7490,26 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
7085
7490
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
7086
7491
  }, undefined>, undefined>;
7087
7492
  /**
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.
7493
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
7494
+ * hands one over any more, so a current server sends `false` on every Mossbear
7495
+ * comment and omits it on a person's or an agent's; the field stays for
7496
+ * readers that predate `findingState`. It does not say whether the agent may
7497
+ * act: read `findingState` for that, and fall back to `approved: false`
7498
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
7499
+ * that predates it. Only a client that reports a version able to mark drafts
7500
+ * is listed a finding at all, so an older reader that strips this field never
7501
+ * receives one it would misread.
7094
7502
  */
7095
7503
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
7096
7504
  /**
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.
7505
+ * Whether an open Mossbear finding is the agent's to act on. A current server
7506
+ * sends `ready` on every open finding: it is the agent's unless the person
7507
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
7508
+ * an older server, means it waits on the person: show it to the user and
7509
+ * change nothing unless they say so. Present only on an open Mossbear
7510
+ * comment. A server that predates the field omits it, and a reader then
7511
+ * falls back to `approved`. This is a new name rather than a new meaning for
7512
+ * `state`, which already says open or resolved.
7104
7513
  */
7105
7514
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
7106
7515
  /**
@@ -7194,6 +7603,11 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
7194
7603
  start: number;
7195
7604
  end: number;
7196
7605
  } | null;
7606
+ element?: {
7607
+ selector: string;
7608
+ tag: string;
7609
+ label?: string | undefined;
7610
+ } | undefined;
7197
7611
  } | undefined;
7198
7612
  body: string;
7199
7613
  finding?: {
@@ -7310,6 +7724,17 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
7310
7724
  readonly start: v.NumberSchema<undefined>;
7311
7725
  readonly end: v.NumberSchema<undefined>;
7312
7726
  }, undefined>, undefined>;
7727
+ /**
7728
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
7729
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
7730
+ * the passage has no source lines, so an agent can find a block the
7731
+ * page's script built.
7732
+ */
7733
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
7734
+ readonly selector: v.StringSchema<undefined>;
7735
+ readonly tag: v.StringSchema<undefined>;
7736
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7737
+ }, undefined>, undefined>;
7313
7738
  }, undefined>, undefined>;
7314
7739
  /** The comment's text, already wrapped in the response's untrusted markers. */
7315
7740
  readonly body: v.StringSchema<undefined>;
@@ -7328,22 +7753,26 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
7328
7753
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
7329
7754
  }, undefined>, undefined>;
7330
7755
  /**
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.
7756
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
7757
+ * hands one over any more, so a current server sends `false` on every Mossbear
7758
+ * comment and omits it on a person's or an agent's; the field stays for
7759
+ * readers that predate `findingState`. It does not say whether the agent may
7760
+ * act: read `findingState` for that, and fall back to `approved: false`
7761
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
7762
+ * that predates it. Only a client that reports a version able to mark drafts
7763
+ * is listed a finding at all, so an older reader that strips this field never
7764
+ * receives one it would misread.
7337
7765
  */
7338
7766
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
7339
7767
  /**
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.
7768
+ * Whether an open Mossbear finding is the agent's to act on. A current server
7769
+ * sends `ready` on every open finding: it is the agent's unless the person
7770
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
7771
+ * an older server, means it waits on the person: show it to the user and
7772
+ * change nothing unless they say so. Present only on an open Mossbear
7773
+ * comment. A server that predates the field omits it, and a reader then
7774
+ * falls back to `approved`. This is a new name rather than a new meaning for
7775
+ * `state`, which already says open or resolved.
7347
7776
  */
7348
7777
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
7349
7778
  /**
@@ -7437,6 +7866,11 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
7437
7866
  start: number;
7438
7867
  end: number;
7439
7868
  } | null;
7869
+ element?: {
7870
+ selector: string;
7871
+ tag: string;
7872
+ label?: string | undefined;
7873
+ } | undefined;
7440
7874
  } | undefined;
7441
7875
  body: string;
7442
7876
  finding?: {
@@ -7552,6 +7986,17 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
7552
7986
  readonly start: v.NumberSchema<undefined>;
7553
7987
  readonly end: v.NumberSchema<undefined>;
7554
7988
  }, undefined>, undefined>;
7989
+ /**
7990
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
7991
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
7992
+ * the passage has no source lines, so an agent can find a block the
7993
+ * page's script built.
7994
+ */
7995
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
7996
+ readonly selector: v.StringSchema<undefined>;
7997
+ readonly tag: v.StringSchema<undefined>;
7998
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
7999
+ }, undefined>, undefined>;
7555
8000
  }, undefined>, undefined>;
7556
8001
  /** The comment's text, already wrapped in the response's untrusted markers. */
7557
8002
  readonly body: v.StringSchema<undefined>;
@@ -7570,22 +8015,26 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
7570
8015
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
7571
8016
  }, undefined>, undefined>;
7572
8017
  /**
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.
8018
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
8019
+ * hands one over any more, so a current server sends `false` on every Mossbear
8020
+ * comment and omits it on a person's or an agent's; the field stays for
8021
+ * readers that predate `findingState`. It does not say whether the agent may
8022
+ * act: read `findingState` for that, and fall back to `approved: false`
8023
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
8024
+ * that predates it. Only a client that reports a version able to mark drafts
8025
+ * is listed a finding at all, so an older reader that strips this field never
8026
+ * receives one it would misread.
7579
8027
  */
7580
8028
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
7581
8029
  /**
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.
8030
+ * Whether an open Mossbear finding is the agent's to act on. A current server
8031
+ * sends `ready` on every open finding: it is the agent's unless the person
8032
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
8033
+ * an older server, means it waits on the person: show it to the user and
8034
+ * change nothing unless they say so. Present only on an open Mossbear
8035
+ * comment. A server that predates the field omits it, and a reader then
8036
+ * falls back to `approved`. This is a new name rather than a new meaning for
8037
+ * `state`, which already says open or resolved.
7589
8038
  */
7590
8039
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
7591
8040
  /**
@@ -7679,6 +8128,11 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
7679
8128
  start: number;
7680
8129
  end: number;
7681
8130
  } | null;
8131
+ element?: {
8132
+ selector: string;
8133
+ tag: string;
8134
+ label?: string | undefined;
8135
+ } | undefined;
7682
8136
  } | undefined;
7683
8137
  body: string;
7684
8138
  finding?: {
@@ -8285,7 +8739,7 @@ export declare const MAX_RULE_MANIFEST_FILES = 500;
8285
8739
  * A rule file observed on disk in the repo `mossbear report` ran from.
8286
8740
  *
8287
8741
  * `path` is relative to that repo root, in exactly the form `payloadPath`
8288
- * takes at import time (`packages/cli/src/rules/discover.ts`), so
8742
+ * takes at import time (`packages/cli/src/guides/discover.ts`), so
8289
8743
  * `file:{format}:{path}` reconstructs the `origin` the dashboard stored for
8290
8744
  * the guide this file produced. That reconstruction is the whole join; nothing
8291
8745
  * else about the file is needed and nothing else is sent.
@@ -8311,7 +8765,7 @@ export declare const RuleManifestFileSchema: v.ObjectSchema<{
8311
8765
  * same account distinguishable, which is the half of review finding 5 that
8312
8766
  * repo-root-relative origins cannot express: two repos each holding
8313
8767
  * `.claude/skills/review` produce byte-identical origins by construction. See
8314
- * `repoIdFromRoot` (`packages/cli/src/rules/manifest.ts`) for how it is
8768
+ * `repoIdFromRoot` (`packages/cli/src/guides/manifest.ts`) for how it is
8315
8769
  * derived and why that derivation is privacy-safe.
8316
8770
  */
8317
8771
  export declare const RuleFileManifestSchema: v.ObjectSchema<{
@@ -9005,7 +9459,7 @@ export declare const GuideHistoryIdentifierSchema: v.SchemaWithPipe<readonly [v.
9005
9459
  *
9006
9460
  * `root` is optional and is the disambiguator, not decoration: `.claude/skills`
9007
9461
  * is scanned under **both** discovery roots
9008
- * (`packages/cli/src/rules/discover.ts:101,105`), so a project skill and its
9462
+ * (`packages/cli/src/guides/discover.ts`), so a project skill and its
9009
9463
  * `~/.claude/skills` twin declare the same path string. When the identifier
9010
9464
  * reaches guides under more than one root and no root was given, the server
9011
9465
  * refuses and names both rather than picking one — answering a question about
@@ -9574,6 +10028,17 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
9574
10028
  readonly start: v.NumberSchema<undefined>;
9575
10029
  readonly end: v.NumberSchema<undefined>;
9576
10030
  }, undefined>, undefined>;
10031
+ /**
10032
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
10033
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
10034
+ * the passage has no source lines, so an agent can find a block the
10035
+ * page's script built.
10036
+ */
10037
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
10038
+ readonly selector: v.StringSchema<undefined>;
10039
+ readonly tag: v.StringSchema<undefined>;
10040
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
10041
+ }, undefined>, undefined>;
9577
10042
  }, undefined>, undefined>;
9578
10043
  /** The comment's text, already wrapped in the response's untrusted markers. */
9579
10044
  readonly body: v.StringSchema<undefined>;
@@ -9592,22 +10057,26 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
9592
10057
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
9593
10058
  }, undefined>, undefined>;
9594
10059
  /**
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.
10060
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
10061
+ * hands one over any more, so a current server sends `false` on every Mossbear
10062
+ * comment and omits it on a person's or an agent's; the field stays for
10063
+ * readers that predate `findingState`. It does not say whether the agent may
10064
+ * act: read `findingState` for that, and fall back to `approved: false`
10065
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
10066
+ * that predates it. Only a client that reports a version able to mark drafts
10067
+ * is listed a finding at all, so an older reader that strips this field never
10068
+ * receives one it would misread.
9601
10069
  */
9602
10070
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
9603
10071
  /**
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.
10072
+ * Whether an open Mossbear finding is the agent's to act on. A current server
10073
+ * sends `ready` on every open finding: it is the agent's unless the person
10074
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
10075
+ * an older server, means it waits on the person: show it to the user and
10076
+ * change nothing unless they say so. Present only on an open Mossbear
10077
+ * comment. A server that predates the field omits it, and a reader then
10078
+ * falls back to `approved`. This is a new name rather than a new meaning for
10079
+ * `state`, which already says open or resolved.
9611
10080
  */
9612
10081
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
9613
10082
  /**
@@ -9935,6 +10404,17 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
9935
10404
  readonly start: v.NumberSchema<undefined>;
9936
10405
  readonly end: v.NumberSchema<undefined>;
9937
10406
  }, undefined>, undefined>;
10407
+ /**
10408
+ * Where the passage sits in an `html` page as the reader saw it: a CSS
10409
+ * selector, the tag, and the nearest `aria-label` or heading. Sent when
10410
+ * the passage has no source lines, so an agent can find a block the
10411
+ * page's script built.
10412
+ */
10413
+ readonly element: v.OptionalSchema<v.ObjectSchema<{
10414
+ readonly selector: v.StringSchema<undefined>;
10415
+ readonly tag: v.StringSchema<undefined>;
10416
+ readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
10417
+ }, undefined>, undefined>;
9938
10418
  }, undefined>, undefined>;
9939
10419
  /** The comment's text, already wrapped in the response's untrusted markers. */
9940
10420
  readonly body: v.StringSchema<undefined>;
@@ -9953,22 +10433,26 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
9953
10433
  readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
9954
10434
  }, undefined>, undefined>;
9955
10435
  /**
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.
10436
+ * Whether the person handed a comment Mossbear drafted to their agent. Nothing
10437
+ * hands one over any more, so a current server sends `false` on every Mossbear
10438
+ * comment and omits it on a person's or an agent's; the field stays for
10439
+ * readers that predate `findingState`. It does not say whether the agent may
10440
+ * act: read `findingState` for that, and fall back to `approved: false`
10441
+ * meaning "not yet accepted" only when `findingState` is absent, from a server
10442
+ * that predates it. Only a client that reports a version able to mark drafts
10443
+ * is listed a finding at all, so an older reader that strips this field never
10444
+ * receives one it would misread.
9962
10445
  */
9963
10446
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
9964
10447
  /**
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.
10448
+ * Whether an open Mossbear finding is the agent's to act on. A current server
10449
+ * sends `ready` on every open finding: it is the agent's unless the person
10450
+ * dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
10451
+ * an older server, means it waits on the person: show it to the user and
10452
+ * change nothing unless they say so. Present only on an open Mossbear
10453
+ * comment. A server that predates the field omits it, and a reader then
10454
+ * falls back to `approved`. This is a new name rather than a new meaning for
10455
+ * `state`, which already says open or resolved.
9972
10456
  */
9973
10457
  readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
9974
10458
  /**
@@ -10253,6 +10737,51 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
10253
10737
  }, undefined>, undefined>;
10254
10738
  }, undefined>;
10255
10739
  export type ArtifactFeedbackBatchResponse = v.InferOutput<typeof ArtifactFeedbackBatchResponseSchema>;
10740
+ /**
10741
+ * How many artifacts one prompt-time announcement names. The rest are counted
10742
+ * in one line and named on a later prompt, so a session that wrote many
10743
+ * artifacts prints a few lines in front of a turn rather than a list.
10744
+ */
10745
+ export declare const MAX_SESSION_COMMENT_ANNOUNCEMENT_ARTIFACTS = 5;
10746
+ /**
10747
+ * Ask which artifacts this agent session wrote carry open comments, and which
10748
+ * (`agent-hears-new-artifact-comments` slice 3).
10749
+ *
10750
+ * **A read, not a write.** Which of those comments the session has already been
10751
+ * told about is kept beside the session, by comment id. Not by creation time:
10752
+ * a comment can become readable long after it was created (a finding its owner
10753
+ * approves, an artifact restored from the Trash), and a time cursor would have
10754
+ * passed it by. The session-start announcement's per-repo count is a different
10755
+ * question and is not touched.
10756
+ */
10757
+ export declare const AnnounceSessionCommentsRequestSchema: v.ObjectSchema<{
10758
+ /**
10759
+ * The harness's own id for the session, as artifact writes record it in a
10760
+ * version's metadata. Matched only against versions the caller's account
10761
+ * wrote, so naming another account's session finds nothing.
10762
+ */
10763
+ readonly agentSessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
10764
+ /** The repo asking, as its committed config declares it, for repo-scoped findings. */
10765
+ 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>;
10766
+ }, undefined>;
10767
+ export type AnnounceSessionCommentsRequest = v.InferOutput<typeof AnnounceSessionCommentsRequestSchema>;
10768
+ export declare const AnnounceSessionCommentsResponseSchema: v.ObjectSchema<{
10769
+ /**
10770
+ * The session's artifacts that carry open comments, most recently commented
10771
+ * first; at most as many as one batch feedback read takes.
10772
+ */
10773
+ readonly artifacts: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
10774
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
10775
+ readonly name: v.StringSchema<undefined>;
10776
+ /** Its open comments, newest first, at most one wire allowance of them. */
10777
+ 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>]>;
10778
+ }, undefined>, undefined>, v.MaxLengthAction<{
10779
+ id: string;
10780
+ name: string;
10781
+ commentIds: string[];
10782
+ }[], 25, undefined>]>;
10783
+ }, undefined>;
10784
+ export type AnnounceSessionCommentsResponse = v.InferOutput<typeof AnnounceSessionCommentsResponseSchema>;
10256
10785
  export declare const SessionGradeRequestSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
10257
10786
  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
10787
  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 +11491,10 @@ export declare const SearchArtifactCommentHitSchema: v.ObjectSchema<{
10962
11491
  */
10963
11492
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
10964
11493
  /**
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.
11494
+ * Whether a Mossbear finding's owner handed it to their agents. Nothing hands
11495
+ * one over any more, so a current server sends `false`. It does not say
11496
+ * whether an agent may act on it: every open finding is ready unless
11497
+ * dismissed. Absent on a person's or an agent's comment and on a reply.
10967
11498
  */
10968
11499
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
10969
11500
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11015,8 +11546,10 @@ export declare const SearchCommentHitSchema: v.VariantSchema<"subjectKind", [v.O
11015
11546
  */
11016
11547
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
11017
11548
  /**
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.
11549
+ * Whether a Mossbear finding's owner handed it to their agents. Nothing hands
11550
+ * one over any more, so a current server sends `false`. It does not say
11551
+ * whether an agent may act on it: every open finding is ready unless
11552
+ * dismissed. Absent on a person's or an agent's comment and on a reply.
11020
11553
  */
11021
11554
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
11022
11555
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11233,8 +11766,10 @@ export declare const SearchCommentsReportSchema: v.VariantSchema<"status", [v.Ob
11233
11766
  */
11234
11767
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
11235
11768
  /**
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.
11769
+ * Whether a Mossbear finding's owner handed it to their agents. Nothing hands
11770
+ * one over any more, so a current server sends `false`. It does not say
11771
+ * whether an agent may act on it: every open finding is ready unless
11772
+ * dismissed. Absent on a person's or an agent's comment and on a reply.
11238
11773
  */
11239
11774
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
11240
11775
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11477,8 +12012,10 @@ export declare const SearchResponseSchema: v.ObjectSchema<{
11477
12012
  */
11478
12013
  readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
11479
12014
  /**
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.
12015
+ * Whether a Mossbear finding's owner handed it to their agents. Nothing hands
12016
+ * one over any more, so a current server sends `false`. It does not say
12017
+ * whether an agent may act on it: every open finding is ready unless
12018
+ * dismissed. Absent on a person's or an agent's comment and on a reply.
11482
12019
  */
11483
12020
  readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
11484
12021
  readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -11805,6 +12342,11 @@ export declare function parseContextItemsResponse(data: unknown): {
11805
12342
  start: number;
11806
12343
  end: number;
11807
12344
  } | null;
12345
+ element?: {
12346
+ selector: string;
12347
+ tag: string;
12348
+ label?: string | undefined;
12349
+ } | undefined;
11808
12350
  } | undefined;
11809
12351
  body: string;
11810
12352
  finding?: {
@@ -11892,6 +12434,11 @@ export declare function parseBundleArtifactsResponse(data: unknown): {
11892
12434
  start: number;
11893
12435
  end: number;
11894
12436
  } | null;
12437
+ element?: {
12438
+ selector: string;
12439
+ tag: string;
12440
+ label?: string | undefined;
12441
+ } | undefined;
11895
12442
  } | undefined;
11896
12443
  body: string;
11897
12444
  finding?: {
@@ -12222,6 +12769,13 @@ export declare function parseAnnounceItemCommentsResponse(data: unknown): {
12222
12769
  open: number;
12223
12770
  announced: number;
12224
12771
  };
12772
+ export declare function parseAnnounceSessionCommentsResponse(data: unknown): {
12773
+ artifacts: {
12774
+ id: string;
12775
+ name: string;
12776
+ commentIds: string[];
12777
+ }[];
12778
+ };
12225
12779
  export declare function parseAgentCommentResponse(data: unknown): {
12226
12780
  created: boolean;
12227
12781
  comment: {
@@ -12248,6 +12802,11 @@ export declare function parseItemCommentsResponse(data: unknown): {
12248
12802
  start: number;
12249
12803
  end: number;
12250
12804
  } | null;
12805
+ element?: {
12806
+ selector: string;
12807
+ tag: string;
12808
+ label?: string | undefined;
12809
+ } | undefined;
12251
12810
  } | undefined;
12252
12811
  body: string;
12253
12812
  finding?: {