@mossbear/protocol 0.1.0-alpha.52 → 0.1.0-alpha.53

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
@@ -852,6 +852,93 @@ export declare const GuideAliasSchema: v.ObjectSchema<{
852
852
  readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>;
853
853
  }, undefined>;
854
854
  export type GuideAlias = v.InferOutput<typeof GuideAliasSchema>;
855
+ /**
856
+ * The markers every untrusted block in a response is wrapped in, plus a
857
+ * statement of what they mean.
858
+ *
859
+ * Generated per response from the content itself, so no marker-like text
860
+ * inside a block can end it early — a property `deriveDelimiterToken` checks
861
+ * rather than assumes.
862
+ *
863
+ * Named for the guide-history response it was written for and shared by every
864
+ * payload that places somebody else's words in front of an agent: a grade's
865
+ * reasoning, and now an item's notes. One marker scheme, not one per payload —
866
+ * a second scheme is a second thing a reader has to be taught to respect.
867
+ * Declared here, above its first user, rather than beside that response.
868
+ */
869
+ export declare const GuideHistoryUntrustedSchema: v.ObjectSchema<{
870
+ readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
871
+ readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
872
+ readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
873
+ readonly note: v.StringSchema<undefined>;
874
+ }, undefined>;
875
+ export type GuideHistoryUntrusted = v.InferOutput<typeof GuideHistoryUntrustedSchema>;
876
+ /**
877
+ * How many open notes one item carries on the wire, newest first.
878
+ *
879
+ * A wire bound, not a product limit: the write side refuses the note that
880
+ * would exceed it *by name* (see the dashboard's note mutator), so this cap is
881
+ * never the thing that silently drops a request a person left.
882
+ */
883
+ export declare const MAX_ITEM_NOTES_ON_WIRE = 20;
884
+ /**
885
+ * One note a **person** left about a context item, riding the item it is about.
886
+ *
887
+ * A note is not an item: it is not a member, not projected, not versioned and
888
+ * not capturable. It travels on the item so that it inherits every delivery
889
+ * decision the item already went through — workspace scope, the archived drop,
890
+ * the response limit, the subscriber's mute — rather than restating them.
891
+ *
892
+ * **Every `body` here is already wrapped in the response's untrusted markers**
893
+ * (`ContextItemsResponseSchema.untrusted`). A reader emits the bytes as it
894
+ * received them and never re-wraps them: the markers are derived against the
895
+ * bodies the server sent, so a second wrapping cannot claim the same guarantee.
896
+ */
897
+ export declare const ContextItemNoteSchema: v.ObjectSchema<{
898
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
899
+ /** The note's text, already wrapped in the response's untrusted markers. */
900
+ readonly body: v.StringSchema<undefined>;
901
+ /** The author's display name as the workspace shows it, or null. Never an email. */
902
+ readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
903
+ /** ISO timestamp, machine format. */
904
+ readonly createdAt: v.StringSchema<undefined>;
905
+ /** The item's content version the note was written against. */
906
+ readonly itemVersion: v.NumberSchema<undefined>;
907
+ /** True when the item's current version is greater than `itemVersion`. */
908
+ readonly itemChangedSince: v.BooleanSchema<undefined>;
909
+ /**
910
+ * How many agent reads were handed this note **before** this one — so a
911
+ * note reaching an agent for the first time reports `0`.
912
+ *
913
+ * It is the stored count as it read at the moment the response was built;
914
+ * the serve this response *is* has not been counted yet. Excluded rather
915
+ * than included because the count is recorded best-effort: a response that
916
+ * claimed to include itself would be wrong whenever that record failed, and
917
+ * a number that is sometimes off by one is worse than one that is
918
+ * consistently the prior total.
919
+ *
920
+ * So `deliveredCount > 0` means an earlier read was handed this note, and
921
+ * `0` means this read is the first. Neither says a model took it in — only
922
+ * that the server handed it over.
923
+ */
924
+ readonly deliveredCount: v.NumberSchema<undefined>;
925
+ /**
926
+ * This note's thread root — its own id for every note written today, since
927
+ * no reply exists yet. Ignorable now; load-bearing once a reply is a second
928
+ * row with a different id here. It is on the wire from the first response
929
+ * because the wire contract is consumed by installed CLI versions: reshaping
930
+ * a flat `notes` array into threads-of-notes later would be a breaking
931
+ * change, while a field today's readers ignore costs them nothing.
932
+ */
933
+ readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
934
+ /**
935
+ * Always `null` today — no reply exists to point at. Present now so an older
936
+ * reader meeting a future response that carries real replies degrades to
937
+ * "a flat list of notes" rather than failing to parse.
938
+ */
939
+ readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
940
+ }, undefined>;
941
+ export type ContextItemNote = v.InferOutput<typeof ContextItemNoteSchema>;
855
942
  export declare const ContextItemSchema: v.ObjectSchema<{
856
943
  readonly id: v.StringSchema<undefined>;
857
944
  readonly type: v.PicklistSchema<string[], undefined>;
@@ -884,6 +971,71 @@ export declare const ContextItemSchema: v.ObjectSchema<{
884
971
  root: "project" | "global";
885
972
  path: string;
886
973
  }[], 8, undefined>]>, undefined>;
