bareloop 0.55.0 → 0.56.0

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 (56) hide show
  1. package/CHANGELOG.md +47 -0
  2. package/bareloop.context.md +4 -2
  3. package/package.json +2 -2
  4. package/src/authorflow.js +141 -264
  5. package/src/authoring.js +2 -3
  6. package/src/authorjob.js +117 -88
  7. package/src/authorreadout.js +9 -15
  8. package/src/authorrun.js +13 -4
  9. package/src/behaviour.js +14 -0
  10. package/src/blockasks.js +43 -0
  11. package/src/checkblock.js +772 -0
  12. package/src/checklist.js +128 -0
  13. package/src/checkpick.js +30 -312
  14. package/src/checkwords.js +3 -1
  15. package/src/declaredclose.js +30 -1
  16. package/src/destpoint.js +3 -1
  17. package/src/draftspend.js +46 -0
  18. package/src/facts.js +8 -1
  19. package/src/fitcheck.js +5 -3
  20. package/src/pagemap.js +15 -3
  21. package/src/panel/authorroutes.js +15 -3
  22. package/src/panel/authorsession.js +133 -46
  23. package/src/panel/index.html +194 -22
  24. package/src/panel/jobplan.js +85 -33
  25. package/src/panel/server.js +52 -7
  26. package/src/pickrecord.js +19 -1
  27. package/src/placerule.js +355 -0
  28. package/src/promptregisters.js +11 -0
  29. package/src/questionbox.js +112 -0
  30. package/src/rowedit.js +115 -0
  31. package/src/rubricstep.js +212 -125
  32. package/src/run.js +10 -2
  33. package/src/userrun.js +46 -1
  34. package/types/authorflow.d.ts +32 -139
  35. package/types/authorjob.d.ts +24 -6
  36. package/types/authorreadout.d.ts +4 -10
  37. package/types/behaviour.d.ts +12 -0
  38. package/types/blockasks.d.ts +37 -0
  39. package/types/checkblock.d.ts +361 -0
  40. package/types/checklist.d.ts +134 -0
  41. package/types/checkpick.d.ts +3 -140
  42. package/types/declaredclose.d.ts +4 -0
  43. package/types/destpoint.d.ts +2 -0
  44. package/types/draftspend.d.ts +21 -0
  45. package/types/fitcheck.d.ts +7 -1
  46. package/types/pagemap.d.ts +4 -0
  47. package/types/panel/authorsession.d.ts +13 -2
  48. package/types/panel/jobgrid.d.ts +8 -8
  49. package/types/panel/jobplan.d.ts +48 -10
  50. package/types/panel/server.d.ts +14 -13
  51. package/types/pickrecord.d.ts +12 -0
  52. package/types/placerule.d.ts +194 -0
  53. package/types/questionbox.d.ts +87 -0
  54. package/types/rowedit.d.ts +32 -0
  55. package/types/rubricstep.d.ts +91 -48
  56. package/types/run.d.ts +10 -1
