@mossbear/protocol 0.1.0-alpha.93 → 0.1.0-alpha.95
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/artifact.test.js +16 -1
- package/dist/artifact.test.js.map +1 -1
- package/dist/schemas.d.ts +889 -16
- package/dist/schemas.d.ts.map +1 -1
- package/dist/schemas.js +258 -6
- package/dist/schemas.js.map +1 -1
- package/dist/schemas.test.js +42 -2
- package/dist/schemas.test.js.map +1 -1
- package/dist/types.d.ts +7 -1
- package/dist/types.d.ts.map +1 -1
- package/dist/types.js.map +1 -1
- package/package.json +1 -1
package/dist/schemas.d.ts
CHANGED
|
@@ -937,21 +937,44 @@ export declare const RevokeScopedTokenRequestSchema: v.ObjectSchema<{
|
|
|
937
937
|
* release step 2 sends; both are read, and the parsed value is always `artifactId`.
|
|
938
938
|
* Drop `itemId` once no such CLI is left to send it.
|
|
939
939
|
*/
|
|
940
|
+
/** The most artifacts one attach request may name. */
|
|
941
|
+
export declare const MAX_BUNDLE_MEMBERS_PER_ATTACH = 200;
|
|
940
942
|
export declare const AttachBundleMemberRequestSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
|
|
941
943
|
readonly artifactId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
942
944
|
readonly itemId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
945
|
+
readonly artifactIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.TransformAction<string[], string[]>, v.MinLengthAction<string[], 1, undefined>, v.MaxLengthAction<string[], 200, undefined>]>, undefined>;
|
|
943
946
|
}, undefined>, v.CheckAction<{
|
|
944
947
|
artifactId?: string | undefined;
|
|
945
948
|
itemId?: string | undefined;
|
|
946
|
-
|
|
949
|
+
artifactIds?: string[] | undefined;
|
|
950
|
+
}, "A member needs an artifactId, or a list of artifactIds on its own.">, v.TransformAction<{
|
|
947
951
|
artifactId?: string | undefined;
|
|
948
952
|
itemId?: string | undefined;
|
|
953
|
+
artifactIds?: string[] | undefined;
|
|
949
954
|
}, {
|
|
950
955
|
artifactId: string;
|
|
956
|
+
} | {
|
|
957
|
+
artifactIds: string[];
|
|
951
958
|
}>]>;
|
|
952
959
|
export declare const AttachBundleMemberResponseSchema: v.ObjectSchema<{
|
|
953
960
|
readonly attached: v.BooleanSchema<undefined>;
|
|
954
961
|
}, undefined>;
|
|
962
|
+
/**
|
|
963
|
+
* One id's outcome in a list attach. `unavailable` is every refusal that is not
|
|
964
|
+
* a path collision, and reads the same whether the artifact is missing, not the
|
|
965
|
+
* caller's to file or in another workspace, so a list cannot probe which ids
|
|
966
|
+
* exist.
|
|
967
|
+
*/
|
|
968
|
+
export declare const AttachBundleMembersResultSchema: v.ObjectSchema<{
|
|
969
|
+
readonly artifactId: v.StringSchema<undefined>;
|
|
970
|
+
readonly status: v.PicklistSchema<["added", "already_there", "unavailable", "path_taken"], undefined>;
|
|
971
|
+
}, undefined>;
|
|
972
|
+
export declare const AttachBundleMembersResponseSchema: v.ObjectSchema<{
|
|
973
|
+
readonly results: v.ArraySchema<v.ObjectSchema<{
|
|
974
|
+
readonly artifactId: v.StringSchema<undefined>;
|
|
975
|
+
readonly status: v.PicklistSchema<["added", "already_there", "unavailable", "path_taken"], undefined>;
|
|
976
|
+
}, undefined>, undefined>;
|
|
977
|
+
}, undefined>;
|
|
955
978
|
export declare const DetachBundleMemberResponseSchema: v.ObjectSchema<{
|
|
956
979
|
readonly detached: v.BooleanSchema<undefined>;
|
|
957
980
|
}, undefined>;
|
|
@@ -1078,6 +1101,13 @@ export declare const MAX_ITEM_COMMENTS_ON_WIRE = 20;
|
|
|
1078
1101
|
* it says how many it held back (`repliesWithheld`), so a cut is never silent.
|
|
1079
1102
|
*/
|
|
1080
1103
|
export declare const MAX_REPLIES_PER_THREAD_ON_WIRE = 10;
|
|
1104
|
+
/**
|
|
1105
|
+
* The most entries one item's `comments` can hold once threads ride it: a
|
|
1106
|
+
* person's allowance of roots plus an agent's own, each followed by its replies.
|
|
1107
|
+
* A client that does not render threads is sent roots alone, which stay within
|
|
1108
|
+
* `MAX_ITEM_COMMENTS_ON_WIRE`.
|
|
1109
|
+
*/
|
|
1110
|
+
export declare const MAX_ITEM_THREAD_ENTRIES_ON_WIRE: number;
|
|
1081
1111
|
/**
|
|
1082
1112
|
* Who wrote a comment. An agent writes under its person's account, so the
|
|
1083
1113
|
* author's name alone cannot tell a person's answer from an agent's message.
|
|
@@ -1186,6 +1216,19 @@ export declare const ArtifactCommentSchema: v.ObjectSchema<{
|
|
|
1186
1216
|
* that the server handed it over.
|
|
1187
1217
|
*/
|
|
1188
1218
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1219
|
+
/**
|
|
1220
|
+
* On a root: true when the item changed after an earlier read was last
|
|
1221
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
1222
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
1223
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
1224
|
+
*
|
|
1225
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
1226
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
1227
|
+
* changes again. A comment never handed over before is never flagged.
|
|
1228
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
1229
|
+
* a reply.
|
|
1230
|
+
*/
|
|
1231
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1189
1232
|
/**
|
|
1190
1233
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
1191
1234
|
*
|
|
@@ -1279,6 +1322,19 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
|
|
|
1279
1322
|
* that the server handed it over.
|
|
1280
1323
|
*/
|
|
1281
1324
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1325
|
+
/**
|
|
1326
|
+
* On a root: true when the item changed after an earlier read was last
|
|
1327
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
1328
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
1329
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
1330
|
+
*
|
|
1331
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
1332
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
1333
|
+
* changes again. A comment never handed over before is never flagged.
|
|
1334
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
1335
|
+
* a reply.
|
|
1336
|
+
*/
|
|
1337
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1282
1338
|
/**
|
|
1283
1339
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
1284
1340
|
*
|
|
@@ -1510,6 +1566,19 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1510
1566
|
* that the server handed it over.
|
|
1511
1567
|
*/
|
|
1512
1568
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1569
|
+
/**
|
|
1570
|
+
* On a root: true when the item changed after an earlier read was last
|
|
1571
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
1572
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
1573
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
1574
|
+
*
|
|
1575
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
1576
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
1577
|
+
* changes again. A comment never handed over before is never flagged.
|
|
1578
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
1579
|
+
* a reply.
|
|
1580
|
+
*/
|
|
1581
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1513
1582
|
/**
|
|
1514
1583
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
1515
1584
|
*
|
|
@@ -1558,10 +1627,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1558
1627
|
itemVersion: number;
|
|
1559
1628
|
itemChangedSince: boolean;
|
|
1560
1629
|
deliveredCount: number;
|
|
1630
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
1561
1631
|
threadId: string;
|
|
1562
1632
|
replyToId: string | null;
|
|
1563
1633
|
repliesWithheld?: number | undefined;
|
|
1564
|
-
}[],
|
|
1634
|
+
}[], number, undefined>]>, undefined>;
|
|
1565
1635
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
1566
1636
|
/**
|
|
1567
1637
|
* Present iff this artifact is owned by git. Absent means Mossbear owns it
|
|
@@ -1631,6 +1701,22 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1631
1701
|
* than a tombstone that says no.
|
|
1632
1702
|
*/
|
|
1633
1703
|
readonly removed: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
1704
|
+
/**
|
|
1705
|
+
* This guide is switched off. Served only to a read that asked for the
|
|
1706
|
+
* bundle's inventory (`inactive=include`), which the publishers make so a
|
|
1707
|
+
* switched-off guide is updated in place rather than created again. Every
|
|
1708
|
+
* other read omits switched-off guides, so a reader that ignores this key is
|
|
1709
|
+
* never handed one.
|
|
1710
|
+
*/
|
|
1711
|
+
readonly inactive: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
1712
|
+
/**
|
|
1713
|
+
* Beside `inactive` only: publication switched this guide off because the
|
|
1714
|
+
* published branch deleted its file, so publishing that file again switches
|
|
1715
|
+
* it back on. A switched-off guide without it was switched off by a person,
|
|
1716
|
+
* and publication leaves it off — re-sending its unchanged bytes would be a
|
|
1717
|
+
* write with nothing to do.
|
|
1718
|
+
*/
|
|
1719
|
+
readonly retiredByPublication: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
1634
1720
|
}, undefined>, v.TransformAction<{
|
|
1635
1721
|
id: string;
|
|
1636
1722
|
artifactId?: string | null | undefined;
|
|
@@ -1675,6 +1761,7 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1675
1761
|
itemVersion: number;
|
|
1676
1762
|
itemChangedSince: boolean;
|
|
1677
1763
|
deliveredCount: number;
|
|
1764
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
1678
1765
|
threadId: string;
|
|
1679
1766
|
replyToId: string | null;
|
|
1680
1767
|
repliesWithheld?: number | undefined;
|
|
@@ -1686,6 +1773,8 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1686
1773
|
branch?: string | undefined;
|
|
1687
1774
|
} | null | undefined;
|
|
1688
1775
|
removed?: true | undefined;
|
|
1776
|
+
inactive?: true | undefined;
|
|
1777
|
+
retiredByPublication?: true | undefined;
|
|
1689
1778
|
}, {
|
|
1690
1779
|
type: string;
|
|
1691
1780
|
id: string;
|
|
@@ -1730,6 +1819,7 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1730
1819
|
itemVersion: number;
|
|
1731
1820
|
itemChangedSince: boolean;
|
|
1732
1821
|
deliveredCount: number;
|
|
1822
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
1733
1823
|
threadId: string;
|
|
1734
1824
|
replyToId: string | null;
|
|
1735
1825
|
repliesWithheld?: number | undefined;
|
|
@@ -1741,6 +1831,8 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1741
1831
|
branch?: string | undefined;
|
|
1742
1832
|
} | null | undefined;
|
|
1743
1833
|
removed?: true | undefined;
|
|
1834
|
+
inactive?: true | undefined;
|
|
1835
|
+
retiredByPublication?: true | undefined;
|
|
1744
1836
|
}>]>;
|
|
1745
1837
|
export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
1746
1838
|
readonly items: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
|
|
@@ -1897,6 +1989,19 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
1897
1989
|
* that the server handed it over.
|
|
1898
1990
|
*/
|
|
1899
1991
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1992
|
+
/**
|
|
1993
|
+
* On a root: true when the item changed after an earlier read was last
|
|
1994
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
1995
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
1996
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
1997
|
+
*
|
|
1998
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
1999
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
2000
|
+
* changes again. A comment never handed over before is never flagged.
|
|
2001
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
2002
|
+
* a reply.
|
|
2003
|
+
*/
|
|
2004
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1900
2005
|
/**
|
|
1901
2006
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
1902
2007
|
*
|
|
@@ -1945,10 +2050,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
1945
2050
|
itemVersion: number;
|
|
1946
2051
|
itemChangedSince: boolean;
|
|
1947
2052
|
deliveredCount: number;
|
|
2053
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
1948
2054
|
threadId: string;
|
|
1949
2055
|
replyToId: string | null;
|
|
1950
2056
|
repliesWithheld?: number | undefined;
|
|
1951
|
-
}[],
|
|
2057
|
+
}[], number, undefined>]>, undefined>;
|
|
1952
2058
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
1953
2059
|
/**
|
|
1954
2060
|
* Present iff this artifact is owned by git. Absent means Mossbear owns it
|
|
@@ -2018,6 +2124,22 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2018
2124
|
* than a tombstone that says no.
|
|
2019
2125
|
*/
|
|
2020
2126
|
readonly removed: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
2127
|
+
/**
|
|
2128
|
+
* This guide is switched off. Served only to a read that asked for the
|
|
2129
|
+
* bundle's inventory (`inactive=include`), which the publishers make so a
|
|
2130
|
+
* switched-off guide is updated in place rather than created again. Every
|
|
2131
|
+
* other read omits switched-off guides, so a reader that ignores this key is
|
|
2132
|
+
* never handed one.
|
|
2133
|
+
*/
|
|
2134
|
+
readonly inactive: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
2135
|
+
/**
|
|
2136
|
+
* Beside `inactive` only: publication switched this guide off because the
|
|
2137
|
+
* published branch deleted its file, so publishing that file again switches
|
|
2138
|
+
* it back on. A switched-off guide without it was switched off by a person,
|
|
2139
|
+
* and publication leaves it off — re-sending its unchanged bytes would be a
|
|
2140
|
+
* write with nothing to do.
|
|
2141
|
+
*/
|
|
2142
|
+
readonly retiredByPublication: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
2021
2143
|
}, undefined>, v.TransformAction<{
|
|
2022
2144
|
id: string;
|
|
2023
2145
|
artifactId?: string | null | undefined;
|
|
@@ -2062,6 +2184,7 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2062
2184
|
itemVersion: number;
|
|
2063
2185
|
itemChangedSince: boolean;
|
|
2064
2186
|
deliveredCount: number;
|
|
2187
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
2065
2188
|
threadId: string;
|
|
2066
2189
|
replyToId: string | null;
|
|
2067
2190
|
repliesWithheld?: number | undefined;
|
|
@@ -2073,6 +2196,8 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2073
2196
|
branch?: string | undefined;
|
|
2074
2197
|
} | null | undefined;
|
|
2075
2198
|
removed?: true | undefined;
|
|
2199
|
+
inactive?: true | undefined;
|
|
2200
|
+
retiredByPublication?: true | undefined;
|
|
2076
2201
|
}, {
|
|
2077
2202
|
type: string;
|
|
2078
2203
|
id: string;
|
|
@@ -2117,6 +2242,7 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2117
2242
|
itemVersion: number;
|
|
2118
2243
|
itemChangedSince: boolean;
|
|
2119
2244
|
deliveredCount: number;
|
|
2245
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
2120
2246
|
threadId: string;
|
|
2121
2247
|
replyToId: string | null;
|
|
2122
2248
|
repliesWithheld?: number | undefined;
|
|
@@ -2128,6 +2254,8 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2128
2254
|
branch?: string | undefined;
|
|
2129
2255
|
} | null | undefined;
|
|
2130
2256
|
removed?: true | undefined;
|
|
2257
|
+
inactive?: true | undefined;
|
|
2258
|
+
retiredByPublication?: true | undefined;
|
|
2131
2259
|
}>]>, undefined>;
|
|
2132
2260
|
/**
|
|
2133
2261
|
* The markers every comment `body` in this response is wrapped in, plus a
|
|
@@ -2300,6 +2428,19 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2300
2428
|
* that the server handed it over.
|
|
2301
2429
|
*/
|
|
2302
2430
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
2431
|
+
/**
|
|
2432
|
+
* On a root: true when the item changed after an earlier read was last
|
|
2433
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
2434
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
2435
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
2436
|
+
*
|
|
2437
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
2438
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
2439
|
+
* changes again. A comment never handed over before is never flagged.
|
|
2440
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
2441
|
+
* a reply.
|
|
2442
|
+
*/
|
|
2443
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2303
2444
|
/**
|
|
2304
2445
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
2305
2446
|
*
|
|
@@ -2348,10 +2489,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2348
2489
|
itemVersion: number;
|
|
2349
2490
|
itemChangedSince: boolean;
|
|
2350
2491
|
deliveredCount: number;
|
|
2492
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
2351
2493
|
threadId: string;
|
|
2352
2494
|
replyToId: string | null;
|
|
2353
2495
|
repliesWithheld?: number | undefined;
|
|
2354
|
-
}[],
|
|
2496
|
+
}[], number, undefined>]>, undefined>;
|
|
2355
2497
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
2356
2498
|
/**
|
|
2357
2499
|
* Present iff this artifact is owned by git. Absent means Mossbear owns it
|
|
@@ -2421,6 +2563,22 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2421
2563
|
* than a tombstone that says no.
|
|
2422
2564
|
*/
|
|
2423
2565
|
readonly removed: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
2566
|
+
/**
|
|
2567
|
+
* This guide is switched off. Served only to a read that asked for the
|
|
2568
|
+
* bundle's inventory (`inactive=include`), which the publishers make so a
|
|
2569
|
+
* switched-off guide is updated in place rather than created again. Every
|
|
2570
|
+
* other read omits switched-off guides, so a reader that ignores this key is
|
|
2571
|
+
* never handed one.
|
|
2572
|
+
*/
|
|
2573
|
+
readonly inactive: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
2574
|
+
/**
|
|
2575
|
+
* Beside `inactive` only: publication switched this guide off because the
|
|
2576
|
+
* published branch deleted its file, so publishing that file again switches
|
|
2577
|
+
* it back on. A switched-off guide without it was switched off by a person,
|
|
2578
|
+
* and publication leaves it off — re-sending its unchanged bytes would be a
|
|
2579
|
+
* write with nothing to do.
|
|
2580
|
+
*/
|
|
2581
|
+
readonly retiredByPublication: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
2424
2582
|
}, undefined>, v.TransformAction<{
|
|
2425
2583
|
id: string;
|
|
2426
2584
|
artifactId?: string | null | undefined;
|
|
@@ -2465,6 +2623,7 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2465
2623
|
itemVersion: number;
|
|
2466
2624
|
itemChangedSince: boolean;
|
|
2467
2625
|
deliveredCount: number;
|
|
2626
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
2468
2627
|
threadId: string;
|
|
2469
2628
|
replyToId: string | null;
|
|
2470
2629
|
repliesWithheld?: number | undefined;
|
|
@@ -2476,6 +2635,8 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2476
2635
|
branch?: string | undefined;
|
|
2477
2636
|
} | null | undefined;
|
|
2478
2637
|
removed?: true | undefined;
|
|
2638
|
+
inactive?: true | undefined;
|
|
2639
|
+
retiredByPublication?: true | undefined;
|
|
2479
2640
|
}, {
|
|
2480
2641
|
type: string;
|
|
2481
2642
|
id: string;
|
|
@@ -2520,6 +2681,7 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2520
2681
|
itemVersion: number;
|
|
2521
2682
|
itemChangedSince: boolean;
|
|
2522
2683
|
deliveredCount: number;
|
|
2684
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
2523
2685
|
threadId: string;
|
|
2524
2686
|
replyToId: string | null;
|
|
2525
2687
|
repliesWithheld?: number | undefined;
|
|
@@ -2531,6 +2693,8 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2531
2693
|
branch?: string | undefined;
|
|
2532
2694
|
} | null | undefined;
|
|
2533
2695
|
removed?: true | undefined;
|
|
2696
|
+
inactive?: true | undefined;
|
|
2697
|
+
retiredByPublication?: true | undefined;
|
|
2534
2698
|
}>]>, undefined>;
|
|
2535
2699
|
readonly untrusted: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
|
|
2536
2700
|
readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
@@ -2548,6 +2712,41 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2548
2712
|
* losing the tail silently.
|
|
2549
2713
|
*/
|
|
2550
2714
|
export declare const MAX_COMMENT_BUNDLE_IDS = 100;
|
|
2715
|
+
/**
|
|
2716
|
+
* `POST /api/v1/context/comments/resolve`: close one open comment and leave the
|
|
2717
|
+
* agent's note as a reply in its thread.
|
|
2718
|
+
*
|
|
2719
|
+
* **Two ways to find the comment, never both at once.** Without `artifactId`,
|
|
2720
|
+
* the id is looked up among the comments the named bundles deliver, which is
|
|
2721
|
+
* what `list_comments` listed. With it, the id is looked up among that one
|
|
2722
|
+
* artifact's open comments, which is what its feedback read listed, after the
|
|
2723
|
+
* same read check that read makes. A request with `artifactId` does not fall
|
|
2724
|
+
* back to the bundles when the id is not on that artifact.
|
|
2725
|
+
*/
|
|
2726
|
+
export declare const ResolveItemCommentRequestSchema: v.ObjectSchema<{
|
|
2727
|
+
/** The comment's id, or a unique prefix of it as a read printed it. */
|
|
2728
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
2729
|
+
/** One line, kept in the thread as the agent's reply. */
|
|
2730
|
+
readonly note: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>, v.RegexAction<string, undefined>]>;
|
|
2731
|
+
/** The bundles this repo receives. Ignored when `artifactId` is sent. */
|
|
2732
|
+
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>]>, readonly []>;
|
|
2733
|
+
/** The artifact the comment is on, as its feedback read was asked for it. */
|
|
2734
|
+
readonly artifactId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>, undefined>;
|
|
2735
|
+
/**
|
|
2736
|
+
* The reader's repo, as its committed `project.id`. A comment drafted from
|
|
2737
|
+
* one repo's corrections is listed only to a read that declares that repo,
|
|
2738
|
+
* so it is resolvable only by one that declares it too.
|
|
2739
|
+
*/
|
|
2740
|
+
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>;
|
|
2741
|
+
/** The CLI's version, so a draft resolves only for a client that marks drafts. */
|
|
2742
|
+
readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
2743
|
+
}, undefined>;
|
|
2744
|
+
export type ResolveItemCommentRequest = v.InferInput<typeof ResolveItemCommentRequestSchema>;
|
|
2745
|
+
/** A resolve the server carried out. Every refusal is an error response instead. */
|
|
2746
|
+
export declare const ResolveItemCommentResponseSchema: v.ObjectSchema<{
|
|
2747
|
+
readonly resolved: v.LiteralSchema<true, undefined>;
|
|
2748
|
+
}, undefined>;
|
|
2749
|
+
export type ResolveItemCommentResponse = v.InferOutput<typeof ResolveItemCommentResponseSchema>;
|
|
2551
2750
|
/**
|
|
2552
2751
|
* How many times one subscriber is told, in one repo, that a given comment is
|
|
2553
2752
|
* waiting before the hook falls silent about it.
|
|
@@ -2594,6 +2793,12 @@ export declare const AnnounceItemCommentsRequestSchema: v.ObjectSchema<{
|
|
|
2594
2793
|
* filtered by the caller's own workspace membership.
|
|
2595
2794
|
*/
|
|
2596
2795
|
readonly bundleIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>;
|
|
2796
|
+
/**
|
|
2797
|
+
* The release asking. A person's reply on a thread counts as waiting only
|
|
2798
|
+
* for a release that renders threads; without it the answer is the roots-only
|
|
2799
|
+
* count every older release was given.
|
|
2800
|
+
*/
|
|
2801
|
+
readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
2597
2802
|
}, undefined>;
|
|
2598
2803
|
export type AnnounceItemCommentsRequest = v.InferOutput<typeof AnnounceItemCommentsRequestSchema>;
|
|
2599
2804
|
/**
|
|
@@ -2675,6 +2880,19 @@ export declare const AgentCommentRequestSchema: v.ObjectSchema<{
|
|
|
2675
2880
|
readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
|
|
2676
2881
|
readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
2677
2882
|
}, undefined>;
|
|
2883
|
+
/**
|
|
2884
|
+
* The reader's repo, as its committed `project.id`. A reply may name a
|
|
2885
|
+
* comment by the unique id prefix `list_comments` printed, and a comment
|
|
2886
|
+
* drafted from one repo's corrections is listed only to a read that declares
|
|
2887
|
+
* that repo, so it is matched only by a reply that declares it too.
|
|
2888
|
+
*/
|
|
2889
|
+
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>;
|
|
2890
|
+
/**
|
|
2891
|
+
* The bundles the reader's `list_comments` was scoped to, so an id prefix
|
|
2892
|
+
* printed there is matched among exactly those bundles. Without it the prefix
|
|
2893
|
+
* is matched among every bundle the caller can reach.
|
|
2894
|
+
*/
|
|
2895
|
+
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>;
|
|
2678
2896
|
}, undefined>;
|
|
2679
2897
|
export type AgentCommentRequest = v.InferOutput<typeof AgentCommentRequestSchema>;
|
|
2680
2898
|
/**
|
|
@@ -2776,6 +2994,19 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
|
|
|
2776
2994
|
* that the server handed it over.
|
|
2777
2995
|
*/
|
|
2778
2996
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
2997
|
+
/**
|
|
2998
|
+
* On a root: true when the item changed after an earlier read was last
|
|
2999
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
3000
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
3001
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
3002
|
+
*
|
|
3003
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
3004
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
3005
|
+
* changes again. A comment never handed over before is never flagged.
|
|
3006
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
3007
|
+
* a reply.
|
|
3008
|
+
*/
|
|
3009
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2779
3010
|
/**
|
|
2780
3011
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
2781
3012
|
*
|
|
@@ -2885,6 +3116,19 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
|
|
|
2885
3116
|
* that the server handed it over.
|
|
2886
3117
|
*/
|
|
2887
3118
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
3119
|
+
/**
|
|
3120
|
+
* On a root: true when the item changed after an earlier read was last
|
|
3121
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
3122
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
3123
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
3124
|
+
*
|
|
3125
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
3126
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
3127
|
+
* changes again. A comment never handed over before is never flagged.
|
|
3128
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
3129
|
+
* a reply.
|
|
3130
|
+
*/
|
|
3131
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2888
3132
|
/**
|
|
2889
3133
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
2890
3134
|
*
|
|
@@ -2946,10 +3190,12 @@ export declare const CommentEvidenceCitationSchema: v.ObjectSchema<{
|
|
|
2946
3190
|
* `navigation` is a skill load counted when a finding was drafted from how
|
|
2947
3191
|
* the skill's files were read: evidence of how a skill was used, not of a
|
|
2948
3192
|
* failure. `action` is a recorded step of a workflow repeated across
|
|
2949
|
-
* sessions.
|
|
2950
|
-
*
|
|
3193
|
+
* sessions. `discrepancy` is a grader's note that a session's closing report
|
|
3194
|
+
* contradicted its recorded actions; its excerpt is the agent's quoted claim
|
|
3195
|
+
* and the record. A server sends `action` and `discrepancy` only to a client
|
|
3196
|
+
* that names a version new enough to parse them.
|
|
2951
3197
|
*/
|
|
2952
|
-
readonly kind: v.PicklistSchema<["verdict", "turn", "navigation", "action"], undefined>;
|
|
3198
|
+
readonly kind: v.PicklistSchema<["verdict", "turn", "navigation", "action", "discrepancy"], undefined>;
|
|
2953
3199
|
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2954
3200
|
/** ISO, when the verdict was graded, the turn was said, the skill loaded, or the action was recorded. */
|
|
2955
3201
|
readonly at: v.StringSchema<undefined>;
|
|
@@ -3064,10 +3310,12 @@ export declare const CommentEvidenceResponseSchema: v.ObjectSchema<{
|
|
|
3064
3310
|
* `navigation` is a skill load counted when a finding was drafted from how
|
|
3065
3311
|
* the skill's files were read: evidence of how a skill was used, not of a
|
|
3066
3312
|
* failure. `action` is a recorded step of a workflow repeated across
|
|
3067
|
-
* sessions.
|
|
3068
|
-
*
|
|
3313
|
+
* sessions. `discrepancy` is a grader's note that a session's closing report
|
|
3314
|
+
* contradicted its recorded actions; its excerpt is the agent's quoted claim
|
|
3315
|
+
* and the record. A server sends `action` and `discrepancy` only to a client
|
|
3316
|
+
* that names a version new enough to parse them.
|
|
3069
3317
|
*/
|
|
3070
|
-
readonly kind: v.PicklistSchema<["verdict", "turn", "navigation", "action"], undefined>;
|
|
3318
|
+
readonly kind: v.PicklistSchema<["verdict", "turn", "navigation", "action", "discrepancy"], undefined>;
|
|
3071
3319
|
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3072
3320
|
/** ISO, when the verdict was graded, the turn was said, the skill loaded, or the action was recorded. */
|
|
3073
3321
|
readonly at: v.StringSchema<undefined>;
|
|
@@ -3498,6 +3746,19 @@ export declare const ArtifactSchema: v.ObjectSchema<{
|
|
|
3498
3746
|
* that the server handed it over.
|
|
3499
3747
|
*/
|
|
3500
3748
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
3749
|
+
/**
|
|
3750
|
+
* On a root: true when the item changed after an earlier read was last
|
|
3751
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
3752
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
3753
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
3754
|
+
*
|
|
3755
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
3756
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
3757
|
+
* changes again. A comment never handed over before is never flagged.
|
|
3758
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
3759
|
+
* a reply.
|
|
3760
|
+
*/
|
|
3761
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3501
3762
|
/**
|
|
3502
3763
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
3503
3764
|
*
|
|
@@ -3546,12 +3807,53 @@ export declare const ArtifactSchema: v.ObjectSchema<{
|
|
|
3546
3807
|
itemVersion: number;
|
|
3547
3808
|
itemChangedSince: boolean;
|
|
3548
3809
|
deliveredCount: number;
|
|
3810
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
3549
3811
|
threadId: string;
|
|
3550
3812
|
replyToId: string | null;
|
|
3551
3813
|
repliesWithheld?: number | undefined;
|
|
3552
|
-
}[],
|
|
3814
|
+
}[], number, undefined>]>, undefined>;
|
|
3553
3815
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
3554
3816
|
}, undefined>;
|
|
3817
|
+
/**
|
|
3818
|
+
* A guide publication: the bytes at an agent-guidance path, published from the
|
|
3819
|
+
* repository that homes the bundle, land as a guide rather than a document.
|
|
3820
|
+
*
|
|
3821
|
+
* `format` is the discovery format of the path, the one import records.
|
|
3822
|
+
* `members` is a skill's member files, relative to its directory, and is
|
|
3823
|
+
* authoritative when present: a stored member it omits is removed, unless it
|
|
3824
|
+
* is listed in `skippedPaths` (present at the ref, but not sendable). Only a
|
|
3825
|
+
* `skill-md` publication carries members.
|
|
3826
|
+
*/
|
|
3827
|
+
export declare const GuidePublishSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
|
|
3828
|
+
readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
|
|
3829
|
+
readonly members: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
|
|
3830
|
+
readonly path: v.SchemaWithPipe<readonly [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">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
|
|
3831
|
+
readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
|
|
3832
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
3833
|
+
path: string;
|
|
3834
|
+
content: string;
|
|
3835
|
+
}[], 64, undefined>, v.CheckAction<{
|
|
3836
|
+
path: string;
|
|
3837
|
+
content: string;
|
|
3838
|
+
}[], "member paths must be unique (case-insensitive)">]>, undefined>;
|
|
3839
|
+
readonly skippedPaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>, v.MaxLengthAction<string[], 256, undefined>]>, undefined>;
|
|
3840
|
+
/**
|
|
3841
|
+
* The repository's other copies of this file, such as a skill's twin in
|
|
3842
|
+
* the other skills folder, each published as an alias of this guide rather
|
|
3843
|
+
* than a guide of its own. Each must be an alias path of the published one
|
|
3844
|
+
* (`aliasPathSiblings`). Additive: an alias it omits is kept.
|
|
3845
|
+
*/
|
|
3846
|
+
readonly aliases: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<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>, v.MaxLengthAction<string[], 8, undefined>]>, undefined>;
|
|
3847
|
+
}, undefined>, v.CheckAction<{
|
|
3848
|
+
format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
|
|
3849
|
+
members?: {
|
|
3850
|
+
path: string;
|
|
3851
|
+
content: string;
|
|
3852
|
+
}[] | undefined;
|
|
3853
|
+
skippedPaths?: string[] | undefined;
|
|
3854
|
+
aliases?: string[] | undefined;
|
|
3855
|
+
}, "only a skill-md guide carries members">]>;
|
|
3856
|
+
export type GuidePublish = v.InferOutput<typeof GuidePublishSchema>;
|
|
3555
3857
|
/**
|
|
3556
3858
|
* Create an artifact. Always a create: it takes no id, and an update is a
|
|
3557
3859
|
* separate request. `bundle` is optional for an unrestricted caller, who files
|
|
@@ -3633,6 +3935,47 @@ export declare const CreateArtifactRequestSchema: v.StrictObjectSchema<{
|
|
|
3633
3935
|
*/
|
|
3634
3936
|
readonly branch: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
3635
3937
|
}, undefined>, undefined>;
|
|
3938
|
+
/**
|
|
3939
|
+
* The agent session that wrote this revision, as its harness names it (the id
|
|
3940
|
+
* `create_comment` resolves). Recorded in the saved version's `metadata`, and
|
|
3941
|
+
* absent when the writer could not tell. Provenance only: it grants nothing
|
|
3942
|
+
* and is not shown as authorship.
|
|
3943
|
+
*/
|
|
3944
|
+
readonly agentSessionId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>, undefined>;
|
|
3945
|
+
/**
|
|
3946
|
+
* Publish this path as a guide ({@link GuidePublishSchema}). The one way an
|
|
3947
|
+
* agent-guidance `path` is accepted: the route also requires `gitSource` and
|
|
3948
|
+
* a `bundle` whose home is `projectId`.
|
|
3949
|
+
*/
|
|
3950
|
+
readonly guide: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
|
|
3951
|
+
readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
|
|
3952
|
+
readonly members: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
|
|
3953
|
+
readonly path: v.SchemaWithPipe<readonly [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">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
|
|
3954
|
+
readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
|
|
3955
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
3956
|
+
path: string;
|
|
3957
|
+
content: string;
|
|
3958
|
+
}[], 64, undefined>, v.CheckAction<{
|
|
3959
|
+
path: string;
|
|
3960
|
+
content: string;
|
|
3961
|
+
}[], "member paths must be unique (case-insensitive)">]>, undefined>;
|
|
3962
|
+
readonly skippedPaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>, v.MaxLengthAction<string[], 256, undefined>]>, undefined>;
|
|
3963
|
+
/**
|
|
3964
|
+
* The repository's other copies of this file, such as a skill's twin in
|
|
3965
|
+
* the other skills folder, each published as an alias of this guide rather
|
|
3966
|
+
* than a guide of its own. Each must be an alias path of the published one
|
|
3967
|
+
* (`aliasPathSiblings`). Additive: an alias it omits is kept.
|
|
3968
|
+
*/
|
|
3969
|
+
readonly aliases: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<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>, v.MaxLengthAction<string[], 8, undefined>]>, undefined>;
|
|
3970
|
+
}, undefined>, v.CheckAction<{
|
|
3971
|
+
format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
|
|
3972
|
+
members?: {
|
|
3973
|
+
path: string;
|
|
3974
|
+
content: string;
|
|
3975
|
+
}[] | undefined;
|
|
3976
|
+
skippedPaths?: string[] | undefined;
|
|
3977
|
+
aliases?: string[] | undefined;
|
|
3978
|
+
}, "only a skill-md guide carries members">]>, undefined>;
|
|
3636
3979
|
}, undefined>;
|
|
3637
3980
|
/**
|
|
3638
3981
|
* Update an existing artifact's content. The id is in the route. The version the
|
|
@@ -3711,6 +4054,46 @@ export declare const UpdateArtifactRequestSchema: v.StrictObjectSchema<{
|
|
|
3711
4054
|
*/
|
|
3712
4055
|
readonly branch: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
|
|
3713
4056
|
}, undefined>, undefined>;
|
|
4057
|
+
/**
|
|
4058
|
+
* The agent session that wrote this revision, as its harness names it (the id
|
|
4059
|
+
* `create_comment` resolves). Recorded in the saved version's `metadata`, and
|
|
4060
|
+
* absent when the writer could not tell. Provenance only: it grants nothing
|
|
4061
|
+
* and is not shown as authorship.
|
|
4062
|
+
*/
|
|
4063
|
+
readonly agentSessionId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>, undefined>;
|
|
4064
|
+
/**
|
|
4065
|
+
* A guide publication's members ({@link GuidePublishSchema}), written after
|
|
4066
|
+
* the body. Accepted only on a guide's body, beside a `gitSource`.
|
|
4067
|
+
*/
|
|
4068
|
+
readonly guide: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
|
|
4069
|
+
readonly format: v.PicklistSchema<["agents-md", "agents-dir", "claude-md", "claude-rules", "cursorrules", "cursor-rules", "skill-md"], undefined>;
|
|
4070
|
+
readonly members: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
|
|
4071
|
+
readonly path: v.SchemaWithPipe<readonly [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">]>, v.CheckAction<string, "path must not shadow the skill’s own SKILL.md">]>;
|
|
4072
|
+
readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "rawContent must be at most 524288 bytes">]>;
|
|
4073
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
4074
|
+
path: string;
|
|
4075
|
+
content: string;
|
|
4076
|
+
}[], 64, undefined>, v.CheckAction<{
|
|
4077
|
+
path: string;
|
|
4078
|
+
content: string;
|
|
4079
|
+
}[], "member paths must be unique (case-insensitive)">]>, undefined>;
|
|
4080
|
+
readonly skippedPaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>, v.MaxLengthAction<string[], 256, undefined>]>, undefined>;
|
|
4081
|
+
/**
|
|
4082
|
+
* The repository's other copies of this file, such as a skill's twin in
|
|
4083
|
+
* the other skills folder, each published as an alias of this guide rather
|
|
4084
|
+
* than a guide of its own. Each must be an alias path of the published one
|
|
4085
|
+
* (`aliasPathSiblings`). Additive: an alias it omits is kept.
|
|
4086
|
+
*/
|
|
4087
|
+
readonly aliases: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<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>, v.MaxLengthAction<string[], 8, undefined>]>, undefined>;
|
|
4088
|
+
}, undefined>, v.CheckAction<{
|
|
4089
|
+
format: "agents-md" | "agents-dir" | "claude-md" | "claude-rules" | "cursorrules" | "cursor-rules" | "skill-md";
|
|
4090
|
+
members?: {
|
|
4091
|
+
path: string;
|
|
4092
|
+
content: string;
|
|
4093
|
+
}[] | undefined;
|
|
4094
|
+
skippedPaths?: string[] | undefined;
|
|
4095
|
+
aliases?: string[] | undefined;
|
|
4096
|
+
}, "only a skill-md guide carries members">]>, undefined>;
|
|
3714
4097
|
}, undefined>;
|
|
3715
4098
|
/**
|
|
3716
4099
|
* Tombstone an artifact: the commit that published it has since deleted the
|
|
@@ -3897,6 +4280,19 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
|
|
|
3897
4280
|
* that the server handed it over.
|
|
3898
4281
|
*/
|
|
3899
4282
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
4283
|
+
/**
|
|
4284
|
+
* On a root: true when the item changed after an earlier read was last
|
|
4285
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
4286
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
4287
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
4288
|
+
*
|
|
4289
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
4290
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
4291
|
+
* changes again. A comment never handed over before is never flagged.
|
|
4292
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
4293
|
+
* a reply.
|
|
4294
|
+
*/
|
|
4295
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3900
4296
|
/**
|
|
3901
4297
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
3902
4298
|
*
|
|
@@ -3945,10 +4341,11 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
|
|
|
3945
4341
|
itemVersion: number;
|
|
3946
4342
|
itemChangedSince: boolean;
|
|
3947
4343
|
deliveredCount: number;
|
|
4344
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
3948
4345
|
threadId: string;
|
|
3949
4346
|
replyToId: string | null;
|
|
3950
4347
|
repliesWithheld?: number | undefined;
|
|
3951
|
-
}[],
|
|
4348
|
+
}[], number, undefined>]>, undefined>;
|
|
3952
4349
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
3953
4350
|
}, undefined>;
|
|
3954
4351
|
readonly revision: v.ObjectSchema<{
|
|
@@ -4077,6 +4474,19 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
4077
4474
|
* that the server handed it over.
|
|
4078
4475
|
*/
|
|
4079
4476
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
4477
|
+
/**
|
|
4478
|
+
* On a root: true when the item changed after an earlier read was last
|
|
4479
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
4480
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
4481
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
4482
|
+
*
|
|
4483
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
4484
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
4485
|
+
* changes again. A comment never handed over before is never flagged.
|
|
4486
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
4487
|
+
* a reply.
|
|
4488
|
+
*/
|
|
4489
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
4080
4490
|
/**
|
|
4081
4491
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
4082
4492
|
*
|
|
@@ -4125,10 +4535,11 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
4125
4535
|
itemVersion: number;
|
|
4126
4536
|
itemChangedSince: boolean;
|
|
4127
4537
|
deliveredCount: number;
|
|
4538
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
4128
4539
|
threadId: string;
|
|
4129
4540
|
replyToId: string | null;
|
|
4130
4541
|
repliesWithheld?: number | undefined;
|
|
4131
|
-
}[],
|
|
4542
|
+
}[], number, undefined>]>, undefined>;
|
|
4132
4543
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
4133
4544
|
}, undefined>;
|
|
4134
4545
|
}, undefined>;
|
|
@@ -4244,6 +4655,19 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
4244
4655
|
* that the server handed it over.
|
|
4245
4656
|
*/
|
|
4246
4657
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
4658
|
+
/**
|
|
4659
|
+
* On a root: true when the item changed after an earlier read was last
|
|
4660
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
4661
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
4662
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
4663
|
+
*
|
|
4664
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
4665
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
4666
|
+
* changes again. A comment never handed over before is never flagged.
|
|
4667
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
4668
|
+
* a reply.
|
|
4669
|
+
*/
|
|
4670
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
4247
4671
|
/**
|
|
4248
4672
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
4249
4673
|
*
|
|
@@ -4292,10 +4716,11 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
4292
4716
|
itemVersion: number;
|
|
4293
4717
|
itemChangedSince: boolean;
|
|
4294
4718
|
deliveredCount: number;
|
|
4719
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
4295
4720
|
threadId: string;
|
|
4296
4721
|
replyToId: string | null;
|
|
4297
4722
|
repliesWithheld?: number | undefined;
|
|
4298
|
-
}[],
|
|
4723
|
+
}[], number, undefined>]>, undefined>;
|
|
4299
4724
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
4300
4725
|
}, undefined>;
|
|
4301
4726
|
}, undefined>;
|
|
@@ -4412,6 +4837,19 @@ export declare const RemoveArtifactResponseSchema: v.ObjectSchema<{
|
|
|
4412
4837
|
* that the server handed it over.
|
|
4413
4838
|
*/
|
|
4414
4839
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
4840
|
+
/**
|
|
4841
|
+
* On a root: true when the item changed after an earlier read was last
|
|
4842
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
4843
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
4844
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
4845
|
+
*
|
|
4846
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
4847
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
4848
|
+
* changes again. A comment never handed over before is never flagged.
|
|
4849
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
4850
|
+
* a reply.
|
|
4851
|
+
*/
|
|
4852
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
4415
4853
|
/**
|
|
4416
4854
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
4417
4855
|
*
|
|
@@ -4460,10 +4898,11 @@ export declare const RemoveArtifactResponseSchema: v.ObjectSchema<{
|
|
|
4460
4898
|
itemVersion: number;
|
|
4461
4899
|
itemChangedSince: boolean;
|
|
4462
4900
|
deliveredCount: number;
|
|
4901
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
4463
4902
|
threadId: string;
|
|
4464
4903
|
replyToId: string | null;
|
|
4465
4904
|
repliesWithheld?: number | undefined;
|
|
4466
|
-
}[],
|
|
4905
|
+
}[], number, undefined>]>, undefined>;
|
|
4467
4906
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
4468
4907
|
}, undefined>;
|
|
4469
4908
|
}, undefined>;
|
|
@@ -4614,6 +5053,63 @@ export declare const ArtifactVersionConflictSchema: v.ObjectSchema<{
|
|
|
4614
5053
|
readonly expectedVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
|
|
4615
5054
|
readonly requestId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
4616
5055
|
}, undefined>;
|
|
5056
|
+
/**
|
|
5057
|
+
* Save a draft of an artifact from a git branch. One draft per artifact,
|
|
5058
|
+
* author and branch, so a second upload from the same branch replaces the
|
|
5059
|
+
* first. `baseVersion` is the artifact version the branch's bytes were
|
|
5060
|
+
* compared with; publishing the draft later sends it as `expectedVersion`.
|
|
5061
|
+
* Content equal to the artifact's current content stores nothing and removes
|
|
5062
|
+
* any draft from that branch, because it has landed.
|
|
5063
|
+
*/
|
|
5064
|
+
export declare const UpsertArtifactDraftRequestSchema: v.StrictObjectSchema<{
|
|
5065
|
+
readonly branch: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
|
|
5066
|
+
readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 524288 bytes">]>;
|
|
5067
|
+
readonly baseVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
|
|
5068
|
+
readonly gitCommit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "commitSha must be 40 or 64 lowercase hex characters">]>, undefined>;
|
|
5069
|
+
}, undefined>;
|
|
5070
|
+
/**
|
|
5071
|
+
* One of the caller's drafts. `branch` is null for a draft written in the
|
|
5072
|
+
* dashboard or by an agent rather than uploaded from git.
|
|
5073
|
+
*/
|
|
5074
|
+
export declare const ArtifactDraftSchema: v.ObjectSchema<{
|
|
5075
|
+
readonly id: v.StringSchema<undefined>;
|
|
5076
|
+
readonly artifactId: v.StringSchema<undefined>;
|
|
5077
|
+
readonly branch: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5078
|
+
readonly gitCommit: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5079
|
+
readonly content: v.StringSchema<undefined>;
|
|
5080
|
+
readonly contentHash: v.StringSchema<undefined>;
|
|
5081
|
+
readonly baseVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
|
|
5082
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
5083
|
+
readonly updatedAt: v.StringSchema<undefined>;
|
|
5084
|
+
}, undefined>;
|
|
5085
|
+
/** `draft` is null when the content had already landed and nothing was kept. */
|
|
5086
|
+
export declare const UpsertArtifactDraftResponseSchema: v.ObjectSchema<{
|
|
5087
|
+
readonly draft: v.NullableSchema<v.ObjectSchema<{
|
|
5088
|
+
readonly id: v.StringSchema<undefined>;
|
|
5089
|
+
readonly artifactId: v.StringSchema<undefined>;
|
|
5090
|
+
readonly branch: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5091
|
+
readonly gitCommit: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5092
|
+
readonly content: v.StringSchema<undefined>;
|
|
5093
|
+
readonly contentHash: v.StringSchema<undefined>;
|
|
5094
|
+
readonly baseVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
|
|
5095
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
5096
|
+
readonly updatedAt: v.StringSchema<undefined>;
|
|
5097
|
+
}, undefined>, undefined>;
|
|
5098
|
+
}, undefined>;
|
|
5099
|
+
/** The caller's own drafts of one artifact, most recently updated first. */
|
|
5100
|
+
export declare const ListArtifactDraftsResponseSchema: v.ObjectSchema<{
|
|
5101
|
+
readonly drafts: v.ArraySchema<v.ObjectSchema<{
|
|
5102
|
+
readonly id: v.StringSchema<undefined>;
|
|
5103
|
+
readonly artifactId: v.StringSchema<undefined>;
|
|
5104
|
+
readonly branch: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5105
|
+
readonly gitCommit: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5106
|
+
readonly content: v.StringSchema<undefined>;
|
|
5107
|
+
readonly contentHash: v.StringSchema<undefined>;
|
|
5108
|
+
readonly baseVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
|
|
5109
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
5110
|
+
readonly updatedAt: v.StringSchema<undefined>;
|
|
5111
|
+
}, undefined>, undefined>;
|
|
5112
|
+
}, undefined>;
|
|
4617
5113
|
export declare const ProposalCitationSchema: v.ObjectSchema<{
|
|
4618
5114
|
readonly agentSessionId: v.StringSchema<undefined>;
|
|
4619
5115
|
readonly timestamp: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
@@ -6147,6 +6643,11 @@ export declare const ArtifactFeedbackQuerySchema: v.ObjectSchema<{
|
|
|
6147
6643
|
* correction drafted for one repo is withheld, as on the comments read.
|
|
6148
6644
|
*/
|
|
6149
6645
|
readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
6646
|
+
/**
|
|
6647
|
+
* The release asking. Replies on a thread are sent only to one that renders
|
|
6648
|
+
* threads; without it the page is roots only, as it was.
|
|
6649
|
+
*/
|
|
6650
|
+
readonly cli: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
6150
6651
|
}, undefined>;
|
|
6151
6652
|
export type ArtifactFeedbackQuery = v.InferOutput<typeof ArtifactFeedbackQuerySchema>;
|
|
6152
6653
|
/**
|
|
@@ -6243,6 +6744,19 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
|
|
|
6243
6744
|
* that the server handed it over.
|
|
6244
6745
|
*/
|
|
6245
6746
|
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
6747
|
+
/**
|
|
6748
|
+
* On a root: true when the item changed after an earlier read was last
|
|
6749
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
6750
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
6751
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
6752
|
+
*
|
|
6753
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
6754
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
6755
|
+
* changes again. A comment never handed over before is never flagged.
|
|
6756
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
6757
|
+
* a reply.
|
|
6758
|
+
*/
|
|
6759
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6246
6760
|
/**
|
|
6247
6761
|
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
6248
6762
|
*
|
|
@@ -6463,6 +6977,346 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
|
|
|
6463
6977
|
}, undefined>, undefined>;
|
|
6464
6978
|
}, undefined>;
|
|
6465
6979
|
export type ArtifactFeedbackResponse = v.InferOutput<typeof ArtifactFeedbackResponseSchema>;
|
|
6980
|
+
/** Most artifacts one batch feedback read may name. */
|
|
6981
|
+
export declare const MAX_ARTIFACT_FEEDBACK_BATCH = 25;
|
|
6982
|
+
/**
|
|
6983
|
+
* `POST /api/v1/artifacts/feedback` body: several artifacts read at once, each
|
|
6984
|
+
* paged as `GET .../:id/feedback` pages it (`cursor` is that artifact's own
|
|
6985
|
+
* `nextCursor`). `project` and `cli` mean what they mean on the single read.
|
|
6986
|
+
*/
|
|
6987
|
+
export declare const ArtifactFeedbackBatchRequestSchema: v.ObjectSchema<{
|
|
6988
|
+
readonly artifacts: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
6989
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>]>;
|
|
6990
|
+
readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "cursor is not a feedback cursor">]>, undefined>;
|
|
6991
|
+
}, undefined>, undefined>, v.MinLengthAction<{
|
|
6992
|
+
id: string;
|
|
6993
|
+
cursor?: string | undefined;
|
|
6994
|
+
}[], 1, undefined>, v.MaxLengthAction<{
|
|
6995
|
+
id: string;
|
|
6996
|
+
cursor?: string | undefined;
|
|
6997
|
+
}[], 25, undefined>]>;
|
|
6998
|
+
readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
6999
|
+
readonly cli: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
7000
|
+
}, undefined>;
|
|
7001
|
+
export type ArtifactFeedbackBatchRequest = v.InferOutput<typeof ArtifactFeedbackBatchRequestSchema>;
|
|
7002
|
+
/**
|
|
7003
|
+
* One entry per requested id, in request order. `feedback` is null for an id
|
|
7004
|
+
* the caller cannot read, missing or out of scope alike, and carries nothing
|
|
7005
|
+
* else about it; the other entries are unaffected. A read that failed is
|
|
7006
|
+
* `unavailable: true` instead, and nothing of it was counted as delivered.
|
|
7007
|
+
*/
|
|
7008
|
+
export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
|
|
7009
|
+
readonly artifacts: v.ArraySchema<v.ObjectSchema<{
|
|
7010
|
+
readonly id: v.StringSchema<undefined>;
|
|
7011
|
+
readonly feedback: v.NullableSchema<v.ObjectSchema<{
|
|
7012
|
+
readonly artifactId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7013
|
+
/** The artifact's current version, as `read` reports it. */
|
|
7014
|
+
readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
|
|
7015
|
+
/** Open comments, oldest first by `(createdAt, id)`. */
|
|
7016
|
+
readonly comments: v.ArraySchema<v.ObjectSchema<{
|
|
7017
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7018
|
+
readonly state: v.OptionalSchema<v.PicklistSchema<["open", "resolved"], undefined>, undefined>;
|
|
7019
|
+
/** Current source location of an anchored passage, or its lost quote. */
|
|
7020
|
+
readonly passage: v.OptionalSchema<v.ObjectSchema<{
|
|
7021
|
+
readonly quote: v.StringSchema<undefined>;
|
|
7022
|
+
readonly status: v.PicklistSchema<["located", "changed", "orphaned"], undefined>;
|
|
7023
|
+
readonly lines: v.NullableSchema<v.ObjectSchema<{
|
|
7024
|
+
readonly start: v.NumberSchema<undefined>;
|
|
7025
|
+
readonly end: v.NumberSchema<undefined>;
|
|
7026
|
+
}, undefined>, undefined>;
|
|
7027
|
+
}, undefined>, undefined>;
|
|
7028
|
+
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
7029
|
+
readonly body: v.StringSchema<undefined>;
|
|
7030
|
+
/**
|
|
7031
|
+
* What a comment Mossbear wrote is: a finding about the item, never an edit.
|
|
7032
|
+
* Present only on a Mossbear comment. The comment's `body` begins with the
|
|
7033
|
+
* claim (what goes wrong); this carries what the claim rests on.
|
|
7034
|
+
*/
|
|
7035
|
+
readonly finding: v.OptionalSchema<v.ObjectSchema<{
|
|
7036
|
+
readonly tier: v.PicklistSchema<["observed", "usage", "practice"], undefined>;
|
|
7037
|
+
/** How the finding is known, in one line: "Seen in 3 sessions (2026-09-15 – 2026-10-03)". */
|
|
7038
|
+
readonly tierLine: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 300, undefined>]>;
|
|
7039
|
+
/** What the drafter did not read, fixed per tier. */
|
|
7040
|
+
readonly blindSpot: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 300, undefined>]>;
|
|
7041
|
+
/** What should change in later sessions if the finding is fixed, wrapped in the untrusted markers. */
|
|
7042
|
+
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7043
|
+
}, undefined>, undefined>;
|
|
7044
|
+
/**
|
|
7045
|
+
* Whether the person approved a comment Mossbear drafted. Present on every
|
|
7046
|
+
* Mossbear comment and absent on a person's or an agent's, which are
|
|
7047
|
+
* requests as written. `false` is a draft nobody has read yet: a reader shows
|
|
7048
|
+
* it to the user and acts only on their go-ahead. Only a client that reports
|
|
7049
|
+
* a version able to mark drafts is ever listed one, so an older reader that
|
|
7050
|
+
* strips this field never receives a draft it would print as a request.
|
|
7051
|
+
*/
|
|
7052
|
+
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
7053
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
7054
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7055
|
+
/**
|
|
7056
|
+
* Who wrote it. Optional because a server that predates the field omits it;
|
|
7057
|
+
* a reader that meets a reply without it cannot tell whose it is, and a
|
|
7058
|
+
* server never sends a reply to a client too old to read this.
|
|
7059
|
+
*/
|
|
7060
|
+
readonly authorKind: v.OptionalSchema<v.PicklistSchema<["person", "agent", "mossbear"], undefined>, undefined>;
|
|
7061
|
+
/** ISO timestamp, machine format. */
|
|
7062
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
7063
|
+
/** The item's content version the comment was written against. */
|
|
7064
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
7065
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
7066
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
7067
|
+
/**
|
|
7068
|
+
* How many agent reads were handed this comment **before** this one — so a
|
|
7069
|
+
* comment reaching an agent for the first time reports `0`.
|
|
7070
|
+
*
|
|
7071
|
+
* It is the stored count as it read at the moment the response was built;
|
|
7072
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
7073
|
+
* than included because the count is recorded best-effort: a response that
|
|
7074
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
7075
|
+
* a number that is sometimes off by one is worse than one that is
|
|
7076
|
+
* consistently the prior total.
|
|
7077
|
+
*
|
|
7078
|
+
* So `deliveredCount > 0` means an earlier read was handed this comment, and
|
|
7079
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
7080
|
+
* that the server handed it over.
|
|
7081
|
+
*/
|
|
7082
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
7083
|
+
/**
|
|
7084
|
+
* On a root: true when the item changed after an earlier read was last
|
|
7085
|
+
* handed this comment. For a guide that is any change to its body or its
|
|
7086
|
+
* files, so a fix in a supporting file counts. A reader should check whether
|
|
7087
|
+
* the change addressed the comment, and resolve it with a note if so.
|
|
7088
|
+
*
|
|
7089
|
+
* Computed before this read is counted, so the read that carries `true` is
|
|
7090
|
+
* the one that uses it up; the next read says `false` unless the item
|
|
7091
|
+
* changes again. A comment never handed over before is never flagged.
|
|
7092
|
+
* Optional because a server that predates the field omits it, and absent on
|
|
7093
|
+
* a reply.
|
|
7094
|
+
*/
|
|
7095
|
+
readonly guideChangedSinceRead: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
7096
|
+
/**
|
|
7097
|
+
* This comment's thread root: its own id on a root, the root's id on a reply.
|
|
7098
|
+
*
|
|
7099
|
+
* **Replies ride the same flat array**, each straight after its root, oldest
|
|
7100
|
+
* first. Only a client that reports a version able to render threads is
|
|
7101
|
+
* sent them; any other reader gets roots alone, as it always did. A person's
|
|
7102
|
+
* reply is part of the thread's request. An agent's reply is context: an
|
|
7103
|
+
* earlier message on the thread, never something to act on. A root an agent
|
|
7104
|
+
* wrote is delivered only once a person has replied to it, and is then the
|
|
7105
|
+
* question that reply answers, not a request of its own.
|
|
7106
|
+
*/
|
|
7107
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7108
|
+
/**
|
|
7109
|
+
* `null` on a root; the root's id on a reply. Threads are one level deep, so
|
|
7110
|
+
* a reply's parent is always its root.
|
|
7111
|
+
*/
|
|
7112
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
7113
|
+
/**
|
|
7114
|
+
* On a root whose thread held more replies than
|
|
7115
|
+
* `MAX_REPLIES_PER_THREAD_ON_WIRE`: how many older ones were not sent.
|
|
7116
|
+
* Absent when the whole thread was sent.
|
|
7117
|
+
*/
|
|
7118
|
+
readonly repliesWithheld: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
|
|
7119
|
+
}, undefined>, undefined>;
|
|
7120
|
+
/** Absent on the last page; pass it back as `cursor` for the next. */
|
|
7121
|
+
readonly nextCursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
7122
|
+
/** The markers every comment `body` is wrapped in; present when any comment came back. */
|
|
7123
|
+
readonly untrusted: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
|
|
7124
|
+
readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7125
|
+
readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7126
|
+
readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7127
|
+
readonly note: v.StringSchema<undefined>;
|
|
7128
|
+
}, undefined>, undefined>, undefined>;
|
|
7129
|
+
readonly grading: v.NullableSchema<v.ObjectSchema<{
|
|
7130
|
+
readonly guide: v.ObjectSchema<{
|
|
7131
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7132
|
+
readonly title: v.StringSchema<undefined>;
|
|
7133
|
+
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>;
|
|
7134
|
+
readonly root: v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>;
|
|
7135
|
+
}, undefined>;
|
|
7136
|
+
/** The wording the window is about, or null when the guide has no revision identity. */
|
|
7137
|
+
readonly currentRevision: v.NullableSchema<v.ObjectSchema<{
|
|
7138
|
+
readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7139
|
+
readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7140
|
+
}, undefined>, undefined>;
|
|
7141
|
+
readonly state: v.PicklistSchema<["evaluated", "awaiting_current_revision", "unevaluated"], undefined>;
|
|
7142
|
+
readonly window: v.ObjectSchema<{
|
|
7143
|
+
/** Rows summarized, after the revision narrow. */
|
|
7144
|
+
readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7145
|
+
readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7146
|
+
readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7147
|
+
/** In context, never engaged. Neither a pass nor a failure. */
|
|
7148
|
+
readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7149
|
+
/** `aligned + misaligned` — the rate's own denominator. */
|
|
7150
|
+
readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7151
|
+
/** `aligned / applicable`, or **null when no run engaged the guide**. */
|
|
7152
|
+
readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
|
|
7153
|
+
/** The rows hit the per-guide cap: a bounded window, never a lifetime total. */
|
|
7154
|
+
readonly isWindowed: v.BooleanSchema<undefined>;
|
|
7155
|
+
/** The cap the rows were fetched under, so a reader can say what "windowed" means. */
|
|
7156
|
+
readonly windowSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7157
|
+
/**
|
|
7158
|
+
* Verdicts fetched and then dropped by the revision narrow — about wording
|
|
7159
|
+
* that is no longer current, or citing no revision at all. A **floor** rather
|
|
7160
|
+
* than a total whenever `isWindowed`, because rows past the cap were never
|
|
7161
|
+
* fetched.
|
|
7162
|
+
*/
|
|
7163
|
+
readonly olderRevisionRows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7164
|
+
/**
|
|
7165
|
+
* `applicable` is too small for the percentage to mean anything — threshold
|
|
7166
|
+
* `applicable < 3` (founder, 2026-08-22). Read the counts, not the rate.
|
|
7167
|
+
*/
|
|
7168
|
+
readonly isLowConfidence: v.BooleanSchema<undefined>;
|
|
7169
|
+
}, undefined>;
|
|
7170
|
+
/**
|
|
7171
|
+
* The last edit's two windows, or **null when there is no earlier wording to
|
|
7172
|
+
* compare against**.
|
|
7173
|
+
*
|
|
7174
|
+
* Present-and-null rather than omitted: a guide on its first revision has no
|
|
7175
|
+
* delta, and that is an answer. An absent key would leave a reader unable to
|
|
7176
|
+
* tell "no edit to measure" from "this server does not report deltas".
|
|
7177
|
+
*/
|
|
7178
|
+
readonly change: v.NullableSchema<v.ObjectSchema<{
|
|
7179
|
+
/** The revision that preceded the change. */
|
|
7180
|
+
readonly before: v.ObjectSchema<{
|
|
7181
|
+
/** The wording this side judges. */
|
|
7182
|
+
readonly revision: v.ObjectSchema<{
|
|
7183
|
+
readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7184
|
+
readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7185
|
+
}, undefined>;
|
|
7186
|
+
/** Rows in this side's window, including the runs that never engaged it. */
|
|
7187
|
+
readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7188
|
+
readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7189
|
+
readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7190
|
+
readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7191
|
+
/** `aligned + misaligned` — this side's own denominator. */
|
|
7192
|
+
readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7193
|
+
/** `aligned / applicable`, or null when no run engaged this wording. */
|
|
7194
|
+
readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
|
|
7195
|
+
/** This side is below the sample floor, so read its counts and not its rate. */
|
|
7196
|
+
readonly isLowConfidence: v.BooleanSchema<undefined>;
|
|
7197
|
+
/**
|
|
7198
|
+
* This side is a bounded sample of its revision rather than the whole record.
|
|
7199
|
+
* A saturated side beside an unsaturated one is two different kinds of
|
|
7200
|
+
* number, and comparing them without saying so is the defect the flag exists
|
|
7201
|
+
* to stop.
|
|
7202
|
+
*/
|
|
7203
|
+
readonly isSaturated: v.BooleanSchema<undefined>;
|
|
7204
|
+
/** The span this side covers, ISO. Both null on a side with no rows. */
|
|
7205
|
+
readonly newestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7206
|
+
readonly oldestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7207
|
+
}, undefined>;
|
|
7208
|
+
/** The wording the guide stands at now. */
|
|
7209
|
+
readonly since: v.ObjectSchema<{
|
|
7210
|
+
/** The wording this side judges. */
|
|
7211
|
+
readonly revision: v.ObjectSchema<{
|
|
7212
|
+
readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7213
|
+
readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7214
|
+
}, undefined>;
|
|
7215
|
+
/** Rows in this side's window, including the runs that never engaged it. */
|
|
7216
|
+
readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7217
|
+
readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7218
|
+
readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7219
|
+
readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7220
|
+
/** `aligned + misaligned` — this side's own denominator. */
|
|
7221
|
+
readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7222
|
+
/** `aligned / applicable`, or null when no run engaged this wording. */
|
|
7223
|
+
readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
|
|
7224
|
+
/** This side is below the sample floor, so read its counts and not its rate. */
|
|
7225
|
+
readonly isLowConfidence: v.BooleanSchema<undefined>;
|
|
7226
|
+
/**
|
|
7227
|
+
* This side is a bounded sample of its revision rather than the whole record.
|
|
7228
|
+
* A saturated side beside an unsaturated one is two different kinds of
|
|
7229
|
+
* number, and comparing them without saying so is the defect the flag exists
|
|
7230
|
+
* to stop.
|
|
7231
|
+
*/
|
|
7232
|
+
readonly isSaturated: v.BooleanSchema<undefined>;
|
|
7233
|
+
/** The span this side covers, ISO. Both null on a side with no rows. */
|
|
7234
|
+
readonly newestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7235
|
+
readonly oldestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7236
|
+
}, undefined>;
|
|
7237
|
+
/**
|
|
7238
|
+
* `since` minus `before`, in `[-1, 1]`, or **null whenever the pair is
|
|
7239
|
+
* suppressed** or either side never engaged the guide. Null is not zero: one
|
|
7240
|
+
* says the evidence does not support a number, the other would be a claim.
|
|
7241
|
+
*/
|
|
7242
|
+
readonly alignmentRateDelta: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
|
|
7243
|
+
/**
|
|
7244
|
+
* Which side is below the sample floor, or null when neither is and the delta
|
|
7245
|
+
* stands. `'since'` is the ordinary post-edit state — *not enough runs since
|
|
7246
|
+
* this change* — and is reported rather than omitted.
|
|
7247
|
+
*/
|
|
7248
|
+
readonly suppressedBy: v.NullableSchema<v.PicklistSchema<["since", "before", "both"], undefined>, undefined>;
|
|
7249
|
+
/** The delta's sign, or null while it is withheld. `unchanged` is exactly zero. */
|
|
7250
|
+
readonly direction: v.NullableSchema<v.PicklistSchema<["improved", "regressed", "unchanged"], undefined>, undefined>;
|
|
7251
|
+
/** Either side is a bounded sample, so neither is a lifetime total. */
|
|
7252
|
+
readonly isWindowed: v.BooleanSchema<undefined>;
|
|
7253
|
+
/** The per-revision cap each side was bounded by, so "sample" has a size. */
|
|
7254
|
+
readonly windowSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7255
|
+
/**
|
|
7256
|
+
* When the current wording was recorded, ISO — the boundary between the two
|
|
7257
|
+
* windows, and null when no version row carries it.
|
|
7258
|
+
*
|
|
7259
|
+
* A date, never an attribution: it says when the window opened, not that the
|
|
7260
|
+
* edit caused what happened inside it.
|
|
7261
|
+
*/
|
|
7262
|
+
readonly changedAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7263
|
+
}, undefined>, undefined>;
|
|
7264
|
+
readonly findings: v.ArraySchema<v.ObjectSchema<{
|
|
7265
|
+
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7266
|
+
readonly occurredAt: v.StringSchema<undefined>;
|
|
7267
|
+
readonly revision: v.NullableSchema<v.ObjectSchema<{
|
|
7268
|
+
readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7269
|
+
readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7270
|
+
}, undefined>, undefined>;
|
|
7271
|
+
readonly isCurrentRevision: v.BooleanSchema<undefined>;
|
|
7272
|
+
readonly reasoning: v.StringSchema<undefined>;
|
|
7273
|
+
}, undefined>, undefined>;
|
|
7274
|
+
/**
|
|
7275
|
+
* Misaligned rows in the window beyond the `MAX_GUIDE_HISTORY_FINDINGS`
|
|
7276
|
+
* returned. Reported rather than silently truncated: a caller reading five
|
|
7277
|
+
* findings has no other way to know it is reading five of forty.
|
|
7278
|
+
*/
|
|
7279
|
+
readonly findingsOmitted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7280
|
+
/**
|
|
7281
|
+
* The caller's newest stored failure-pattern analysis of this guide, or
|
|
7282
|
+
* **null when they have never asked for one**. Optional because a server
|
|
7283
|
+
* that predates it sends no key; a reader must not take absence for "never
|
|
7284
|
+
* analysed".
|
|
7285
|
+
*/
|
|
7286
|
+
readonly analysis: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
|
|
7287
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7288
|
+
/** When it was written, ISO. */
|
|
7289
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
7290
|
+
readonly outcome: v.PicklistSchema<["pattern", "no_pattern"], undefined>;
|
|
7291
|
+
readonly summary: v.StringSchema<undefined>;
|
|
7292
|
+
/** Failed sessions the analysis read. */
|
|
7293
|
+
readonly sessionsAnalysed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7294
|
+
/** Failed sessions it left out to stay within its prompt's cap. */
|
|
7295
|
+
readonly sessionsOmitted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
|
|
7296
|
+
readonly stale: v.BooleanSchema<undefined>;
|
|
7297
|
+
/** Why it is out of date, or null while it is current. */
|
|
7298
|
+
readonly staleReason: v.NullableSchema<v.PicklistSchema<["revision_changed", "new_failures"], undefined>, undefined>;
|
|
7299
|
+
/** Failures it has not read, when `staleReason` is `new_failures`; else null. */
|
|
7300
|
+
readonly newFailures: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
|
|
7301
|
+
}, undefined>, undefined>, undefined>;
|
|
7302
|
+
readonly untrusted: v.ObjectSchema<{
|
|
7303
|
+
readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7304
|
+
readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7305
|
+
readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
7306
|
+
readonly note: v.StringSchema<undefined>;
|
|
7307
|
+
}, undefined>;
|
|
7308
|
+
}, undefined>, undefined>;
|
|
7309
|
+
/** Present exactly when `grading` is null. */
|
|
7310
|
+
readonly gradingUnavailable: v.OptionalSchema<v.ObjectSchema<{
|
|
7311
|
+
readonly code: v.PicklistSchema<["not-graded", "not-available-to-credential"], undefined>;
|
|
7312
|
+
readonly reason: v.StringSchema<undefined>;
|
|
7313
|
+
}, undefined>, undefined>;
|
|
7314
|
+
}, undefined>, undefined>;
|
|
7315
|
+
/** Set on a null `feedback` that is a failed read, not an unreadable id: ask again. */
|
|
7316
|
+
readonly unavailable: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
|
|
7317
|
+
}, undefined>, undefined>;
|
|
7318
|
+
}, undefined>;
|
|
7319
|
+
export type ArtifactFeedbackBatchResponse = v.InferOutput<typeof ArtifactFeedbackBatchResponseSchema>;
|
|
6466
7320
|
export declare const SessionGradeRequestSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
|
|
6467
7321
|
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>;
|
|
6468
7322
|
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>;
|
|
@@ -7883,10 +8737,18 @@ export declare function parseCreateBundleResponse(data: unknown): {
|
|
|
7883
8737
|
};
|
|
7884
8738
|
export declare function parseAttachBundleMemberRequest(data: unknown): {
|
|
7885
8739
|
artifactId: string;
|
|
8740
|
+
} | {
|
|
8741
|
+
artifactIds: string[];
|
|
7886
8742
|
};
|
|
7887
8743
|
export declare function parseAttachBundleMemberResponse(data: unknown): {
|
|
7888
8744
|
attached: boolean;
|
|
7889
8745
|
};
|
|
8746
|
+
export declare function parseAttachBundleMembersResponse(data: unknown): {
|
|
8747
|
+
results: {
|
|
8748
|
+
artifactId: string;
|
|
8749
|
+
status: "added" | "already_there" | "unavailable" | "path_taken";
|
|
8750
|
+
}[];
|
|
8751
|
+
};
|
|
7890
8752
|
export declare function parseDetachBundleMemberResponse(data: unknown): {
|
|
7891
8753
|
detached: boolean;
|
|
7892
8754
|
};
|
|
@@ -7984,6 +8846,7 @@ export declare function parseContextItemsResponse(data: unknown): {
|
|
|
7984
8846
|
itemVersion: number;
|
|
7985
8847
|
itemChangedSince: boolean;
|
|
7986
8848
|
deliveredCount: number;
|
|
8849
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
7987
8850
|
threadId: string;
|
|
7988
8851
|
replyToId: string | null;
|
|
7989
8852
|
repliesWithheld?: number | undefined;
|
|
@@ -7995,6 +8858,8 @@ export declare function parseContextItemsResponse(data: unknown): {
|
|
|
7995
8858
|
branch?: string | undefined;
|
|
7996
8859
|
} | null | undefined;
|
|
7997
8860
|
removed?: true | undefined;
|
|
8861
|
+
inactive?: true | undefined;
|
|
8862
|
+
retiredByPublication?: true | undefined;
|
|
7998
8863
|
}[];
|
|
7999
8864
|
untrusted?: {
|
|
8000
8865
|
token: string;
|
|
@@ -8048,6 +8913,7 @@ export declare function parseBundleArtifactsResponse(data: unknown): {
|
|
|
8048
8913
|
itemVersion: number;
|
|
8049
8914
|
itemChangedSince: boolean;
|
|
8050
8915
|
deliveredCount: number;
|
|
8916
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
8051
8917
|
threadId: string;
|
|
8052
8918
|
replyToId: string | null;
|
|
8053
8919
|
repliesWithheld?: number | undefined;
|
|
@@ -8059,6 +8925,8 @@ export declare function parseBundleArtifactsResponse(data: unknown): {
|
|
|
8059
8925
|
branch?: string | undefined;
|
|
8060
8926
|
} | null | undefined;
|
|
8061
8927
|
removed?: true | undefined;
|
|
8928
|
+
inactive?: true | undefined;
|
|
8929
|
+
retiredByPublication?: true | undefined;
|
|
8062
8930
|
}[];
|
|
8063
8931
|
untrusted?: {
|
|
8064
8932
|
token: string;
|
|
@@ -8348,6 +9216,10 @@ export declare function parseGuideHistoryResponse(data: unknown): {
|
|
|
8348
9216
|
export declare function parseAnnounceItemCommentsRequest(data: unknown): {
|
|
8349
9217
|
projectId: string;
|
|
8350
9218
|
bundleIds: string[];
|
|
9219
|
+
cliVersion?: string | undefined;
|
|
9220
|
+
};
|
|
9221
|
+
export declare function parseResolveItemCommentResponse(data: unknown): {
|
|
9222
|
+
resolved: true;
|
|
8351
9223
|
};
|
|
8352
9224
|
export declare function parseAnnounceItemCommentsResponse(data: unknown): {
|
|
8353
9225
|
open: number;
|
|
@@ -8394,6 +9266,7 @@ export declare function parseItemCommentsResponse(data: unknown): {
|
|
|
8394
9266
|
itemVersion: number;
|
|
8395
9267
|
itemChangedSince: boolean;
|
|
8396
9268
|
deliveredCount: number;
|
|
9269
|
+
guideChangedSinceRead?: boolean | undefined;
|
|
8397
9270
|
threadId: string;
|
|
8398
9271
|
replyToId: string | null;
|
|
8399
9272
|
repliesWithheld?: number | undefined;
|
|
@@ -8441,7 +9314,7 @@ export declare function parseCommentEvidenceResponse(data: unknown): {
|
|
|
8441
9314
|
}[];
|
|
8442
9315
|
} | null;
|
|
8443
9316
|
citations: {
|
|
8444
|
-
kind: "verdict" | "turn" | "navigation" | "action";
|
|
9317
|
+
kind: "verdict" | "turn" | "navigation" | "action" | "discrepancy";
|
|
8445
9318
|
sessionId: string;
|
|
8446
9319
|
at: string;
|
|
8447
9320
|
excerpt: string;
|