974
+ /**
975
+ * Open notes a person left about this item, newest first.
976
+ *
977
+ * Optional, and absent rather than empty when there are none — the same rule
978
+ * `aliases` and `projectId` follow above, and for the same reason: an older
979
+ * reader against a newer server ignores the key, and a newer reader against
980
+ * an older server reads "no notes" instead of failing.
981
+ *
982
+ * **Absence is not a verdict.** No notes here means none were served on this
983
+ * item in this response — not that nobody has anything to say about it.
984
+ */
985
+ readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
986
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
987
+ /** The note's text, already wrapped in the response's untrusted markers. */
988
+ readonly body: v.StringSchema<undefined>;
989
+ /** The author's display name as the workspace shows it, or null. Never an email. */
990
+ readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
991
+ /** ISO timestamp, machine format. */
992
+ readonly createdAt: v.StringSchema<undefined>;
993
+ /** The item's content version the note was written against. */
994
+ readonly itemVersion: v.NumberSchema<undefined>;
995
+ /** True when the item's current version is greater than `itemVersion`. */
996
+ readonly itemChangedSince: v.BooleanSchema<undefined>;
997
+ /**
998
+ * How many agent reads were handed this note **before** this one — so a
999
+ * note reaching an agent for the first time reports `0`.
1000
+ *
1001
+ * It is the stored count as it read at the moment the response was built;
1002
+ * the serve this response *is* has not been counted yet. Excluded rather
1003
+ * than included because the count is recorded best-effort: a response that
1004
+ * claimed to include itself would be wrong whenever that record failed, and
1005
+ * a number that is sometimes off by one is worse than one that is
1006
+ * consistently the prior total.
1007
+ *
1008
+ * So `deliveredCount > 0` means an earlier read was handed this note, and
1009
+ * `0` means this read is the first. Neither says a model took it in — only
1010
+ * that the server handed it over.
1011
+ */
1012
+ readonly deliveredCount: v.NumberSchema<undefined>;
1013
+ /**
1014
+ * This note's thread root — its own id for every note written today, since
1015
+ * no reply exists yet. Ignorable now; load-bearing once a reply is a second
1016
+ * row with a different id here. It is on the wire from the first response
1017
+ * because the wire contract is consumed by installed CLI versions: reshaping
1018
+ * a flat `notes` array into threads-of-notes later would be a breaking
1019
+ * change, while a field today's readers ignore costs them nothing.
1020
+ */
1021
+ readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1022
+ /**
1023
+ * Always `null` today — no reply exists to point at. Present now so an older
1024
+ * reader meeting a future response that carries real replies degrades to
1025
+ * "a flat list of notes" rather than failing to parse.
1026
+ */
1027
+ readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
1028
+ }, undefined>, undefined>, v.MaxLengthAction<{
1029
+ id: string;
1030
+ body: string;
1031
+ authorName: string | null;
1032
+ createdAt: string;
1033
+ itemVersion: number;
1034
+ itemChangedSince: boolean;
1035
+ deliveredCount: number;
1036
+ threadId: string;
1037
+ replyToId: string | null;
1038
+ }[], 20, undefined>]>, undefined>;
887
1039
  readonly updatedAt: v.StringSchema<undefined>;
888
1040
  }, undefined>;
889
1041
  export declare const ContextItemsResponseSchema: v.ObjectSchema<{
@@ -919,8 +1071,84 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
919
1071
  root: "project" | "global";
920
1072
  path: string;
921
1073
  }[], 8, undefined>]>, undefined>;