@@ -0,0 +1,87 @@
1
+ /**
2
+ * Which buttons a look question offers. Agree only when it carries a proposal (a reading ask with its reading, a check-pick ask with its check); Drop it only where "drop it" leaves
3
+ * one of the person's own `~` rules Not checked (a can't-check ask or a check-pick ask about a rule number).
4
+ * @param {{source?: string, ask?: string, reading?: unknown, check?: unknown, rule?: unknown}} q @returns {{agree: boolean, drop: boolean}}
5
+ */
6
+ export function offersOf(q: {
7
+ source?: string;
8
+ ask?: string;
9
+ reading?: unknown;
10
+ check?: unknown;
11
+ rule?: unknown;
12
+ }): {
13
+ agree: boolean;
14
+ drop: boolean;
15
+ };
16
+ /**
17
+ * A look question as the PANEL shows it: the code's own answer words (`Answer "agree"...` / `Answer "drop it"...`) cut off the end, because the buttons and the box say it.
18
+ * Only the known tails are cut, matched exactly as a suffix (never a pattern over the prose); a question that ends in none of them is returned whole.
19
+ * @param {{question: string, line?: number, source?: string}} q @returns {string}
20
+ */
21
+ export function panelQuestionText(q: {
22
+ question: string;
23
+ line?: number;
24
+ source?: string;
25
+ }): string;
26
+ /**
27
+ * What the panel's question box shows for one pending ask. Only a question the person answers (`kind: 'answer'`) has a box; every other ask (language, menu, install)
28
+ * keeps the chat input. `sendChoice` = the choice the box's own Send posts.
29
+ * @param {{kind: string, source?: string, index?: number, total?: number, question?: string, line?: number, offers?: {agree: boolean, drop: boolean}, folder?: string, current?: string}} step
30
+ * @returns {{head: string, line: string, text: string, choices: {choice: string, label: string}[], orLabel: string|null, sendChoice: string}|null}
31
+ */
32
+ export function boxFor(step: {
33
+ kind: string;
34
+ source?: string;
35
+ index?: number;
36
+ total?: number;
37
+ question?: string;
38
+ line?: number;
39
+ offers?: {
40
+ agree: boolean;
41
+ drop: boolean;
42
+ };
43
+ folder?: string;
44
+ current?: string;
45
+ }): {
46
+ head: string;
47
+ line: string;
48
+ text: string;
49
+ choices: {
50
+ choice: string;
51
+ label: string;
52
+ }[];
53
+ orLabel: string | null;
54
+ sendChoice: string;
55
+ } | null;
56
+ /**
57
+ * The door's check of a choice sent for the pending ask. Null = accepted; else the refusal words.
58
+ * @param {{kind: string, source?: string, rule?: unknown, offers?: {agree: boolean, drop: boolean}}} step @param {unknown} choice @returns {string|null}
59
+ */
60
+ export function refuseChoice(step: {
61
+ kind: string;
62
+ source?: string;
63
+ rule?: unknown;
64
+ offers?: {
65
+ agree: boolean;
66
+ drop: boolean;
67
+ };
68
+ }, choice: unknown): string | null;
69
+ /**
70
+ * What a choice resolves the question with: the words the asker reads (today's own words for the effect, so the drafting log and the CLI path see the same), and the chat line the person
71
+ * sees as their own. `rule` = the box's words kept whole.
72
+ * @param {unknown} choice @param {unknown} text @returns {{value: string, shown: string}|{error: string}}
73
+ */
74
+ export function resolveChoice(choice: unknown, text: unknown): {
75
+ value: string;
76
+ shown: string;
77
+ } | {
78
+ error: string;
79
+ };
80
+ /** the door's refusals, word for word (fwd am31); a refusal leaves the question open and writes nothing */
81
+ export const CHOICE_SAYS: Readonly<{
82
+ bad: "That answer is not one of the choices. Nothing was saved.";
83
+ notOffered: "That choice is not offered for this question. Nothing was saved.";
84
+ outOfDate: "This page is out of date. Reload it and answer again. Nothing was saved.";
85
+ noRule: "That question is about the job line, not one of your ~ rules, so there is nothing to drop. Agree, or type your own words. Nothing was saved.";
86
+ blank: "An answer is needed here — there is no skip. Type it in the box and press Send.";
87
+ }>;
@@ -0,0 +1,32 @@
1
+ /**
2
+ * The ONE user message: the person's job lines (their `~` rules numbered), the look, the inputs (bounded).
3
+ * @param {{jobLines: any[], look: any, texts: Record<string, string>}} o
4
+ * @returns {string}
5
+ */
6
+ export function rowEditUserText({ jobLines, look, texts }: {
7
+ jobLines: any[];
8
+ look: any;
9
+ texts: Record<string, string>;
10
+ }): string;
11
+ /** the tool a row-edit reply is delivered through */
12
+ export const ROW_EDIT_TOOL: "submit_edits";
13
+ /** what an acknowledged reply returns (the loop ends the call the moment the tool fires) */
14
+ export const ROW_EDIT_ACK: "edits received";
15
+ /** the drafter's system text for the row-edit turn (a prompt register: src/promptregisters.js) */
16
+ export const ROW_EDIT_SYSTEM: string;
17
+ /** the fixed sentence that follows the refusals in a revise turn (the turn carries each refusal's own reason and nothing else) */
18
+ export const ROW_EDIT_REVISE: "Send corrected edits only (an empty \"edits\" list is a good answer).";
19
+ export function rowEditChannel(ticket?: boolean): {
20
+ name: string;
21
+ instruction: string;
22
+ textPath: string;
23
+ tool: (box: {
24
+ calls: any[];
25
+ }) => {
26
+ name: string;
27
+ description: string;
28
+ parameters: Record<string, any>;
29
+ execute: (args: any) => Promise<string>;
30
+ };
31
+ };
32
+ export function editsOf(artifact: any): any[];
@@ -3,6 +3,12 @@
3
3
  * @returns {string}
