@mossbear/protocol 0.1.0-alpha.114 → 0.1.0-alpha.116

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.
Files changed (73) hide show
  1. package/dist/bundles.d.ts +662 -0
  2. package/dist/bundles.d.ts.map +1 -0
  3. package/dist/bundles.js +454 -0
  4. package/dist/bundles.js.map +1 -0
  5. package/dist/bundles.test.d.ts +2 -0
  6. package/dist/bundles.test.d.ts.map +1 -0
  7. package/dist/bundles.test.js +61 -0
  8. package/dist/bundles.test.js.map +1 -0
  9. package/dist/comments.d.ts +1405 -0
  10. package/dist/comments.d.ts.map +1 -0
  11. package/dist/comments.js +683 -0
  12. package/dist/comments.js.map +1 -0
  13. package/dist/comments.test.d.ts +2 -0
  14. package/dist/comments.test.d.ts.map +1 -0
  15. package/dist/comments.test.js +64 -0
  16. package/dist/comments.test.js.map +1 -0
  17. package/dist/guideHistory.d.ts +643 -0
  18. package/dist/guideHistory.d.ts.map +1 -0
  19. package/dist/guideHistory.js +343 -0
  20. package/dist/guideHistory.js.map +1 -0
  21. package/dist/guideHistory.test.d.ts +2 -0
  22. package/dist/guideHistory.test.d.ts.map +1 -0
  23. package/dist/guideHistory.test.js +35 -0
  24. package/dist/guideHistory.test.js.map +1 -0
  25. package/dist/guideImport.d.ts +398 -0
  26. package/dist/guideImport.d.ts.map +1 -0
  27. package/dist/guideImport.js +350 -0
  28. package/dist/guideImport.js.map +1 -0
  29. package/dist/guideImport.test.d.ts +2 -0
  30. package/dist/guideImport.test.d.ts.map +1 -0
  31. package/dist/guideImport.test.js +62 -0
  32. package/dist/guideImport.test.js.map +1 -0
  33. package/dist/guideSnapshot.d.ts +105 -0
  34. package/dist/guideSnapshot.d.ts.map +1 -0
  35. package/dist/guideSnapshot.js +101 -0
  36. package/dist/guideSnapshot.js.map +1 -0
  37. package/dist/guideSnapshot.test.d.ts +2 -0
  38. package/dist/guideSnapshot.test.d.ts.map +1 -0
  39. package/dist/guideSnapshot.test.js +49 -0
  40. package/dist/guideSnapshot.test.js.map +1 -0
  41. package/dist/schemas.d.ts +5122 -11710
  42. package/dist/schemas.d.ts.map +1 -1
  43. package/dist/schemas.js +61 -2816
  44. package/dist/schemas.js.map +1 -1
  45. package/dist/search.d.ts +1222 -0
  46. package/dist/search.d.ts.map +1 -0
  47. package/dist/search.js +474 -0
  48. package/dist/search.js.map +1 -0
  49. package/dist/search.test.d.ts +2 -0
  50. package/dist/search.test.d.ts.map +1 -0
  51. package/dist/search.test.js +64 -0
  52. package/dist/search.test.js.map +1 -0
  53. package/dist/sessionContracts.test.d.ts +2 -0
  54. package/dist/sessionContracts.test.d.ts.map +1 -0
  55. package/dist/sessionContracts.test.js +75 -0
  56. package/dist/sessionContracts.test.js.map +1 -0
  57. package/dist/sessionDigest.d.ts +149 -0
  58. package/dist/sessionDigest.d.ts.map +1 -0
  59. package/dist/sessionDigest.js +57 -0
  60. package/dist/sessionDigest.js.map +1 -0
  61. package/dist/sessionGrade.d.ts +184 -0
  62. package/dist/sessionGrade.d.ts.map +1 -0
  63. package/dist/sessionGrade.js +130 -0
  64. package/dist/sessionGrade.js.map +1 -0
  65. package/dist/types.d.ts +4 -27
  66. package/dist/types.d.ts.map +1 -1
  67. package/dist/types.js.map +1 -1
  68. package/dist/usageOnly.d.ts +5 -5
  69. package/dist/wirePrimitives.d.ts +173 -0
  70. package/dist/wirePrimitives.d.ts.map +1 -0
  71. package/dist/wirePrimitives.js +210 -0
  72. package/dist/wirePrimitives.js.map +1 -0
  73. package/package.json +1 -1