1074
+ /**
1075
+ * Open notes a person left about this item, newest first.
1076
+ *
1077
+ * Optional, and absent rather than empty when there are none — the same rule
1078
+ * `aliases` and `projectId` follow above, and for the same reason: an older
1079
+ * reader against a newer server ignores the key, and a newer reader against
1080
+ * an older server reads "no notes" instead of failing.
1081
+ *
1082
+ * **Absence is not a verdict.** No notes here means none were served on this
1083
+ * item in this response — not that nobody has anything to say about it.
1084
+ */
1085
+ readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
1086
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1087
+ /** The note's text, already wrapped in the response's untrusted markers. */
1088
+ readonly body: v.StringSchema<undefined>;
1089
+ /** The author's display name as the workspace shows it, or null. Never an email. */
1090
+ readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1091
+ /** ISO timestamp, machine format. */
1092
+ readonly createdAt: v.StringSchema<undefined>;
1093
+ /** The item's content version the note was written against. */
1094
+ readonly itemVersion: v.NumberSchema<undefined>;
1095
+ /** True when the item's current version is greater than `itemVersion`. */
1096
+ readonly itemChangedSince: v.BooleanSchema<undefined>;
1097
+ /**
1098
+ * How many agent reads were handed this note **before** this one — so a
1099
+ * note reaching an agent for the first time reports `0`.
1100
+ *
1101
+ * It is the stored count as it read at the moment the response was built;
1102
+ * the serve this response *is* has not been counted yet. Excluded rather
1103
+ * than included because the count is recorded best-effort: a response that
1104
+ * claimed to include itself would be wrong whenever that record failed, and
1105
+ * a number that is sometimes off by one is worse than one that is
1106
+ * consistently the prior total.
1107
+ *
1108
+ * So `deliveredCount > 0` means an earlier read was handed this note, and
1109
+ * `0` means this read is the first. Neither says a model took it in — only
1110
+ * that the server handed it over.
1111
+ */
1112
+ readonly deliveredCount: v.NumberSchema<undefined>;
1113
+ /**
1114
+ * This note's thread root — its own id for every note written today, since
1115
+ * no reply exists yet. Ignorable now; load-bearing once a reply is a second
1116
+ * row with a different id here. It is on the wire from the first response
1117
+ * because the wire contract is consumed by installed CLI versions: reshaping
1118
+ * a flat `notes` array into threads-of-notes later would be a breaking
1119
+ * change, while a field today's readers ignore costs them nothing.
1120
+ */
1121
+ readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1122
+ /**
1123
+ * Always `null` today — no reply exists to point at. Present now so an older
1124
+ * reader meeting a future response that carries real replies degrades to
1125
+ * "a flat list of notes" rather than failing to parse.
1126
+ */
1127
+ readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
1128
+ }, undefined>, undefined>, v.MaxLengthAction<{
1129
+ id: string;
1130
+ body: string;
1131
+ authorName: string | null;
1132
+ createdAt: string;
1133
+ itemVersion: number;
1134
+ itemChangedSince: boolean;
1135
+ deliveredCount: number;
1136
+ threadId: string;
1137
+ replyToId: string | null;
1138
+ }[], 20, undefined>]>, undefined>;
922
1139
  readonly updatedAt: v.StringSchema<undefined>;
923
1140
  }, undefined>, undefined>;
1141
+ /**
1142
+ * The markers every note `body` in this response is wrapped in, plus a
1143
+ * statement of what they mean. Present exactly when at least one item
1144
+ * carries a note — there is nothing to delimit otherwise.
1145
+ */
1146
+ readonly untrusted: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
1147
+ readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1148
+ readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1149
+ readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1150
+ readonly note: v.StringSchema<undefined>;
1151
+ }, undefined>, undefined>, undefined>;
924
1152
  }, undefined>;
925
1153
  /** Max number of context item ids a push may cite as its transform sources. */
926
1154
  export declare const MAX_TRANSFORM_SOURCE_IDS = 100;
@@ -986,6 +1214,71 @@ export declare const PushContextResponseSchema: v.ObjectSchema<{
986
1214
  root: "project" | "global";
987
1215
  path: string;
988
1216
  }[], 8, undefined>]>, undefined>;