4
4
  */
5
5
  export function stepFileContract(): string;
6
+ /**
7
+ * R10 (fwd am28, rewritten here): what a facts+text line's worker is told about the person's picks, one plain line per pick, the values and what counts, never a verdict and never any other
8
+ * check. Written by code from the signed pick parts; a list item is what bareguard's listItems counts (its own line starting with "1." or "- " and a space).
9
+ * @param {any[]} picked countable parts (`{check, value, names, ...}`) @returns {string[]}
10
+ */
11
+ export function toldPicks(picked: any[]): string[];
6
12
  /**
7
13
  * What the worker is told about each line, from the close that will grade it (PART 1b item 7): a FACTS line gets its
8
14
  * facts and its count; a TEXT line that follows a facts line is told its numbers come from that line's quotes. Written by code from
@@ -199,41 +205,69 @@ export function checkRubricRules(stages: any[], { jobLines, refused, red }: {
199
205
  red: (code: string, path: string, detail: string, extra?: object) => void;
200
206
  }): void;
201
207
  /**
202
- * PART 1c L3 - the person's own words win over the AI's reading of them, settled by CODE before anything is validated or signed:
203
- * - a limit on a fact whose bounds are all in the words the person wrote (the line, its `~` rules, an answer they gave) is the
204
- * person's, so it is NOT marked "AI's proposal" (smv710w8c3wdh: the plan called the person's own range the AI's);
205
- * - a time range the AI proposed while the person wrote ONE explicit positive time range ("between 07:00 and 23:00") on that line
206
- * is replaced by exactly that range (smv710w8c3wdh: the plan said 5:00 AM). Only when it is unambiguous: one such range in the
207
- * line's rules and one AI-proposed `between` time fact on the line; a rule with a negation ("not between ...") is never read as a range;
208
- * - a `~` rule is a check or under Not checked, never both: a `refused` entry for a rule that a part of its own line carries is dropped.
209
- * Pure; returns a new declaration, the input untouched. The model is told the same in the brief; this makes it true either way.
210
- * @param {any} declaration @param {any[]|null|undefined} jobLines @returns {any}
208
+ * Does this rule text hold more than one amount (money) or more than one time range (time)? The ONE guard code's own limit read and an AI
209
+ * reading edit both use: "under $450 or over $900" is two limits, and one reading of it would be a wrong check.
210
+ * @param {string} shape @param {string} text @returns {boolean}
211
211
  */
212
- export function settlePersonsWords(declaration: any, jobLines: any[] | null | undefined): any;
212
+ export function holdsManyBounds(shape: string, text: string): boolean;
213
213
  /**
214
- * PART 1b — put the number tie on every prose step. A rubric-step stage with no fact part that comes AFTER one or more fact
215
- * stages gets exactly one `numbersFromFacts` part naming those lines; one the model wrote is replaced. Pure; returns a new
216
- * declaration (the input is untouched). The model never writes this part: it is code's, so a draft cannot omit it.
217
- * @param {any} declaration @returns {any}
214
+ * The limit the person's own words give a fact of this shape: `{reading}` or `{why}` (a plain reason; the rule then stays Not checked).
215
+ * @param {string} shape money or time @param {string} text the `~` rule's words @param {any} [fact] the look fact (its currency and unit lists must fit)
216
+ * @returns {{reading: {op: 'lt'|'lte'|'gt'|'gte', value: number} | {op: 'between', lo: number|string, hi: number|string}} | {why: string}}
218
217
  */
