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.
- package/CHANGELOG.md +47 -0
- package/bareloop.context.md +4 -2
- package/package.json +2 -2
- package/src/authorflow.js +141 -264
- package/src/authoring.js +2 -3
- package/src/authorjob.js +117 -88
- package/src/authorreadout.js +9 -15
- package/src/authorrun.js +13 -4
- package/src/behaviour.js +14 -0
- package/src/blockasks.js +43 -0
- package/src/checkblock.js +772 -0
- package/src/checklist.js +128 -0
- package/src/checkpick.js +30 -312
- package/src/checkwords.js +3 -1
- package/src/declaredclose.js +30 -1
- package/src/destpoint.js +3 -1
- package/src/draftspend.js +46 -0
- package/src/facts.js +8 -1
- package/src/fitcheck.js +5 -3
- package/src/pagemap.js +15 -3
- package/src/panel/authorroutes.js +15 -3
- package/src/panel/authorsession.js +133 -46
- package/src/panel/index.html +194 -22
- package/src/panel/jobplan.js +85 -33
- package/src/panel/server.js +52 -7
- package/src/pickrecord.js +19 -1
- package/src/placerule.js +355 -0
- package/src/promptregisters.js +11 -0
- package/src/questionbox.js +112 -0
- package/src/rowedit.js +115 -0
- package/src/rubricstep.js +212 -125
- package/src/run.js +10 -2
- package/src/userrun.js +46 -1
- package/types/authorflow.d.ts +32 -139
- package/types/authorjob.d.ts +24 -6
- package/types/authorreadout.d.ts +4 -10
- package/types/behaviour.d.ts +12 -0
- package/types/blockasks.d.ts +37 -0
- package/types/checkblock.d.ts +361 -0
- package/types/checklist.d.ts +134 -0
- package/types/checkpick.d.ts +3 -140
- package/types/declaredclose.d.ts +4 -0
- package/types/destpoint.d.ts +2 -0
- package/types/draftspend.d.ts +21 -0
- package/types/fitcheck.d.ts +7 -1
- package/types/pagemap.d.ts +4 -0
- package/types/panel/authorsession.d.ts +13 -2
- package/types/panel/jobgrid.d.ts +8 -8
- package/types/panel/jobplan.d.ts +48 -10
- package/types/panel/server.d.ts +14 -13
- package/types/pickrecord.d.ts +12 -0
- package/types/placerule.d.ts +194 -0
- package/types/questionbox.d.ts +87 -0
- package/types/rowedit.d.ts +32 -0
- package/types/rubricstep.d.ts +91 -48
- 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[];
|
package/types/rubricstep.d.ts
CHANGED
|
@@ -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
|
-
*
|
|
203
|
-
*
|
|
204
|
-
*
|
|
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
|
|
212
|
+
export function holdsManyBounds(shape: string, text: string): boolean;
|
|
213
213
|
/**
|
|
214
|
-
*
|
|
215
|
-
*
|
|
216
|
-
*
|
|
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
|
|
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
|
-
*
|
|
222
|
-
*
|
|
223
|
-
*
|
|
224
|
-
*
|
|
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
|
|
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
|
|
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
|
-
* `
|
|
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,
|
|
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
|
-
|
|
266
|
-
|
|
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
|
-
*
|
|
275
|
-
*
|
|
276
|
-
*
|
|
277
|
-
*
|
|
278
|
-
* @
|
|
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
|
|
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" |
|
|
325
|
+
by: "agent" | "you" | "default";
|
|
326
|
+
key?: string;
|
|
295
327
|
}[];
|
|
296
328
|
notChecked: string[];
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
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;
|