1217
+ /**
1218
+ * Open notes a person left about this item, newest first.
1219
+ *
1220
+ * Optional, and absent rather than empty when there are none — the same rule
1221
+ * `aliases` and `projectId` follow above, and for the same reason: an older
1222
+ * reader against a newer server ignores the key, and a newer reader against
1223
+ * an older server reads "no notes" instead of failing.
1224
+ *
1225
+ * **Absence is not a verdict.** No notes here means none were served on this
1226
+ * item in this response — not that nobody has anything to say about it.
1227
+ */
1228
+ readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
1229
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1230
+ /** The note's text, already wrapped in the response's untrusted markers. */
1231
+ readonly body: v.StringSchema<undefined>;
1232
+ /** The author's display name as the workspace shows it, or null. Never an email. */
1233
+ readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1234
+ /** ISO timestamp, machine format. */
1235
+ readonly createdAt: v.StringSchema<undefined>;
1236
+ /** The item's content version the note was written against. */
1237
+ readonly itemVersion: v.NumberSchema<undefined>;
1238
+ /** True when the item's current version is greater than `itemVersion`. */
1239
+ readonly itemChangedSince: v.BooleanSchema<undefined>;
1240
+ /**
1241
+ * How many agent reads were handed this note **before** this one — so a
1242
+ * note reaching an agent for the first time reports `0`.
1243
+ *
1244
+ * It is the stored count as it read at the moment the response was built;
1245
+ * the serve this response *is* has not been counted yet. Excluded rather
1246
+ * than included because the count is recorded best-effort: a response that
1247
+ * claimed to include itself would be wrong whenever that record failed, and
1248
+ * a number that is sometimes off by one is worse than one that is
1249
+ * consistently the prior total.
1250
+ *
1251
+ * So `deliveredCount > 0` means an earlier read was handed this note, and
1252
+ * `0` means this read is the first. Neither says a model took it in — only
1253
+ * that the server handed it over.
1254
+ */
1255
+ readonly deliveredCount: v.NumberSchema<undefined>;
1256
+ /**
1257
+ * This note's thread root — its own id for every note written today, since
1258
+ * no reply exists yet. Ignorable now; load-bearing once a reply is a second
1259
+ * row with a different id here. It is on the wire from the first response
1260
+ * because the wire contract is consumed by installed CLI versions: reshaping
1261
+ * a flat `notes` array into threads-of-notes later would be a breaking
1262
+ * change, while a field today's readers ignore costs them nothing.
1263
+ */
1264
+ readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1265
+ /**
1266
+ * Always `null` today — no reply exists to point at. Present now so an older
1267
+ * reader meeting a future response that carries real replies degrades to
1268
+ * "a flat list of notes" rather than failing to parse.
1269
+ */
1270
+ readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
1271
+ }, undefined>, undefined>, v.MaxLengthAction<{
1272
+ id: string;
1273
+ body: string;
1274
+ authorName: string | null;
1275
+ createdAt: string;
1276
+ itemVersion: number;
1277
+ itemChangedSince: boolean;
1278
+ deliveredCount: number;
1279
+ threadId: string;
1280
+ replyToId: string | null;
1281
+ }[], 20, undefined>]>, undefined>;
989
1282
  readonly updatedAt: v.StringSchema<undefined>;
990
1283
  }, undefined>;
991
1284
  readonly created: v.BooleanSchema<undefined>;
@@ -1037,6 +1330,71 @@ export declare const UpdateContextItemResponseSchema: v.ObjectSchema<{
1037
1330
  root: "project" | "global";
1038
1331
  path: string;
1039
1332
  }[], 8, undefined>]>, undefined>;
1333
+ /**
1334
+ * Open notes a person left about this item, newest first.
1335
+ *
1336
+ * Optional, and absent rather than empty when there are none — the same rule
1337
+ * `aliases` and `projectId` follow above, and for the same reason: an older
1338
+ * reader against a newer server ignores the key, and a newer reader against
1339
+ * an older server reads "no notes" instead of failing.
1340
+ *
1341
+ * **Absence is not a verdict.** No notes here means none were served on this
1342
+ * item in this response — not that nobody has anything to say about it.
1343
+ */
1344
+ readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
1345
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1346
+ /** The note's text, already wrapped in the response's untrusted markers. */
1347
+ readonly body: v.StringSchema<undefined>;
1348
+ /** The author's display name as the workspace shows it, or null. Never an email. */
1349
+ readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1350
+ /** ISO timestamp, machine format. */
1351
+ readonly createdAt: v.StringSchema<undefined>;
1352
+ /** The item's content version the note was written against. */
1353
+ readonly itemVersion: v.NumberSchema<undefined>;
1354
+ /** True when the item's current version is greater than `itemVersion`. */
1355
+ readonly itemChangedSince: v.BooleanSchema<undefined>;
1356
+ /**
1357
+ * How many agent reads were handed this note **before** this one — so a
1358
+ * note reaching an agent for the first time reports `0`.
1359
+ *
1360
+ * It is the stored count as it read at the moment the response was built;
1361
+ * the serve this response *is* has not been counted yet. Excluded rather
1362
+ * than included because the count is recorded best-effort: a response that
1363
+ * claimed to include itself would be wrong whenever that record failed, and
1364
+ * a number that is sometimes off by one is worse than one that is
1365
+ * consistently the prior total.
1366
+ *
1367
+ * So `deliveredCount > 0` means an earlier read was handed this note, and
1368
+ * `0` means this read is the first. Neither says a model took it in — only
1369
+ * that the server handed it over.
1370
+ */
1371
+ readonly deliveredCount: v.NumberSchema<undefined>;
1372
+ /**
1373
+ * This note's thread root — its own id for every note written today, since
1374
+ * no reply exists yet. Ignorable now; load-bearing once a reply is a second
1375
+ * row with a different id here. It is on the wire from the first response
1376
+ * because the wire contract is consumed by installed CLI versions: reshaping
1377
+ * a flat `notes` array into threads-of-notes later would be a breaking
1378
+ * change, while a field today's readers ignore costs them nothing.
1379
+ */
1380
+ readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1381
+ /**
1382
+ * Always `null` today — no reply exists to point at. Present now so an older
1383
+ * reader meeting a future response that carries real replies degrades to
1384
+ * "a flat list of notes" rather than failing to parse.
1385
+ */
1386
+ readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
1387
+ }, undefined>, undefined>, v.MaxLengthAction<{
1388
+ id: string;
1389
+ body: string;
1390
+ authorName: string | null;
1391
+ createdAt: string;
1392
+ itemVersion: number;
1393
+ itemChangedSince: boolean;
1394
+ deliveredCount: number;
1395
+ threadId: string;
1396
+ replyToId: string | null;
1397
+ }[], 20, undefined>]>, undefined>;
1040
1398
  readonly updatedAt: v.StringSchema<undefined>;