219
- export function withFactBindings(declaration: any): any;
218
+ export function readLimit(shape: string, text: string, fact?: any): {
219
+ reading: {
220
+ op: "lt" | "lte" | "gt" | "gte";
221
+ value: number;
222
+ } | {
223
+ op: "between";
224
+ lo: number | string;
225
+ hi: number | string;
226
+ };
227
+ } | {
228
+ why: string;
229
+ };
220
230
  /**
221
- * NO SILENT DROP (idea A core, spec 4.4): code writes the Not checked rows for what the page rules removed, before the declaration is validated.
222
- * - a dropped FACT that carries a `~` rule no part carries and no `refused` entry names -> `closeDecl.refused` gets {line, rule, reason}
223
- * (shown under that line in the person's own rule words by {@link ruleNotChecked});
224
- * - any other drop (a fact from the job line itself, a rule another fact carries, a word dropped from a fact that is still checked, so a
225
- * narrower check is still said) -> one line in `closeDecl.notes`, shown as Not checked (the AI's own reading).
226
- * Never a line-level `refused` entry without `rule` (that would silence every other rule red on the line). A rule the drafter already listed
227
- * itself is never listed twice, and running this twice adds nothing. Pure; the input is untouched.
228
- * @param {any} declaration @param {import('./pagerules.js').Dropped[]|null|undefined} dropped @param {any[]|null|undefined} jobLines @returns {any}
231
+ * A check-list row named in the person's plain words: `phrase "### Fixed"`. The words are the draft log's; with none, the text after the key's kind prefix (`L1.phrase.### fixed`).
232
+ * Never empty. Pure.
233
+ * @param {unknown} kind @param {string} key @param {string[]|null|undefined} words
234
+ * @returns {string}
229
235
  */
230
- export function withDropNotes(declaration: any, dropped: import("./pagerules.js").Dropped[] | null | undefined, jobLines: any[] | null | undefined): any;
236
+ export function listRowName(kind: unknown, key: string, words: string[] | null | undefined): string;
231
237
  /**
232
238
  * The ~ rules the drafter listed under Not checked (`refused` entries that name a `rule`), each as one line in the person's own
233
239
  * words: `line N: "<the rule as written>" — <the drafter's reason>` (PART 1b, RF6 / RF16).
234
- * @param {any} closeDecl @param {any[]|null|undefined} jobLines @returns {string[]}
240
+ * @param {any} closeDecl @param {any[]|null|undefined} jobLines @param {{key: string, words: string[]}[]|null} [ledger] the draft log's final list rows (`readDraftLedger`) @returns {string[]}
235
241
  */
236
- export function ruleNotChecked(closeDecl: any, jobLines: any[] | null | undefined): string[];
242
+ export function ruleNotChecked(closeDecl: any, jobLines: any[] | null | undefined, ledger?: {
243
+ key: string;
244
+ words: string[];
245
+ }[] | null): string[];
246
+ /** the same lines as {@link ruleNotChecked}, each with who it belongs to (`by`: the row's kind, F-c) @param {any} closeDecl @param {any[]|null|undefined} jobLines @param {{key: string, words: string[]}[]|null} [ledger] @returns {{text: string, by?: 'you'|'agent'|'default'}[]} */
247
+ export function ruleNotCheckedItems(closeDecl: any, jobLines: any[] | null | undefined, ledger?: {
248
+ key: string;
249
+ words: string[];
250
+ }[] | null): {
251
+ text: string;
252
+ by?: "you" | "agent" | "default";
253
+ }[];
254
+ /**
255
+ * The refusals of a signed close, as ONE reader: when the close carries the one check list (`closeDecl.list`) its not-checked rows are the refusals (a `~` rule's row names the rule, a fact row its
256
+ * fact name); the old `closeDecl.refused` entries a list has no row for (a line-level refusal, a rule the list never saw) are kept, so nothing the older close said is lost. A close with no list
257
+ * reads `refused` alone. Pure.
258
+ * @param {any} closeDecl
259
+ * @returns {{line: number, rule?: number, kind?: string, key?: string, by?: 'you'|'agent'|'default', label?: string, reason: string, fromList: boolean}[]}
260
+ */
261
+ export function refusedOf(closeDecl: any): {
262
+ line: number;
263
+ rule?: number;
264
+ kind?: string;
265
+ key?: string;
266
+ by?: "you" | "agent" | "default";
267
+ label?: string;
268
+ reason: string;
269
+ fromList: boolean;
270
+ }[];
237
271
  /**
238
272
  * The Not-checked lines code owns for the rubric-step stages of a close: a prose step's CONTENT is judged by the person at
239
273
  * Accept, and the card says so (PART 1b, RF5). One line per prose step (a stage with no fact part).
@@ -255,15 +289,15 @@ export function partSentence(part: any): string;
255
289
  * The checks a signed close actually runs, per job line, in plain code-written sentences: one per countable part of every
256
290
  * rubric-step stage. This is the ONE reader both the plan card and the sign-time invariant use.
257
291
  * Each row says who added the check (`by`): `you` = one of the person's picks, as the signed close's own record (`closeDecl.picks`) names it; `agent` = the drafter's;
258
- * `null` = code's own tie (the numbers of a text step come from the fact quotes), which is neither.
292
+ * `default` = code's own (the one list's `$` rows: the cited part written by `defaultCitedText`, and the numbers tie of a text step).
259
293
  * @param {any} closeDecl
260
- * @returns {{line: number, text: string, covers: number[], by: 'agent'|'you'|null}[]}
294
+ * @returns {{line: number, text: string, by: 'agent'|'you'|'default', key?: string}[]}
261
295
  */