@@ -0,0 +1,643 @@
1
+ /** Guide verdict history contracts, inferred types, and boundary parsers. */
2
+ import * as v from 'valibot';
3
+ /**
4
+ * The read an agent makes of a guide's own grading record, so the improvement
5
+ * loop the user already runs in-conversation ("what could be improved in this
6
+ * skill?") has the evidence Mossbear holds and the agent does not.
7
+ *
8
+ * **Evidence out, never instructions out.** Nothing in this contract carries a
9
+ * directive to change anything, and nothing on the server writes as a result of
10
+ * it. It is a read, and the decision stays in the user's conversation.
11
+ */
12
+ /**
13
+ * How the agent names the guide.
14
+ *
15
+ * Either a repo-relative path exactly as the guide file declares it
16
+ * (`.claude/skills/reviewer/SKILL.md`, `AGENTS.md`), or the bare name of a
17
+ * skill (`reviewer`), which the server expands to the skill layouts it knows.
18
+ * Both resolve through the `(root, path)` identity import already reconciles
19
+ * on, rather than a second one invented here.
20
+ *
21
+ * Bounded and shape-checked at the boundary rather than at the query string: it
22
+ * reaches a SQL predicate, and an identifier is not free text.
23
+ */
24
+ export declare const GuideHistoryIdentifierSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "guide must not contain control characters">]>;
25
+ /**
26
+ * The request an agent sends.
27
+ *
28
+ * `root` is optional and is the disambiguator, not decoration: `.claude/skills`
29
+ * is scanned under **both** discovery roots
30
+ * (`packages/cli/src/guides/discover.ts`), so a project skill and its
31
+ * `~/.claude/skills` twin declare the same path string. When the identifier
32
+ * reaches guides under more than one root and no root was given, the server
33
+ * refuses and names both rather than picking one — answering a question about
34
+ * the wrong file's history is worse than not answering it.
35
+ */
36
+ export declare const GuideHistoryRequestSchema: v.ObjectSchema<{
37
+ readonly guide: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "guide must not contain control characters">]>;
38
+ readonly root: v.OptionalSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>;
39
+ /**
40
+ * Which repo's copy — **the axis import itself reconciles on**, and the one
41
+ * that actually resolves the common collision.
42
+ *
43
+ * `root` alone does not, and assuming it did was the first version's defect:
44
+ * import's resolution key is `(userId, repoId, root, path)` and two files at
45
+ * one path under different repos deliberately stay two rows. So any
46
+ * user with two repos has two guides at `(project, AGENTS.md)`, and a refusal
47
+ * telling them to pass `root` names the one field that cannot separate those.
48
+ *
49
+ * `projectId` is the portable identity a repo commits and every clone agrees
50
+ * on; `repoId` is the machine-local digest. Both are optional and both are
51
+ * what the caller already sends at import time, so an agent running inside a
52
+ * repo supplies them without being asked.
53
+ */
54
+ readonly projectId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
55
+ readonly repoId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
56
+ /**
57
+ * The exact guide, when the caller has already been shown the candidates.
58
+ *
59
+ * The escape hatch that makes the refusal always satisfiable: two repos can
60
+ * be indistinguishable to a caller that knows neither id (a guide imported
61
+ * before repo identity was recorded carries neither), and an error whose
62
+ * remedy cannot be carried out is worse than no remedy at all. The 409 names
63
+ * this id for every candidate.
64
+ */
65
+ readonly guideId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
66
+ }, undefined>;
67
+ export type GuideHistoryRequest = v.InferOutput<typeof GuideHistoryRequestSchema>;
68
+ /**
69
+ * One revision of a guide's wording: the body file and the version it stood at.
70
+ *
71
+ * The pair, never a bare version number — `guide_files.version` restarts at 1
72
+ * per row, so a number alone compares equal across two different files.
73
+ */
74
+ export declare const GuideHistoryRevisionSchema: v.ObjectSchema<{
75
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
76
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
77
+ }, undefined>;
78
+ export type GuideHistoryRevision = v.InferOutput<typeof GuideHistoryRevisionSchema>;
79
+ /**
80
+ * Which of three states the guide's record is in — a required field rather than
81
+ * something a reader infers from empty arrays.
82
+ *
83
+ * The distinction is the whole point of returning it: `unevaluated` means no
84
+ * graded run has ever produced a verdict, while `awaiting_current_revision`
85
+ * means the guide has a real record that is entirely about wording the user has
86
+ * since rewritten. Collapsing those two onto "no data" is exactly the claim the
87
+ * dashboard stopped making with its awaiting-current-revision check, and an
88
+ * agent reading an absence as a verdict is the same error one screen further
89
+ * out.
90
+ */
91
+ export declare const GuideHistoryStateSchema: v.PicklistSchema<["evaluated", "awaiting_current_revision", "unevaluated"], undefined>;
92
+ export type GuideHistoryState = v.InferOutput<typeof GuideHistoryStateSchema>;
93
+ /**
94
+ * The verdict window, scoped to the revision named beside it.
95
+ *
96
+ * Both denominators travel: `applicable` is the rate's own denominator
97
+ * (`aligned + misaligned`), `total` is the window's row count including the runs
98
+ * that never engaged the guide. Rendering one as the other is the defect
99
+ * `alignment-rate-sample-disclosure` was filed for, and a payload carrying only
100
+ * one of them would hand an agent the same mistake.
101
+ */
102
+ export declare const GuideHistoryWindowSchema: v.ObjectSchema<{
103
+ /** Rows summarized, after the revision narrow. */
104
+ readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
105
+ readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
106
+ readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
107
+ /** In context, never engaged. Neither a pass nor a failure. */
108
+ readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
109
+ /** `aligned + misaligned` — the rate's own denominator. */
110
+ readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
111
+ /** `aligned / applicable`, or **null when no run engaged the guide**. */
112
+ readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
113
+ /** The rows hit the per-guide cap: a bounded window, never a lifetime total. */
114
+ readonly isWindowed: v.BooleanSchema<undefined>;
115
+ /** The cap the rows were fetched under, so a reader can say what "windowed" means. */
116
+ readonly windowSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
117
+ /**
118
+ * Verdicts fetched and then dropped by the revision narrow — about wording
119
+ * that is no longer current, or citing no revision at all. A **floor** rather
120
+ * than a total whenever `isWindowed`, because rows past the cap were never
121
+ * fetched.
122
+ */
123
+ readonly olderRevisionRows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
124
+ /**
125
+ * `applicable` is too small for the percentage to mean anything — threshold
126
+ * `applicable < 3` (founder, 2026-08-22). Read the counts, not the rate.
127
+ */
128
+ readonly isLowConfidence: v.BooleanSchema<undefined>;
129
+ }, undefined>;
130
+ export type GuideHistoryWindow = v.InferOutput<typeof GuideHistoryWindowSchema>;
131
+ /**
132
+ * One side of a guide edit's before/after pair — the wording, and what the runs
133
+ * that engaged it did.
134
+ *
135
+ * Structurally a window like `GuideHistoryWindow` and deliberately not that
136
+ * schema: these two sides are bounded **per revision** by a different
137
+ * server-side query, so `isSaturated` is
138
+ * the server's own measurement of its partition rather than the client-side
139
+ * `isWindowed` inference, and the span each side covers is part of what makes
140
+ * the pair readable.
141
+ *
142
+ * Both denominators travel here for the same reason they travel on the window:
143
+ * a delta between two undisclosed denominators is worse than no number at all.
144
+ */
145
+ export declare const GuideHistoryChangeSideSchema: v.ObjectSchema<{
146
+ /** The wording this side judges. */
147
+ readonly revision: v.ObjectSchema<{
148
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
149
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
150
+ }, undefined>;
151
+ /** Rows in this side's window, including the runs that never engaged it. */
152
+ readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
153
+ readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
154
+ readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
155
+ readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
156
+ /** `aligned + misaligned` — this side's own denominator. */
157
+ readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
158
+ /** `aligned / applicable`, or null when no run engaged this wording. */
159
+ readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
160
+ /** This side is below the sample floor, so read its counts and not its rate. */
161
+ readonly isLowConfidence: v.BooleanSchema<undefined>;
162
+ /**
163
+ * This side is a bounded sample of its revision rather than the whole record.
164
+ * A saturated side beside an unsaturated one is two different kinds of
165
+ * number, and comparing them without saying so is the defect the flag exists
166
+ * to stop.
167
+ */
168
+ readonly isSaturated: v.BooleanSchema<undefined>;
169
+ /** The span this side covers, ISO. Both null on a side with no rows. */
170
+ readonly newestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
171
+ readonly oldestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
172
+ }, undefined>;
173
+ export type GuideHistoryChangeSide = v.InferOutput<typeof GuideHistoryChangeSideSchema>;
174
+ /**
175
+ * Which side is too thin for a delta to mean anything.
176
+ *
177
+ * Named rather than a boolean because the two take different sentences: too few
178
+ * runs *since* the change is the ordinary state right after an edit, while too
179
+ * few *before* it means there was never a baseline to compare against.
180
+ */
181
+ export declare const GuideHistoryChangeSuppressionSchema: v.PicklistSchema<["since", "before", "both"], undefined>;
182
+ /**
183
+ * Which way the pair points, or null while the delta is withheld.
184
+ *
185
+ * A reading of a *set* of runs, never a verdict on one — the vocabulary
186
+ * `aligned | misaligned | not_applicable` is untouched, and nothing derived
187
+ * here is written back to a row.
188
+ */
189
+ export declare const GuideHistoryChangeDirectionSchema: v.PicklistSchema<["improved", "regressed", "unchanged"], undefined>;
190
+ /**
191
+ * The guide's last edit, read as two windows
192
+ * (`insight-to-proven-change` §A, surfaced by `guide-history-for-agents`
193
+ * deliverable 3).
194
+ *
195
+ * > Changed 12 Aug. Before: misaligned in 6 of 8 runs that engaged it.
196
+ * > Since: 0 of 11.
197
+ *
198
+ * **Null on the response is a state, not a missing field.** It means this guide
199
+ * has no earlier wording that produced evidence — a guide on its first
200
+ * revision, which is the normal state and not an error.
201
+ *
202
+ * **Paired, never merged**, and **never causal**: this states two windows and
203
+ * their denominators and stops. The model changed, the task mix changed and the
204
+ * codebase changed too, so "since" is the strongest word the evidence supports.
205
+ */
206
+ export declare const GuideHistoryChangeSchema: v.ObjectSchema<{
207
+ /** The revision that preceded the change. */
208
+ readonly before: v.ObjectSchema<{
209
+ /** The wording this side judges. */
210
+ readonly revision: v.ObjectSchema<{
211
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
212
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
213
+ }, undefined>;
214
+ /** Rows in this side's window, including the runs that never engaged it. */
215
+ readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
216
+ readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
217
+ readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
218
+ readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
219
+ /** `aligned + misaligned` — this side's own denominator. */
220
+ readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
221
+ /** `aligned / applicable`, or null when no run engaged this wording. */
222
+ readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
223
+ /** This side is below the sample floor, so read its counts and not its rate. */
224
+ readonly isLowConfidence: v.BooleanSchema<undefined>;
225
+ /**
226
+ * This side is a bounded sample of its revision rather than the whole record.
227
+ * A saturated side beside an unsaturated one is two different kinds of
228
+ * number, and comparing them without saying so is the defect the flag exists
229
+ * to stop.
230
+ */
231
+ readonly isSaturated: v.BooleanSchema<undefined>;
232
+ /** The span this side covers, ISO. Both null on a side with no rows. */
233
+ readonly newestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
234
+ readonly oldestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
235
+ }, undefined>;
236
+ /** The wording the guide stands at now. */
237
+ readonly since: v.ObjectSchema<{
238
+ /** The wording this side judges. */
239
+ readonly revision: v.ObjectSchema<{
240
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
241
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
242
+ }, undefined>;
243
+ /** Rows in this side's window, including the runs that never engaged it. */
244
+ readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
245
+ readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
246
+ readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
247
+ readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
248
+ /** `aligned + misaligned` — this side's own denominator. */
249
+ readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
250
+ /** `aligned / applicable`, or null when no run engaged this wording. */
251
+ readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
252
+ /** This side is below the sample floor, so read its counts and not its rate. */
253
+ readonly isLowConfidence: v.BooleanSchema<undefined>;
254
+ /**
255
+ * This side is a bounded sample of its revision rather than the whole record.
256
+ * A saturated side beside an unsaturated one is two different kinds of
257
+ * number, and comparing them without saying so is the defect the flag exists
258
+ * to stop.
259
+ */
260
+ readonly isSaturated: v.BooleanSchema<undefined>;
261
+ /** The span this side covers, ISO. Both null on a side with no rows. */
262
+ readonly newestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
263
+ readonly oldestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
264
+ }, undefined>;
265
+ /**
266
+ * `since` minus `before`, in `[-1, 1]`, or **null whenever the pair is
267
+ * suppressed** or either side never engaged the guide. Null is not zero: one
268
+ * says the evidence does not support a number, the other would be a claim.
269
+ */
270
+ readonly alignmentRateDelta: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
271
+ /**
272
+ * Which side is below the sample floor, or null when neither is and the delta
273
+ * stands. `'since'` is the ordinary post-edit state — *not enough runs since
274
+ * this change* — and is reported rather than omitted.
275
+ */
276
+ readonly suppressedBy: v.NullableSchema<v.PicklistSchema<["since", "before", "both"], undefined>, undefined>;
277
+ /** The delta's sign, or null while it is withheld. `unchanged` is exactly zero. */
278
+ readonly direction: v.NullableSchema<v.PicklistSchema<["improved", "regressed", "unchanged"], undefined>, undefined>;
279
+ /** Either side is a bounded sample, so neither is a lifetime total. */
280
+ readonly isWindowed: v.BooleanSchema<undefined>;
281
+ /** The per-revision cap each side was bounded by, so "sample" has a size. */
282
+ readonly windowSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
283
+ /**
284
+ * When the current wording was recorded, ISO — the boundary between the two
285
+ * windows, and null when no version row carries it.
286
+ *
287
+ * A date, never an attribution: it says when the window opened, not that the
288
+ * edit caused what happened inside it.
289
+ */
290
+ readonly changedAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
291
+ }, undefined>;
292
+ export type GuideHistoryChange = v.InferOutput<typeof GuideHistoryChangeSchema>;
293
+ /** Findings returned per response, and the character bound on each reasoning. */
294
+ export declare const MAX_GUIDE_HISTORY_FINDINGS = 5;
295
+ export declare const MAX_GUIDE_HISTORY_REASONING_CHARS = 1200;
296
+ /**
297
+ * One recorded finding: a run that judged this guide misaligned, and why.
298
+ *
299
+ * `reasoning` arrives **already wrapped in the response's untrusted markers**
300
+ * rather than raw. It is model-authored text derived from a transcript, so the
301
+ * discipline the run grader applies to such text on the way in applies on the
302
+ * way out; wrapping it at the source is what makes the boundary
303
+ * unforgeable, since a consumer handed raw text plus separate markers can
304
+ * simply not use them.
305
+ *
306
+ * `isCurrentRevision` is not optional detail. A payload that scopes its *rate*
307
+ * to the current wording and then hands over reasoning about deleted sentences,
308
+ * unlabelled, reproduces inside one response the conflation
309
+ * `pattern-evidence-guide-revision` removed from the dashboard.
310
+ */
311
+ export declare const GuideHistoryFindingSchema: v.ObjectSchema<{
312
+ readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
313
+ readonly occurredAt: v.StringSchema<undefined>;
314
+ readonly revision: v.NullableSchema<v.ObjectSchema<{
315
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
316
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
317
+ }, undefined>, undefined>;
318
+ readonly isCurrentRevision: v.BooleanSchema<undefined>;
319
+ readonly reasoning: v.StringSchema<undefined>;
320
+ }, undefined>;
321
+ export type GuideHistoryFinding = v.InferOutput<typeof GuideHistoryFindingSchema>;
322
+ /** The guide the identifier resolved to, echoed so the agent can check itself. */
323
+ export declare const GuideHistoryGuideSchema: v.ObjectSchema<{
324
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
325
+ readonly title: v.StringSchema<undefined>;
326
+ 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>;
327
+ readonly root: v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>;
328
+ }, undefined>;
329
+ /**
330
+ * The caller's newest stored failure-pattern analysis of the guide
331
+ * (`drafted-guide-suggestions` slice 7), served through artifact feedback.
332
+ *
333
+ * **The caller's own analysis only.** An analysis reads the caller's verdicts,
334
+ * so a workspace-mate's is never returned, the same rule the verdicts follow.
335
+ *
336
+ * **Staleness is derived on read**: the
337
+ * guide's wording changed since (`revision_changed`), or failures of the same
338
+ * wording arrived that it has not read (`new_failures`, with how many). A stale
339
+ * analysis is still what it found; it is reported, never withheld.
340
+ *
341
+ * `summary` arrives wrapped in the response's untrusted markers. It is
342
+ * model-authored text derived from session transcripts. On `no_pattern` it may
343
+ * be empty between them, because the dashboard supplies that sentence itself.
344
+ */
345
+ export declare const GuideHistoryAnalysisSchema: v.ObjectSchema<{
346
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
347
+ /** When it was written, ISO. */
348
+ readonly createdAt: v.StringSchema<undefined>;
349
+ readonly outcome: v.PicklistSchema<["pattern", "no_pattern"], undefined>;
350
+ readonly summary: v.StringSchema<undefined>;
351
+ /** Failed sessions the analysis read. */
352
+ readonly sessionsAnalysed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
353
+ /** Failed sessions it left out to stay within its prompt's cap. */
354
+ readonly sessionsOmitted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
355
+ readonly stale: v.BooleanSchema<undefined>;
356
+ /** Why it is out of date, or null while it is current. */
357
+ readonly staleReason: v.NullableSchema<v.PicklistSchema<["revision_changed", "new_failures"], undefined>, undefined>;
358
+ /** Failures it has not read, when `staleReason` is `new_failures`; else null. */
359
+ readonly newFailures: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
360
+ }, undefined>;
361
+ export type GuideHistoryAnalysis = v.InferOutput<typeof GuideHistoryAnalysisSchema>;
362
+ export declare const GuideHistoryResponseSchema: v.ObjectSchema<{
363
+ readonly guide: v.ObjectSchema<{
364
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
365
+ readonly title: v.StringSchema<undefined>;
366
+ 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>;
367
+ readonly root: v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>;
368
+ }, undefined>;
369
+ /** The wording the window is about, or null when the guide has no revision identity. */
370
+ readonly currentRevision: v.NullableSchema<v.ObjectSchema<{
371
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
372
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
373
+ }, undefined>, undefined>;
374
+ readonly state: v.PicklistSchema<["evaluated", "awaiting_current_revision", "unevaluated"], undefined>;
375
+ readonly window: v.ObjectSchema<{
376
+ /** Rows summarized, after the revision narrow. */
377
+ readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
378
+ readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
379
+ readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
380
+ /** In context, never engaged. Neither a pass nor a failure. */
381
+ readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
382
+ /** `aligned + misaligned` — the rate's own denominator. */
383
+ readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
384
+ /** `aligned / applicable`, or **null when no run engaged the guide**. */
385
+ readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
386
+ /** The rows hit the per-guide cap: a bounded window, never a lifetime total. */
387
+ readonly isWindowed: v.BooleanSchema<undefined>;
388
+ /** The cap the rows were fetched under, so a reader can say what "windowed" means. */
389
+ readonly windowSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
390
+ /**
391
+ * Verdicts fetched and then dropped by the revision narrow — about wording
392
+ * that is no longer current, or citing no revision at all. A **floor** rather
393
+ * than a total whenever `isWindowed`, because rows past the cap were never
394
+ * fetched.
395
+ */
396
+ readonly olderRevisionRows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
397
+ /**
398
+ * `applicable` is too small for the percentage to mean anything — threshold
399
+ * `applicable < 3` (founder, 2026-08-22). Read the counts, not the rate.
400
+ */
401
+ readonly isLowConfidence: v.BooleanSchema<undefined>;
402
+ }, undefined>;
403
+ /**
404
+ * The last edit's two windows, or **null when there is no earlier wording to
405
+ * compare against**.
406
+ *
407
+ * Present-and-null rather than omitted: a guide on its first revision has no
408
+ * delta, and that is an answer. An absent key would leave a reader unable to
409
+ * tell "no edit to measure" from "this server does not report deltas".
410
+ */
411
+ readonly change: v.NullableSchema<v.ObjectSchema<{
412
+ /** The revision that preceded the change. */
413
+ readonly before: v.ObjectSchema<{
414
+ /** The wording this side judges. */
415
+ readonly revision: v.ObjectSchema<{
416
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
417
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
418
+ }, undefined>;
419
+ /** Rows in this side's window, including the runs that never engaged it. */
420
+ readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
421
+ readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
422
+ readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
423
+ readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
424
+ /** `aligned + misaligned` — this side's own denominator. */
425
+ readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
426
+ /** `aligned / applicable`, or null when no run engaged this wording. */
427
+ readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
428
+ /** This side is below the sample floor, so read its counts and not its rate. */
429
+ readonly isLowConfidence: v.BooleanSchema<undefined>;
430
+ /**
431
+ * This side is a bounded sample of its revision rather than the whole record.
432
+ * A saturated side beside an unsaturated one is two different kinds of
433
+ * number, and comparing them without saying so is the defect the flag exists
434
+ * to stop.
435
+ */
436
+ readonly isSaturated: v.BooleanSchema<undefined>;
437
+ /** The span this side covers, ISO. Both null on a side with no rows. */
438
+ readonly newestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
439
+ readonly oldestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
440
+ }, undefined>;
441
+ /** The wording the guide stands at now. */
442
+ readonly since: v.ObjectSchema<{
443
+ /** The wording this side judges. */
444
+ readonly revision: v.ObjectSchema<{
445
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
446
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
447
+ }, undefined>;
448
+ /** Rows in this side's window, including the runs that never engaged it. */
449
+ readonly total: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
450
+ readonly aligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
451
+ readonly misaligned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
452
+ readonly notApplicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
453
+ /** `aligned + misaligned` — this side's own denominator. */
454
+ readonly applicable: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
455
+ /** `aligned / applicable`, or null when no run engaged this wording. */
456
+ readonly alignmentRate: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
457
+ /** This side is below the sample floor, so read its counts and not its rate. */
458
+ readonly isLowConfidence: v.BooleanSchema<undefined>;
459
+ /**
460
+ * This side is a bounded sample of its revision rather than the whole record.
461
+ * A saturated side beside an unsaturated one is two different kinds of
462
+ * number, and comparing them without saying so is the defect the flag exists
463
+ * to stop.
464
+ */
465
+ readonly isSaturated: v.BooleanSchema<undefined>;
466
+ /** The span this side covers, ISO. Both null on a side with no rows. */
467
+ readonly newestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
468
+ readonly oldestAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
469
+ }, undefined>;
470
+ /**
471
+ * `since` minus `before`, in `[-1, 1]`, or **null whenever the pair is
472
+ * suppressed** or either side never engaged the guide. Null is not zero: one
473
+ * says the evidence does not support a number, the other would be a claim.
474
+ */
475
+ readonly alignmentRateDelta: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
476
+ /**
477
+ * Which side is below the sample floor, or null when neither is and the delta
478
+ * stands. `'since'` is the ordinary post-edit state — *not enough runs since
479
+ * this change* — and is reported rather than omitted.
480
+ */
481
+ readonly suppressedBy: v.NullableSchema<v.PicklistSchema<["since", "before", "both"], undefined>, undefined>;
482
+ /** The delta's sign, or null while it is withheld. `unchanged` is exactly zero. */
483
+ readonly direction: v.NullableSchema<v.PicklistSchema<["improved", "regressed", "unchanged"], undefined>, undefined>;
484
+ /** Either side is a bounded sample, so neither is a lifetime total. */
485
+ readonly isWindowed: v.BooleanSchema<undefined>;
486
+ /** The per-revision cap each side was bounded by, so "sample" has a size. */
487
+ readonly windowSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
488
+ /**
489
+ * When the current wording was recorded, ISO — the boundary between the two
490
+ * windows, and null when no version row carries it.
491
+ *
492
+ * A date, never an attribution: it says when the window opened, not that the
493
+ * edit caused what happened inside it.
494
+ */
495
+ readonly changedAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
496
+ }, undefined>, undefined>;
497
+ readonly findings: v.ArraySchema<v.ObjectSchema<{
498
+ readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
499
+ readonly occurredAt: v.StringSchema<undefined>;
500
+ readonly revision: v.NullableSchema<v.ObjectSchema<{
501
+ readonly bodyItemId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
502
+ readonly version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
503
+ }, undefined>, undefined>;
504
+ readonly isCurrentRevision: v.BooleanSchema<undefined>;
505
+ readonly reasoning: v.StringSchema<undefined>;
506
+ }, undefined>, undefined>;
507
+ /**
508
+ * Misaligned rows in the window beyond the `MAX_GUIDE_HISTORY_FINDINGS`
509
+ * returned. Reported rather than silently truncated: a caller reading five
510
+ * findings has no other way to know it is reading five of forty.
511
+ */
512
+ readonly findingsOmitted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
513
+ /**
514
+ * The caller's newest stored failure-pattern analysis of this guide, or
515
+ * **null when they have never asked for one**. Optional because a server
516
+ * that predates it sends no key; a reader must not take absence for "never
517
+ * analysed".
518
+ */
519
+ readonly analysis: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
520
+ readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
521
+ /** When it was written, ISO. */
522
+ readonly createdAt: v.StringSchema<undefined>;
523
+ readonly outcome: v.PicklistSchema<["pattern", "no_pattern"], undefined>;
524
+ readonly summary: v.StringSchema<undefined>;
525
+ /** Failed sessions the analysis read. */
526
+ readonly sessionsAnalysed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
527
+ /** Failed sessions it left out to stay within its prompt's cap. */
528
+ readonly sessionsOmitted: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
529
+ readonly stale: v.BooleanSchema<undefined>;
530
+ /** Why it is out of date, or null while it is current. */
531
+ readonly staleReason: v.NullableSchema<v.PicklistSchema<["revision_changed", "new_failures"], undefined>, undefined>;
532
+ /** Failures it has not read, when `staleReason` is `new_failures`; else null. */
533
+ readonly newFailures: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
534
+ }, undefined>, undefined>, undefined>;
535
+ readonly untrusted: v.ObjectSchema<{
536
+ readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
537
+ readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
538
+ readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
539
+ readonly note: v.StringSchema<undefined>;
540
+ }, undefined>;
541
+ }, undefined>;
542
+ export type GuideHistoryResponse = v.InferOutput<typeof GuideHistoryResponseSchema>;
543
+ export declare function parseGuideHistoryRequest(data: unknown): {
544
+ guide: string;
545
+ root?: "project" | "global" | undefined;
546
+ projectId?: string | undefined;
547
+ repoId?: string | undefined;
548
+ guideId?: string | undefined;
549
+ };
550
+ export declare function parseGuideHistoryResponse(data: unknown): {
551
+ guide: {
552
+ id: string;
553
+ title: string;
554
+ path: string | null;
555
+ root: "project" | "global" | null;
556
+ };
557
+ currentRevision: {
558
+ bodyItemId: string;
559
+ version: number;
560
+ } | null;
561
+ state: "evaluated" | "awaiting_current_revision" | "unevaluated";
562
+ window: {
563
+ total: number;
564
+ aligned: number;
565
+ misaligned: number;
566
+ notApplicable: number;
567
+ applicable: number;
568
+ alignmentRate: number | null;
569
+ isWindowed: boolean;
570
+ windowSize: number;
571
+ olderRevisionRows: number;
572
+ isLowConfidence: boolean;
573
+ };
574
+ change: {
575
+ before: {
576
+ revision: {
577
+ bodyItemId: string;
578
+ version: number;
579
+ };
580
+ total: number;
581
+ aligned: number;
582
+ misaligned: number;
583
+ notApplicable: number;
584
+ applicable: number;
585
+ alignmentRate: number | null;
586
+ isLowConfidence: boolean;
587
+ isSaturated: boolean;
588
+ newestAt: string | null;
589
+ oldestAt: string | null;
590
+ };
591
+ since: {
592
+ revision: {
593
+ bodyItemId: string;
594
+ version: number;
595
+ };
596
+ total: number;
597
+ aligned: number;
598
+ misaligned: number;
599
+ notApplicable: number;
600
+ applicable: number;
601
+ alignmentRate: number | null;
602
+ isLowConfidence: boolean;
603
+ isSaturated: boolean;
604
+ newestAt: string | null;
605
+ oldestAt: string | null;
606
+ };
607
+ alignmentRateDelta: number | null;
608
+ suppressedBy: "since" | "before" | "both" | null;
609
+ direction: "improved" | "regressed" | "unchanged" | null;
610
+ isWindowed: boolean;
611
+ windowSize: number;
612
+ changedAt: string | null;
613
+ } | null;
614
+ findings: {
615
+ sessionId: string;
616
+ occurredAt: string;
617
+ revision: {
618
+ bodyItemId: string;
619
+ version: number;
620
+ } | null;
621
+ isCurrentRevision: boolean;
622
+ reasoning: string;
623
+ }[];
624
+ findingsOmitted: number;
625
+ analysis?: {
626
+ id: string;
627
+ createdAt: string;
628
+ outcome: "pattern" | "no_pattern";
629
+ summary: string;
630
+ sessionsAnalysed: number;
631
+ sessionsOmitted: number;
632
+ stale: boolean;
633
+ staleReason: "revision_changed" | "new_failures" | null;
634
+ newFailures: number | null;
635
+ } | null | undefined;
636
+ untrusted: {
637
+ token: string;
638
+ startMarker: string;
639
+ endMarker: string;
640
+ note: string;
641
+ };
642
+ };
643
+ //# sourceMappingURL=guideHistory.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"guideHistory.d.ts","sourceRoot":"","sources":["../src/guideHistory.ts"],"names":[],"mappings":"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"}