1041
1399
  }, undefined>;
1042
1400
  readonly updated: v.BooleanSchema<undefined>;
@@ -1141,6 +1499,71 @@ export declare const ContextItemResponseSchema: v.ObjectSchema<{
1141
1499
  root: "project" | "global";
1142
1500
  path: string;
1143
1501
  }[], 8, undefined>]>, undefined>;
1502
+ /**
1503
+ * Open notes a person left about this item, newest first.
1504
+ *
1505
+ * Optional, and absent rather than empty when there are none — the same rule
1506
+ * `aliases` and `projectId` follow above, and for the same reason: an older
1507
+ * reader against a newer server ignores the key, and a newer reader against
1508
+ * an older server reads "no notes" instead of failing.
1509
+ *
1510
+ * **Absence is not a verdict.** No notes here means none were served on this
1511
+ * item in this response — not that nobody has anything to say about it.
1512
+ */
1513
+ readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
1514
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1515
+ /** The note's text, already wrapped in the response's untrusted markers. */
1516
+ readonly body: v.StringSchema<undefined>;
1517
+ /** The author's display name as the workspace shows it, or null. Never an email. */
1518
+ readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1519
+ /** ISO timestamp, machine format. */
1520
+ readonly createdAt: v.StringSchema<undefined>;
1521
+ /** The item's content version the note was written against. */
1522
+ readonly itemVersion: v.NumberSchema<undefined>;
1523
+ /** True when the item's current version is greater than `itemVersion`. */
1524
+ readonly itemChangedSince: v.BooleanSchema<undefined>;
1525
+ /**
1526
+ * How many agent reads were handed this note **before** this one — so a
1527
+ * note reaching an agent for the first time reports `0`.
1528
+ *
1529
+ * It is the stored count as it read at the moment the response was built;
1530
+ * the serve this response *is* has not been counted yet. Excluded rather
1531
+ * than included because the count is recorded best-effort: a response that
1532
+ * claimed to include itself would be wrong whenever that record failed, and
1533
+ * a number that is sometimes off by one is worse than one that is
1534
+ * consistently the prior total.
1535
+ *
1536
+ * So `deliveredCount > 0` means an earlier read was handed this note, and
1537
+ * `0` means this read is the first. Neither says a model took it in — only
1538
+ * that the server handed it over.
1539
+ */
1540
+ readonly deliveredCount: v.NumberSchema<undefined>;
1541
+ /**
1542
+ * This note's thread root — its own id for every note written today, since
1543
+ * no reply exists yet. Ignorable now; load-bearing once a reply is a second
1544
+ * row with a different id here. It is on the wire from the first response
1545
+ * because the wire contract is consumed by installed CLI versions: reshaping
1546
+ * a flat `notes` array into threads-of-notes later would be a breaking
1547
+ * change, while a field today's readers ignore costs them nothing.
1548
+ */
1549
+ readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1550
+ /**
1551
+ * Always `null` today — no reply exists to point at. Present now so an older
1552
+ * reader meeting a future response that carries real replies degrades to
1553
+ * "a flat list of notes" rather than failing to parse.
1554
+ */
1555
+ readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
1556
+ }, undefined>, undefined>, v.MaxLengthAction<{
1557
+ id: string;
1558
+ body: string;
1559
+ authorName: string | null;
1560
+ createdAt: string;
1561
+ itemVersion: number;
1562
+ itemChangedSince: boolean;
1563
+ deliveredCount: number;
1564
+ threadId: string;
1565
+ replyToId: string | null;
1566
+ }[], 20, undefined>]>, undefined>;
1144
1567
  readonly updatedAt: v.StringSchema<undefined>;
1145
1568
  }, undefined>;
1146
1569
  }, undefined>;
@@ -1178,6 +1601,71 @@ export declare const ArchiveContextItemResponseSchema: v.ObjectSchema<{
1178
1601
  root: "project" | "global";
1179
1602
  path: string;
1180
1603
  }[], 8, undefined>]>, undefined>;