262
296
  export function checksOfClose(closeDecl: any): {
263
297
  line: number;
264
298
  text: string;
265
- covers: number[];
266
- by: "agent" | "you" | null;
299
+ by: "agent" | "you" | "default";
300
+ key?: string;
267
301
  }[];
268
302
  /**
269
303
  * The names of the facts a signed close checks (every fact part of every rubric-step stage). Pure.
@@ -271,33 +305,40 @@ export function checksOfClose(closeDecl: any): {
271
305
  */
272
306
  export function signedFactNames(closeDecl: any): string[];
273
307
  /**
274
- * Reconcile the CONFIRMED plan with the close the composer actually wrote. The plan card after drafting shows exactly
275
- * the close's own checks (`checksOfClose`); every confirmed check that no part carries out (no part lists its number in
276
- * `covers`) is moved to Not checked, in the person's words, with the reason. A check can therefore never be shown and then
277
- * silently dropped (run mv5bk400: "lists 3 releases" was confirmed, then left out of the signed close without a word).
278
- * @param {{confirmed: {text: string, fromLine: number[]|null}[], notChecked: string[], closeDecl: any, jobLines?: any[]|null}} o
279
- * `jobLines` — the person's numbered lines, so a ~ rule the drafter listed as Not checked reads in the person's own words
280
- * @returns {{checkItems: {text: string, fromLine: number[], by: 'agent'|'you'|null}[], notChecked: string[], moved: {text: string, fromLine: number[]|null}[]}}
308
+ * The plan card after drafting, read from the signed close ALONE (one source, the same the Job tab reads): its checks are `checksOfClose`; its Not checked is the close's own notes, the prose
309
+ * steps' "you judge it at Accept" lines and the refusals (`ruleNotChecked`, which reads the list's not-checked rows when the close carries the list). Nothing the confirm turn said is merged
310
+ * in: a rubric confirm turn plans the goal only, so a check can never be shown and then silently dropped (run mv5bk400).
311
+ * @param {{closeDecl: any, jobLines?: any[]|null, ledger?: {key: string, words: string[]}[]|null}} o `jobLines` the person's numbered lines, so a ~ rule reads in the person's own words; `ledger` the draft log's final list rows, so a phrase row is named by its words
312
+ * @returns {{checkItems: {text: string, fromLine: number[], by: 'agent'|'you'|'default', key?: string}[], notChecked: string[], notCheckedBy: Record<string, 'you'|'agent'|'default'>}}
281
313
  */