1604
+ /**
1605
+ * Open notes a person left about this item, newest first.
1606
+ *
1607
+ * Optional, and absent rather than empty when there are none — the same rule
1608
+ * `aliases` and `projectId` follow above, and for the same reason: an older
1609
+ * reader against a newer server ignores the key, and a newer reader against
1610
+ * an older server reads "no notes" instead of failing.
1611
+ *
1612
+ * **Absence is not a verdict.** No notes here means none were served on this
1613
+ * item in this response — not that nobody has anything to say about it.
1614
+ */
1615
+ readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
1616
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1617
+ /** The note's text, already wrapped in the response's untrusted markers. */
1618
+ readonly body: v.StringSchema<undefined>;
1619
+ /** The author's display name as the workspace shows it, or null. Never an email. */
1620
+ readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
1621
+ /** ISO timestamp, machine format. */
1622
+ readonly createdAt: v.StringSchema<undefined>;
1623
+ /** The item's content version the note was written against. */
1624
+ readonly itemVersion: v.NumberSchema<undefined>;
1625
+ /** True when the item's current version is greater than `itemVersion`. */
1626
+ readonly itemChangedSince: v.BooleanSchema<undefined>;
1627
+ /**
1628
+ * How many agent reads were handed this note **before** this one — so a
1629
+ * note reaching an agent for the first time reports `0`.
1630
+ *
1631
+ * It is the stored count as it read at the moment the response was built;
1632
+ * the serve this response *is* has not been counted yet. Excluded rather
1633
+ * than included because the count is recorded best-effort: a response that
1634
+ * claimed to include itself would be wrong whenever that record failed, and
1635
+ * a number that is sometimes off by one is worse than one that is
1636
+ * consistently the prior total.
1637
+ *
1638
+ * So `deliveredCount > 0` means an earlier read was handed this note, and
1639
+ * `0` means this read is the first. Neither says a model took it in — only
1640
+ * that the server handed it over.
1641
+ */
1642
+ readonly deliveredCount: v.NumberSchema<undefined>;
1643
+ /**
1644
+ * This note's thread root — its own id for every note written today, since
1645
+ * no reply exists yet. Ignorable now; load-bearing once a reply is a second
1646
+ * row with a different id here. It is on the wire from the first response
1647
+ * because the wire contract is consumed by installed CLI versions: reshaping
1648
+ * a flat `notes` array into threads-of-notes later would be a breaking
1649
+ * change, while a field today's readers ignore costs them nothing.
1650
+ */
1651
+ readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
1652
+ /**
1653
+ * Always `null` today — no reply exists to point at. Present now so an older
1654
+ * reader meeting a future response that carries real replies degrades to
1655
+ * "a flat list of notes" rather than failing to parse.
1656
+ */
1657
+ readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
1658
+ }, undefined>, undefined>, v.MaxLengthAction<{
1659
+ id: string;
1660
+ body: string;
1661
+ authorName: string | null;
1662
+ createdAt: string;
1663
+ itemVersion: number;
1664
+ itemChangedSince: boolean;
1665
+ deliveredCount: number;
1666
+ threadId: string;
1667
+ replyToId: string | null;
1668
+ }[], 20, undefined>]>, undefined>;
1181
1669
  readonly updatedAt: v.StringSchema<undefined>;
1182
1670
  }, undefined>;
1183
1671
  }, undefined>;
@@ -1197,6 +1685,7 @@ export declare const InboxCaptureRequestSchema: v.ObjectSchema<{
1197
1685
  * from it. The one in-repo caller is the dashboard composer.)
1198
1686
  */
1199
1687
  readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 8, "id must be at least 8 characters">, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "id must contain only letters, digits, underscore, dot or hyphen">]>, undefined>;
1688
+ readonly bundleId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
1200
1689
  readonly contentType: v.PicklistSchema<("document" | "reference" | "asset")[], undefined>;
1201
1690
  readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 262144 bytes">]>;
1202
1691
  readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
@@ -2542,20 +3031,6 @@ export declare const GuideHistoryGuideSchema: v.ObjectSchema<{
2542
3031
  readonly path: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>;
2543
3032
  readonly root: v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>;
2544
3033
  }, undefined>;
2545
- /**
2546
- * The markers every `reasoning` block in this response is wrapped in, plus a
2547
- * statement of what they mean.
2548
- *
2549
- * Generated per response from the content itself, so no marker-like text inside
2550
- * a block can end it early — a property `deriveDelimiterToken` checks rather
2551
- * than assumes.
2552
- */
2553
- export declare const GuideHistoryUntrustedSchema: v.ObjectSchema<{
2554
- readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2555
- readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2556
- readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2557
- readonly note: v.StringSchema<undefined>;
2558
- }, undefined>;
2559
3034
  export declare const GuideHistoryResponseSchema: v.ObjectSchema<{
2560
3035
  readonly guide: v.ObjectSchema<{
2561
3036
  readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -2849,77 +3324,6 @@ export declare const SessionGradeResponseSchema: v.ObjectSchema<{
2849
3324
  }, undefined>, undefined>;
2850
3325
  }, undefined>;
2851
3326
  export type SessionGradeResponse = v.InferOutput<typeof SessionGradeResponseSchema>;
2852
- /**
2853
- * The five kinds of session residue the server used to extract on session
2854
- * close. No longer produced by anything — kept so an already-installed CLI's
2855
- * parse of the (now always-empty) response still type-checks against the
2856
- * same shape it always has.
2857
- */
2858
- export declare const SessionResidueKindSchema: v.PicklistSchema<["decision", "deferral", "assumption", "question", "found_not_fixed"], undefined>;
2859
- export type SessionResidueKind = v.InferOutput<typeof SessionResidueKindSchema>;
2860
- /**
2861
- * How many residue items one read returns at most — the same cap the
2862
- * extractor applies per session, applied again across sessions: the handoff a
2863
- * session reads at start is a glance, not a log.
2864
- */
2865
- export declare const MAX_SESSION_RESIDUE_ITEMS = 5;
2866
- /** `?project=` — the committed project id whose recent sessions to read. */
2867
- export declare const SessionResidueRequestSchema: v.ObjectSchema<{
2868
- readonly project: 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">]>;
2869
- }, undefined>;
2870
- export type SessionResidueRequest = v.InferOutput<typeof SessionResidueRequestSchema>;
2871
- /** One item a recent session in the project left behind. */
2872
- export declare const SessionResidueItemSchema: v.ObjectSchema<{
2873
- readonly kind: v.PicklistSchema<["decision", "deferral", "assumption", "question", "found_not_fixed"], undefined>;
2874
- /**
2875
- * The item's text, **already wrapped in the response's untrusted markers**
2876
- * — model-authored, transcript-derived, and about to be placed in front of
2877
- * an agent, so delimited at the source exactly as a grade's reasoning is.
2878
- */
2879
- readonly text: v.StringSchema<undefined>;
2880
- /** The run the item came from; what `mossbear sessions <id>` takes. */
2881
- readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2882
- readonly agentSessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2883
- /** ISO timestamp of the session's close; null while it is still open. */
2884
- readonly endedAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
2885
- }, undefined>;
2886
- export type SessionResidueItem = v.InferOutput<typeof SessionResidueItemSchema>;
2887
- export declare const SessionResidueResponseSchema: v.ObjectSchema<{
2888
- readonly project: 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">]>;
2889
- /**
2890
- * Newest session first, then in the order the session recorded them; at
2891
- * most {@link MAX_SESSION_RESIDUE_ITEMS}. Empty is the ordinary answer and
2892
- * says "nothing on record", never "nothing happened".
2893
- */
2894
- readonly items: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
2895
- readonly kind: v.PicklistSchema<["decision", "deferral", "assumption", "question", "found_not_fixed"], undefined>;
2896
- /**
2897
- * The item's text, **already wrapped in the response's untrusted markers**
2898
- * — model-authored, transcript-derived, and about to be placed in front of
2899
- * an agent, so delimited at the source exactly as a grade's reasoning is.
2900
- */
2901
- readonly text: v.StringSchema<undefined>;
2902
- /** The run the item came from; what `mossbear sessions <id>` takes. */
2903
- readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2904
- readonly agentSessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2905
- /** ISO timestamp of the session's close; null while it is still open. */
2906
- readonly endedAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
2907
- }, undefined>, undefined>, v.MaxLengthAction<{
2908
- kind: "decision" | "deferral" | "assumption" | "question" | "found_not_fixed";
2909
- text: string;
2910
- sessionId: string;
2911
- agentSessionId: string;
2912
- endedAt: string | null;
2913
- }[], 5, undefined>]>;
2914
- /** The markers every `text` is wrapped in; present exactly when `items` is non-empty. */
2915
- readonly untrusted: v.NullableSchema<v.ObjectSchema<{
2916
- readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2917
- readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2918
- readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
2919
- readonly note: v.StringSchema<undefined>;
2920
- }, undefined>, undefined>;
2921
- }, undefined>;
2922
- export type SessionResidueResponse = v.InferOutput<typeof SessionResidueResponseSchema>;
2923
3327
  export declare function parseAgentConfig(data: unknown): {
2924
3328
  id: string;
2925
3329
  name: string;
@@ -3098,6 +3502,17 @@ export declare function parseContextItem(data: unknown): {
3098
3502
  root: "project" | "global";
3099
3503
  path: string;
3100
3504
  }[] | undefined;
3505
+ notes?: {
3506
+ id: string;
3507
+ body: string;
3508
+ authorName: string | null;
3509
+ createdAt: string;
3510
+ itemVersion: number;
3511
+ itemChangedSince: boolean;
3512
+ deliveredCount: number;
3513
+ threadId: string;
3514
+ replyToId: string | null;
3515
+ }[] | undefined;
3101
3516
  updatedAt: string;
3102
3517
  };