282
- export function reconcileRubricPlan({ confirmed, notChecked, closeDecl, jobLines }: {
283
- confirmed: {
284
- text: string;
285
- fromLine: number[] | null;
286
- }[];
287
- notChecked: string[];
314
+ export function cardOfClose({ closeDecl, jobLines, ledger }: {
288
315
  closeDecl: any;
289
316
  jobLines?: any[] | null;
317
+ ledger?: {
318
+ key: string;
319
+ words: string[];
320
+ }[] | null;
290
321
  }): {
291
322
  checkItems: {
292
323
  text: string;
293
324
  fromLine: number[];
294
- by: "agent" | "you" | null;
325
+ by: "agent" | "you" | "default";
326
+ key?: string;
295
327
  }[];
296
328
  notChecked: string[];
297
- moved: {
298
- text: string;
299
- fromLine: number[] | null;
300
- }[];
329
+ notCheckedBy: Record<string, "you" | "agent" | "default">;
330
+ };
331
+ /**
332
+ * The sign-time check of a close that carries the one check list: every BUILT row (the mechanical floor aside) points at a part that is really in the close, and every real check part
333
+ * (countable or fact) has at least one built row pointing at it, so a check cannot be in the close with no row and a row cannot claim a check the close does not run. A close with no list is
334
+ * not examined here. Pure.
335
+ * @param {any} closeDecl @returns {{ok: true}|{ok: false, error: string}}
336
+ */
337
+ export function listMatchesClose(closeDecl: any): {
338
+ ok: true;
339
+ } | {
340
+ ok: false;
341
+ error: string;
301
342
  };
302
343
  /**
303
344
  * The sign-time invariant: the checks the person was shown (`shown`, from the plan card) are exactly the checks the signed
@@ -350,6 +391,8 @@ export const COUNT_CHECKS: Readonly<Record<string, readonly string[]>>;
350
391
  export function sha256Of(b: string | Buffer): string;
351
392
  export function boundInWords(b: unknown, said: string): boolean;
352
393
  export function wordsSaidOn(jl: any): string;
394
+ export const NEGATING_RE: RegExp;
395
+ export function defaultCitedText(label: string): string;
353
396
  export type ShapeRed = {
354
397
  code: string;
355
398
  path: string;
package/types/run.d.ts CHANGED
@@ -51,6 +51,10 @@
51
51
  * never a step knob and never agent-selectable; absent, a judged stage instrument-stops as
52
52
  * a wiring gap rather than grading on whatever binding happened to be at hand. Its spend
53
53
  * lands on this ledger as `judge-round` (see `ACCOUNTED_ROUND_TYPES`).
54
+ * @param {Record<string, string>|null} [opts.placeValues] PLACE RULES (src/placerule.js): the values this run's start read for the spec's place-rule facts, by key. Bound
55
+ * as those facts' phrases on the run's own in-memory copy AFTER the approval check and the `job-start` record, so the hash checked and the hash recorded stay the
56
+ * SIGNED one and the signed spec is never changed; the planner and the close read the copy. Absent = the signed words.
57
+ * @param {{workflowKey: string, rows: object[]}|null} [opts.placeRead] PLACE RULES: what the run start read (rows {key, kind, found, value, was, reason}); recorded once as a `place-rules` event right after `job-start`. Absent = the job has none (or this is a resume, whose first leg wrote it).
54
58
  * @param {number} [opts.capRuns] shell-owned iteration cap for the plan flow's
55
59
  * CLOSE-FIX loop (a plan STEP runs under the strike ladder instead)
56
60
  * @param {number} [opts.strikeLimit] shell-owned strike ceiling for a plan step's ladder
@@ -219,7 +223,7 @@
219
223
  * deliberately NOT in the resumable/checkpoint set (`src/reuse.js`) — an
220
224
  * unknown in-flight state is not a known-safe resume point.
221
225
  */
222
- export function runJob(rawSpec: object | string, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider, judgeModel, rates, judgeRates, emit, capRuns, strikeLimit, shellCapUsd, closeTimeoutMs, closeDir, layerRoot, readShim, scout, bridge, draftSpentUsd, draftSpendComplete, priorSpentUsd, priorSpendComplete, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun, resumable, stopFile, learnHints, ticketRecord, ticketUnsure, prRecord }: {
226
+ export function runJob(rawSpec: object | string, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider, judgeModel, rates, judgeRates, emit, capRuns, strikeLimit, shellCapUsd, closeTimeoutMs, closeDir, layerRoot, readShim, scout, bridge, draftSpentUsd, draftSpendComplete, priorSpentUsd, priorSpendComplete, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun, resumable, stopFile, learnHints, ticketRecord, ticketUnsure, prRecord, placeValues, placeRead }: {
223
227
  approvals: unknown;
224
228
  workdir: string;
225
229
  provider: any;
@@ -241,6 +245,11 @@ export function runJob(rawSpec: object | string, { approvals, workdir, provider,
241
245
  } | null | undefined;
242
246
  judgeModel?: string | null | undefined;
243
247
  judgeProvider?: any;
248
+ placeValues?: Record<string, string> | null | undefined;
249
+ placeRead?: {
250
+ workflowKey: string;
251
+ rows: object[];
252
+ } | null | undefined;
244
253
  capRuns?: number | undefined;
245
254
  strikeLimit?: number | undefined;
246
255
  shellCapUsd?: number | undefined;