3103
3518
  export declare function parseContextItemsResponse(data: unknown): {
@@ -3117,8 +3532,25 @@ export declare function parseContextItemsResponse(data: unknown): {
3117
3532
  root: "project" | "global";
3118
3533
  path: string;
3119
3534
  }[] | undefined;
3535
+ notes?: {
3536
+ id: string;
3537
+ body: string;
3538
+ authorName: string | null;
3539
+ createdAt: string;
3540
+ itemVersion: number;
3541
+ itemChangedSince: boolean;
3542
+ deliveredCount: number;
3543
+ threadId: string;
3544
+ replyToId: string | null;
3545
+ }[] | undefined;
3120
3546
  updatedAt: string;
3121
3547
  }[];
3548
+ untrusted?: {
3549
+ token: string;
3550
+ startMarker: string;
3551
+ endMarker: string;
3552
+ note: string;
3553
+ } | null | undefined;
3122
3554
  };
3123
3555
  export declare function parsePushContextRequest(data: unknown): {
3124
3556
  name: string;
@@ -3147,6 +3579,17 @@ export declare function parsePushContextResponse(data: unknown): {
3147
3579
  root: "project" | "global";
3148
3580
  path: string;
3149
3581
  }[] | undefined;
3582
+ notes?: {
3583
+ id: string;
3584
+ body: string;
3585
+ authorName: string | null;
3586
+ createdAt: string;
3587
+ itemVersion: number;
3588
+ itemChangedSince: boolean;
3589
+ deliveredCount: number;
3590
+ threadId: string;
3591
+ replyToId: string | null;
3592
+ }[] | undefined;
3150
3593
  updatedAt: string;
3151
3594
  };
3152
3595
  created: boolean;
@@ -3176,6 +3619,17 @@ export declare function parseUpdateContextItemResponse(data: unknown): {
3176
3619
  root: "project" | "global";
3177
3620
  path: string;
3178
3621
  }[] | undefined;
3622
+ notes?: {
3623
+ id: string;
3624
+ body: string;
3625
+ authorName: string | null;
3626
+ createdAt: string;
3627
+ itemVersion: number;
3628
+ itemChangedSince: boolean;
3629
+ deliveredCount: number;
3630
+ threadId: string;
3631
+ replyToId: string | null;
3632
+ }[] | undefined;
3179
3633
  updatedAt: string;
3180
3634
  };
3181
3635
  updated: boolean;
@@ -3204,6 +3658,17 @@ export declare function parseContextItemResponse(data: unknown): {
3204
3658
  root: "project" | "global";
3205
3659
  path: string;
3206
3660
  }[] | undefined;
3661
+ notes?: {
3662
+ id: string;
3663
+ body: string;
3664
+ authorName: string | null;
3665
+ createdAt: string;
3666
+ itemVersion: number;
3667
+ itemChangedSince: boolean;
3668
+ deliveredCount: number;
3669
+ threadId: string;
3670
+ replyToId: string | null;
3671
+ }[] | undefined;
3207
3672
  updatedAt: string;
3208
3673
  };
3209
3674
  };
@@ -3225,11 +3690,23 @@ export declare function parseArchiveContextItemResponse(data: unknown): {
3225
3690
  root: "project" | "global";
3226
3691
  path: string;
3227
3692
  }[] | undefined;
3693
+ notes?: {
3694
+ id: string;
3695
+ body: string;
3696
+ authorName: string | null;
3697
+ createdAt: string;
3698
+ itemVersion: number;
3699
+ itemChangedSince: boolean;
3700
+ deliveredCount: number;
3701
+ threadId: string;
3702
+ replyToId: string | null;
3703
+ }[] | undefined;
3228
3704
  updatedAt: string;
3229
3705
  };
3230
3706
  };
3231
3707
  export declare function parseInboxCaptureRequest(data: unknown): {
3232
3708
  id?: string | undefined;
3709
+ bundleId?: string | null | undefined;
3233
3710
  contentType: "document" | "reference" | "asset";
3234
3711
  content: string;
3235
3712
  name?: string | undefined;
@@ -3578,21 +4055,5 @@ export declare function parseSessionGradeResponse(data: unknown): {
3578
4055
  note: string;
3579
4056
  } | null;
3580
4057
  };
3581
- export declare function parseSessionResidueResponse(data: unknown): {
3582
- project: string;
3583
- items: {
3584
- kind: "decision" | "deferral" | "assumption" | "question" | "found_not_fixed";
3585
- text: string;
3586
- sessionId: string;
3587
- agentSessionId: string;
3588
- endedAt: string | null;
3589
- }[];
3590
- untrusted: {
3591
- token: string;
3592
- startMarker: string;
3593
- endMarker: string;
3594
- note: string;
3595
- } | null;
3596
- };
3597
4058
  export {};
3598
4059
  //# sourceMappingURL=schemas.d.ts.map