bareloop 0.57.0 → 0.58.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 (49) hide show
  1. package/CHANGELOG.md +45 -0
  2. package/bareloop.context.md +11 -8
  3. package/package.json +1 -1
  4. package/src/authorflow.js +50 -62
  5. package/src/authorjob.js +100 -30
  6. package/src/authorreadout.js +88 -0
  7. package/src/authorrun.js +63 -24
  8. package/src/authorscout.js +9 -1
  9. package/src/blockasks.js +11 -16
  10. package/src/checkblock.js +227 -31
  11. package/src/checkpick.js +0 -5
  12. package/src/declaredclose.js +38 -6
  13. package/src/draftspend.js +20 -4
  14. package/src/fencepointcall.js +76 -0
  15. package/src/guarddescriptions.js +14 -0
  16. package/src/kinds.js +5 -1
  17. package/src/pagemap.js +7 -29
  18. package/src/panel/authorroutes.js +6 -1
  19. package/src/panel/authorsession.js +108 -32
  20. package/src/panel/index.html +38 -13
  21. package/src/panel/jobplan.js +49 -16
  22. package/src/panel/server.js +66 -6
  23. package/src/planrun.js +2 -0
  24. package/src/promptregisters.js +5 -0
  25. package/src/questionbox.js +32 -20
  26. package/src/reviewdoor.js +1 -1
  27. package/src/rowresults.js +69 -0
  28. package/src/rubricstep.js +110 -22
  29. package/src/stagewords.js +24 -0
  30. package/types/authorflow.d.ts +42 -79
  31. package/types/authorjob.d.ts +3 -2
  32. package/types/authorreadout.d.ts +44 -0
  33. package/types/authorrun.d.ts +20 -0
  34. package/types/blockasks.d.ts +5 -10
  35. package/types/checkblock.d.ts +115 -11
  36. package/types/checkpick.d.ts +0 -3
  37. package/types/declaredclose.d.ts +3 -1
  38. package/types/draftspend.d.ts +16 -2
  39. package/types/fencepointcall.d.ts +68 -0
  40. package/types/guarddescriptions.d.ts +7 -0
  41. package/types/kinds.d.ts +1 -0
  42. package/types/pagemap.d.ts +2 -5
  43. package/types/panel/authorsession.d.ts +3 -2
  44. package/types/panel/jobplan.d.ts +13 -1
  45. package/types/panel/server.d.ts +41 -16
  46. package/types/questionbox.d.ts +20 -6
  47. package/types/rowresults.d.ts +23 -0
  48. package/types/rubricstep.d.ts +34 -7
  49. package/types/stagewords.d.ts +11 -0
@@ -196,6 +196,7 @@
196
196
  .rp-status{font-size:13px;color:var(--text-dim);min-width:0;overflow-wrap:anywhere;}
197
197
  .rp-sep{color:var(--text-faint);margin-right:6px;}
198
198
  .st-word{font-weight:700;color:var(--text);}
199
+ .audit-checks-label{font-size:12px;}
199
200
  .wf-ended-inline{flex:1 1 auto;white-space:normal;}
200
201
  .wf-compact{flex-wrap:wrap;}
201
202
  .wf-runno{color:var(--accent);flex:none;}
@@ -479,6 +480,7 @@
479
480
  /* PRD v1.107 Part 6: the Result tab. Boxes are the Job tab's own (.job-card, .field, .ro-value, .field-row); text wraps, nothing scrolls the page. */
480
481
  #result-body{min-width:0;overflow-wrap:anywhere;}
481
482
  .rs-ok{color:var(--green);font-weight:700;}
483
+ .rs-bad{color:var(--red);font-weight:700;}
482
484
  #result-body mark{background:var(--rl-accent-bg-strong);color:var(--text);border-radius:2px;padding:0 1px;}
483
485
  #result-door-card{border-color:var(--amber);}
484
486
  #result-door-card .st-word{color:var(--amber);}
@@ -706,6 +708,9 @@
706
708
  .jp-qs .lbl{display:inline-block;color:var(--text-faint);margin-right:8px;}
707
709
  .jp-qs ul{margin:4px 0;padding-left:26px;}
708
710
  .jp-goal{font-size:12px;color:var(--text-faint);margin-top:8px;}
711
+ /* the draft readout above the signed-ready card: plain text, wrapped, the server names the heading lines (bold) */
712
+ .jp-readout{white-space:pre-wrap;overflow-wrap:anywhere;font-size:12px;margin:0 0 12px;padding-bottom:10px;border-bottom:1px solid var(--border);}
713
+ .jp-readout b{font-weight:700;}
709
714
  /* hamr 2026-10-05: the focused/selected Chat-card field gets a blue border (the accent), no outline ring */
710
715
  #panel-chat :is(input,select,textarea):focus{border-color:var(--accent);outline:none;}
711
716
  /* hamr 2026-10-05: the ask box is dimmed until something asks for a reply (placeholder stays readable) */
@@ -1057,13 +1062,13 @@
1057
1062
  <button class="btn primary wide" type="button" id="chat-q-send" data-testid="chat-q-send">Send</button>
1058
1063
  </div>
1059
1064
 
1060
- <div class="chat-input-row">
1065
+ <div class="chat-input-row" hidden>
1061
1066
  <label for="chat-msg" style="display:none">Message</label>
1062
1067
  <textarea id="chat-msg" rows="2" placeholder="Answer here when the draft asks you a question…" data-testid="chat-msg"></textarea>
1063
1068
  </div>
1064
1069
  <button class="btn primary wide" type="button" id="chat-main-btn" data-testid="chat-main" disabled>Start drafting</button>
1065
1070
  <div class="hint" id="chat-main-hint" data-testid="chat-main-hint"></div>
1066
- <!-- hamr 2026-10-09: Revise = reopen the boxes, filled as drafted, and draft again. Shown only while a plan waits for the OK. -->
1071
+ <!-- hamr 2026-10-09: Revise = reopen the boxes, filled as drafted, and draft again. Shown while a plan waits for the OK and on the final card (phase prepared). -->
1067
1072
  <button class="btn wide" type="button" id="chat-reopen-btn" data-testid="chat-reopen" hidden>Revise</button>
1068
1073
  <!-- fwd M4e am14 item 3: "N revises left"; after the second revise this same button reads Start over (a fresh draft, its own 2 revises) -->
1069
1074
  <span id="chat-left-count" data-testid="revises-left" class="hint" hidden></span>
@@ -3671,7 +3676,7 @@
3671
3676
  });
3672
3677
  // PRD v1.106 Part 5 Q1: each question the person answered, under its step, in the server's own words (asked, then said); wraps
3673
3678
  (Array.isArray(st.humans) ? st.humans : []).forEach(function(h){
3674
- rows += '<tr class="human-row" data-testid="drafting-human"><td colspan="5" style="overflow-wrap:anywhere;white-space:pre-wrap">' + escapeXml(h.askedText) + "<br>" + escapeXml(h.saidText) + "</td></tr>";
3679
+ rows += '<tr class="human-row" data-testid="drafting-human"><td colspan="5" style="overflow-wrap:anywhere;white-space:pre-wrap">' + escapeXml(h.askedText) + (h.saidText ? "<br>" + escapeXml(h.saidText) : "") + "</td></tr>";
3675
3680
  });
3676
3681
  });
3677
3682
  rows += '<tr class="drafting-total"><td><b>total</b></td><td>' + (part.wallMs === null || part.wallMs === undefined ? "–" : duration(part.wallMs)) +
@@ -3845,7 +3850,7 @@
3845
3850
  // one row of the Audit's check list: its words, its tag, its result in the one state sign+word markup (a row with no recorded verdict says so, never "passed")
3846
3851
  function auditCheckRowHtml(r){
3847
3852
  var res = r.result === "held" ? ["green", r.word || "held"] : r.result === "record-missing" ? ["grey", r.word || "the gate's record for this run is missing"] : r.result === "passed" ? ["green", "passed"] : r.result === "failed" ? ["red", "failed"] : r.result === "not-checked" ? ["grey", "not checked"] : r.result === "not-reached" ? ["grey", r.word || "not reached"] : ["grey", "no result recorded"];
3848
- return '<div class="audit-check-row" data-testid="audit-check-row" data-result="' + escapeXml(r.result) + '" style="overflow-wrap:anywhere">' + escapeXml(r.text) + byTagOf(r.by) + " " + stateDotHTML(res[0], res[1], "audit-check-state") + "</div>";
3853
+ return '<div class="audit-check-row" data-testid="audit-check-row" data-result="' + escapeXml(r.result) + '" style="overflow-wrap:anywhere">' + escapeXml(r.text) + byTagOf(r.by) + " " + stateDotHTML(res[0], res[1], "audit-check-state") + (r.result === "failed" && r.why ? ' <span class="hint" data-testid="audit-check-why">\u2014 ' + escapeXml(r.why) + "</span>" : "") + "</div>";
3849
3854
  }
3850
3855
  // the Checks fold's one state sign (code-owned, one place): any row failed = [✗]; else any row with no recorded result / no gate record = [·]; else [✓] ("held" is passed, "not checked" rows never move it)
3851
3856
  function auditChecksSignClass(rows){
@@ -3861,7 +3866,7 @@
3861
3866
  var nPass = all.filter(function(r){ return r.result === "passed" || r.result === "held"; }).length;
3862
3867
  var nFail = all.filter(function(r){ return r.result === "failed"; }).length;
3863
3868
  var nUnreached = all.filter(function(r){ return r.result === "not-reached"; }).length;
3864
- var head = "checks &middot; " + nPass + " passed" + (nFail ? " &middot; " + nFail + " failed" : "") + (nUnreached ? " &middot; " + nUnreached + " not reached" : "") + ((ac.notChecked || []).length ? " &middot; " + ac.notChecked.length + " not checked" : "");
3869
+ var head = '<b class="st-word audit-checks-label">checks</b>' + " &middot; " + nPass + " passed" + (nFail ? " &middot; " + nFail + " failed" : "") + (nUnreached ? " &middot; " + nUnreached + " not reached" : "") + ((ac.notChecked || []).length ? " &middot; " + ac.notChecked.length + " not checked" : "");
3865
3870
  var btn = document.createElement("button");
3866
3871
  btn.type = "button";
3867
3872
  btn.className = "btn audit-part-toggle";
@@ -4153,7 +4158,7 @@
4153
4158
  // (src/panel/jobplan.js): numbered lines with their rule, the checks under the line each serves (folded), the AI's own
4154
4159
  // "Not checked", the always-on guards. Only the marker is blue (--plan). Returns HTML (every text is escaped).
4155
4160
  // the tag of a row by its kind (F-c, code-owned): `~` rows [you], `!` rows [agent], `$` rows [default]; one spelling for the confirm card, the signed card, the Job tab and the Result tab
4156
- function byTagOf(by){ return by === "you" ? ' <span class="by" data-testid="plan-by" data-by="you">[you]</span>' : by === "agent" ? ' <span class="by" data-testid="plan-by" data-by="agent">[agent]</span>' : by === "default" ? ' <span class="by" data-testid="plan-by" data-by="default">[default]</span>' : ""; }
4161
+ function byTagOf(by){ return by === "you" ? ' <span class="by" data-testid="plan-by" data-by="you">~ [you]</span>' : by === "agent" ? ' <span class="by" data-testid="plan-by" data-by="agent">! [agent]</span>' : by === "default" ? ' <span class="by" data-testid="plan-by" data-by="default">$ [default]</span>' : ""; }
4157
4162
  function renderJobPlan(plan, ctl){
4158
4163
  // the legend promises \u203A checks, so it shows only when the plan has one to show (the goal-only confirm card has none yet)
4159
4164
  var hasCheck = (plan.loose || []).length > 0 || (plan.lines || []).some(function(l){ return (l.checks || []).length || (l.picked || []).length || (l.always || []).length; });
@@ -4343,6 +4348,15 @@
4343
4348
  }
4344
4349
  return h;
4345
4350
  }
4351
+ // each row of the line with its OWN mark (Addendum 2026-11-14 (c) piece 4): \u2713 passed, \u2717 failed (with the check's reason), \u00B7 no result; a gap no row owns is its own failed item. The server decides every mark and word
4352
+ function resultCheckRowsHtml(line){
4353
+ var rows = line.checkRows || [], gaps = line.unclaimed || [];
4354
+ if(!rows.length && !gaps.length) return "";
4355
+ var mark = function(res){ return res === "passed" ? '<span class="rs-ok">\u2713</span>' : res === "failed" ? '<span class="rs-bad">\u2717</span>' : '<span class="hint">\u00B7</span>'; };
4356
+ return resultField("Each check", '<div class="ro-value" data-testid="result-checkrows">' + rows.map(function(r){
4357
+ return '<div data-testid="result-checkrow" data-result="' + escapeXml(r.result) + '">' + mark(r.result) + " " + escapeXml(r.text) + byTagOf(r.by) + (r.result === "failed" && r.why ? ' <span class="hint">\u2014 ' + escapeXml(r.why) + "</span>" : "") + "</div>";
4358
+ }).join("") + gaps.map(function(g){ return '<div data-testid="result-checkrow" data-result="failed"><span class="rs-bad">\u2717</span> ' + escapeXml(g) + "</div>"; }).join("") + "</div>");
4359
+ }
4346
4360
  function resultTextLine(line){
4347
4361
  var h = resultFileWords(line.file);
4348
4362
  if(typeof line.answer === "string") h += resultField("Answer", '<div class="ro-value" data-testid="result-answer" style="color:var(--text);white-space:pre-wrap">' + escapeXml(line.answer) + '</div>');
@@ -4369,7 +4383,7 @@
4369
4383
  function resultLineCard(line, own, note){
4370
4384
  return '<div class="job-card" data-testid="result-line"><h4>Line ' + escapeXml(String(line.n)) + '</h4>' + resultLineBox(line) +
4371
4385
  (own ? resultPageLink(line.page, note, "result-page-line") : "") +
4372
- (line.kind === "facts" ? resultFactsLine(line) : resultTextLine(line)) +
4386
+ (line.kind === "facts" ? resultFactsLine(line) : resultTextLine(line)) + resultCheckRowsHtml(line) +
4373
4387
  resultNotChecked("Not checked", line.notChecked, "result-line-notchecked", line.notCheckedBy) + '</div>';
4374
4388
  }
4375
4389
  // ---- the generic Result tab (R7b item 4): every ended non-rubric run. The server sends the facts and the words (`kind: "generic"`); the page only draws.
@@ -5458,6 +5472,8 @@
5458
5472
  var mainBtn = document.getElementById("chat-main-btn");
5459
5473
  var mainHint = document.getElementById("chat-main-hint");
5460
5474
  var reopenBtn = document.getElementById("chat-reopen-btn");
5475
+ // hamr 2026-11-15: the chat's typing box is shown only while something asks to be typed (the language, the goal); a check question has buttons and no box (renderQuestionBox), and with no ask the box is not drawn dimmed
5476
+ var chatRowEl = document.querySelector(".chat-input-row");
5461
5477
  var qBox = document.getElementById("chat-question");
5462
5478
  var qHead = document.getElementById("chat-q-head");
5463
5479
  var qLine = document.getElementById("chat-q-line");
@@ -5746,7 +5762,7 @@
5746
5762
  document.getElementById("jf-cap-time").parentNode.hidden = false;
5747
5763
  document.getElementById("chat-clear-btn").hidden = false;
5748
5764
  ["chat-main-btn", "chat-main-hint"].forEach(function(id){ document.getElementById(id).hidden = false; });
5749
- document.querySelector(".chat-input-row").hidden = false;
5765
+ document.querySelector(".chat-input-row").hidden = true;
5750
5766
  }
5751
5767
  function openNewCard(){
5752
5768
  card.hidden = false;
@@ -6071,6 +6087,13 @@
6071
6087
  function planControlHTML(op, key){
6072
6088
  return ' <button type="button" class="btn jp-btn" data-testid="plan-' + op + '" data-rowop="' + op + '" data-rowkey="' + escapeXml(key) + '">' + (op === "add" ? "Add" : "Drop") + "</button>";
6073
6089
  }
6090
+ // the draft readout is plain text; the server names which lines are headings (src/authorreadout.js readoutHeadIndexes), drawn bold
6091
+ function readoutHtml(r){
6092
+ var heads = Array.isArray(r.heads) ? r.heads : [];
6093
+ return r.text.replace(/\s+$/, "").split("\n").map(function(l, i){
6094
+ return heads.indexOf(i) >= 0 ? "<b>" + escapeXml(l) + "</b>" : escapeXml(l);
6095
+ }).join("\n");
6096
+ }
6074
6097
  function renderMessages(state){
6075
6098
  var sig = JSON.stringify(state.messages);
6076
6099
  if(sig === lastMsgSig) return;
@@ -6081,11 +6104,12 @@
6081
6104
  var who = chatWhoLabel(m.role);
6082
6105
  var whoHtml = who ? ('<div class="who">' + escapeXml(who) + '</div>') : "";
6083
6106
  if(m.kind === "plan" && m.plan){
6107
+ var ro = m.readout && typeof m.readout.text === "string" ? '<div class="jp-readout" data-testid="plan-readout">' + readoutHtml(m.readout) + "</div>" : "";
6084
6108
  // P7: the confirm turn's plan is drawn by the one job-plan renderer (the Job tab uses the same)
6085
6109
  var qs = (m.plan.questions || []).length
6086
6110
  ? '<div class="jp-qs" data-testid="plan-questions"><span class="lbl">AI\'s open questions</span><ul>' +
6087
6111
  m.plan.questions.map(function(q){ return "<li>" + escapeXml(q) + "</li>"; }).join("") + "</ul><b>Revise if you need to.</b></div>" : "";
6088
- return '<div class="msg ' + cls + '" data-testid="plan-bubble">' + whoHtml + renderJobPlan(m.plan, m.plan.editable === true ? planControlHTML : null) + qs + '<div class="jp-goal">' + escapeXml(m.text) + "</div></div>";
6112
+ return '<div class="msg ' + cls + '" data-testid="plan-bubble">' + whoHtml + ro + renderJobPlan(m.plan, m.plan.editable === true ? planControlHTML : null) + qs + '<div class="jp-goal">' + escapeXml(m.text) + "</div></div>";
6089
6113
  }
6090
6114
  return '<div class="msg ' + cls + '">' + whoHtml + escapeXml(m.text) + '</div>';
6091
6115
  }).join("");
@@ -6162,7 +6186,8 @@
6162
6186
  if(st.phase === "prepared" && st.signClicked){
6163
6187
  return {text: "Sign " + (st.specHash || "").slice(0, 8) + " & run", action: "sign", disabled: false, hint: hint};
6164
6188
  }
6165
- return {text: "Sign & run", action: "sign-prepare", disabled: false, hint: hint};
6189
+ // at the plan menu this click only confirms the plan and starts drafting the checks (it never signs): it says so. A drafted card's first click (a Reuse) keeps "Sign & run"
6190
+ return {text: atMenu ? "Draft the plan" : "Sign & run", action: "sign-prepare", disabled: false, hint: hint};
6166
6191
  }
6167
6192
  return {text: "Sign & run", action: "none", disabled: true, hint: ""};
6168
6193
  }
@@ -6172,9 +6197,9 @@
6172
6197
  function askBoxOpenFor(st){
6173
6198
  return !!st.session && !!st.pendingAsk && st.pendingAsk.kind !== "install-needed" && st.pendingAsk.kind !== "menu";
6174
6199
  }
6175
- // pure: Revise shows only while a plan waits for the OK
6200
+ // pure: Revise shows while a plan waits for the OK (the plan menu) AND on the final signed-ready card (phase "prepared": the pending ask is null there, which is why it never showed)
6176
6201
  function reviseShownFor(st){
6177
- return !!st.session && !!st.pendingAsk && st.pendingAsk.kind === "menu";
6202
+ return !!st.session && ((!!st.pendingAsk && st.pendingAsk.kind === "menu") || (st.phase === "prepared" && !st.pendingAsk));
6178
6203
  }
6179
6204
  // fwd M4e am14 item 3 (pure): 2 revises per draft, shown as "2 revises left" / "1 revise left"; with none left the same button reads Start over. The SERVER counts (revisesLeft); an
6180
6205
  // absent number (a state from before the count) reads as 2.
@@ -6193,6 +6218,7 @@
6193
6218
  }
6194
6219
  // hamr 2026-10-05: the ask box is open only while something asks for a reply; otherwise dimmed and emptied
6195
6220
  var open = askBoxOpenFor(st);
6221
+ chatRowEl.hidden = !open || !!(st.pendingAsk && st.pendingAsk.box);
6196
6222
  msgInput.disabled = !open;
6197
6223
  if(!open) msgInput.value = "";
6198
6224
  var b = mainButtonFor(st, !msgInput.value.trim(), reusePathNow() || verdictValue() === "reuse");
@@ -6288,7 +6314,6 @@
6288
6314
  var ask = state && state.pendingAsk;
6289
6315
  var b = ask && ask.box ? ask.box : null;
6290
6316
  qBox.hidden = b === null;
6291
- document.querySelector(".chat-input-row").hidden = b !== null;
6292
6317
  mainBtn.hidden = b !== null; mainHint.hidden = b !== null;
6293
6318
  if(b === null){ qKey = null; return; }
6294
6319
  var key = String(sessionId) + ":" + String(ask.index) + ":" + String(ask.source) + ":" + b.text;
@@ -14,14 +14,16 @@
14
14
  import { NOT_REACHED } from './status.js';
15
15
  import { ticketFilterWords } from '../ticketfilter.js';
16
16
  import { KIND_CATALOGUE } from '../authoring.js';
17
+ import { stageQuestionsByName } from '../stagewords.js';
17
18
  import { WEEK_ONLY_WORDS } from '../checklist.js';
18
19
  import { splitReadNotes } from '../pagedropwords.js';
19
- import { checksOfClose, signedFactNames, proseNotChecked, lineRules, confirmedGoalOf, refusedOf, listRowName, ruleNotCheckedItems } from '../rubricstep.js';
20
+ import { checksOfClose, carriesOneList, FENCE_KEY, guardKeyOf, stageKeyOf, guardRowText, signedFactNames, proseNotChecked, lineRules, confirmedGoalOf, refusedOf, listRowName, ruleNotCheckedItems } from '../rubricstep.js';
20
21
 
21
22
  /** `by` = who added the check: the drafter (`agent`) or the person's own pick (`you`); absent = code's own (an always-on guard, a number tie) or not known */
22
23
  /** `stage` = the signed close stage the row belongs to (its recorded verdict is the row's result in the Audit) */
23
- /** @typedef {{text: string, by: 'agent'|'you'|'default'|null, result: 'passed'|'failed'|'none'|'not-reached'|'not-checked'|'held'|'record-missing', word?: string}} AuditRow */
24
- /** @typedef {{name: string, cls: 'machine check'|'judge'|null, by?: 'agent'|'you'|'default'|null, key?: string, stage?: string}} PlanCheck */
24
+ /** @typedef {{text: string, by: 'agent'|'you'|'default'|null, result: 'passed'|'failed'|'none'|'not-reached'|'not-checked'|'held'|'record-missing', word?: string, key?: string, why?: string}} AuditRow */
25
+ /** `fence` = a repo job's `~` rule the write fence keeps (its result is the gate's record of the run, like the fence row's) */
26
+ /** @typedef {{name: string, cls: 'machine check'|'judge'|null, by?: 'agent'|'you'|'default'|null, key?: string, stage?: string, fence?: true}} PlanCheck */
25
27
  /** @typedef {{n: number, text: string, rule: string, rules: string[], checks: PlanCheck[], refused: string[], always?: string[], picked?: string[]}} PlanLine */
26
28
  /** @typedef {{lines: PlanLine[], loose: PlanCheck[], notChecked: string[], readNotes: string[], alwaysOn: string[], older: boolean, goal?: string, ticketFilter?: string, notCheckedBy?: Record<string, 'you'|'agent'|'default'>, suggested?: {key: string, line: number, text: string}[], editable?: boolean}} JobPlan */
27
29
 
@@ -55,7 +57,7 @@ export function checkClassOfKind(kind) {
55
57
  * @returns {JobPlan}
56
58
  */
57
59
  export function planFromSpec(spec, ledger = null) {
58
- /** @type {{name: string, cls: 'machine check'|'judge'|null, fromLine: number[]|null, by?: 'agent'|'you'|'default'|null, stage?: string}[]} */
60
+ /** @type {{name: string, cls: 'machine check'|'judge'|null, fromLine: number[]|null, by?: 'agent'|'you'|'default'|null, stage?: string, key?: string}[]} */
59
61
  let stages = [];
60
62
  if (spec && Array.isArray(spec.closeDecl?.stages)) {
61
63
  stages = spec.closeDecl.stages.filter((/** @type {any} */ s) => s && typeof s.name === 'string' && s.name)
@@ -63,8 +65,13 @@ export function planFromSpec(spec, ledger = null) {
63
65
  const fromLine = Array.isArray(s.fromLine) && s.fromLine.length ? s.fromLine.filter(Number.isInteger) : null;
64
66
  // PART 1b: a rubric-step stage is shown as the checks it RUNS — one code-worded row per fact, per count, per limit — read by
65
67
  // the same reader (`checksOfClose`) the confirm card and the sign-time invariant use, so the Job tab cannot differ from them
66
- const rows = s.kind === 'rubric-step' ? checksOfClose({ stages: [s], picks: spec.closeDecl.picks, list: spec.closeDecl.list }) : [];
67
- return rows.length > 0 ? rows.map((r) => ({ name: r.text, cls: /** @type {'machine check'} */ ('machine check'), fromLine, by: r.by, stage: s.name })) : [{ name: s.name, cls: checkClassOfKind(s.kind), fromLine, by: /** @type {'agent'} */ ('agent'), stage: s.name }];
68
+ const rows = s.kind === 'rubric-step' ? checksOfClose({ stages: [s], picks: spec.closeDecl.picks, list: spec.closeDecl.list }).filter((r) => r.line !== 0) : [];
69
+ // a guard stage the signed list holds as a job-level `$` row (piece 2) is that row: one check that serves no one line, drawn once, never "Always checked"
70
+ const guardRow = s.kind !== 'rubric-step' && Array.isArray(spec.closeDecl.list) ? spec.closeDecl.list.find((/** @type {any} */ r) => r && r.kind === 'guard' && r.state === 'built' && r.key === guardKeyOf(s.name)) : null;
71
+ if (guardRow) return [{ name: guardRowText(s.name), cls: checkClassOfKind(s.kind), fromLine: /** @type {number[]} */ ([0]), by: /** @type {'default'} */ ('default'), stage: s.name, key: String(guardRow.key) }];
72
+ // a repo job's `!` work stage is its list row (Addendum 2026-11-15 (d)): the row's key rides on the check
73
+ const stageRow = s.kind !== 'rubric-step' && Array.isArray(spec.closeDecl.list) && spec.closeDecl.list.some((/** @type {any} */ r) => r && r.kind === 'stage' && r.key === stageKeyOf(s.name));
74
+ return rows.length > 0 ? rows.map((r) => ({ name: r.text, cls: /** @type {'machine check'} */ ('machine check'), fromLine, by: r.by, stage: s.name, ...(r.key ? { key: r.key } : {}) })) : [{ name: stageRow ? (stageQuestionsByName(spec).get(s.name) ?? s.name) : s.name, cls: checkClassOfKind(s.kind), fromLine, by: /** @type {'agent'} */ ('agent'), stage: s.name, ...(stageRow ? { key: stageKeyOf(s.name) } : {}) }];
68
75
  });
69
76
  } else if (spec && Array.isArray(spec.close)) {
70
77
  stages = spec.close.filter((/** @type {any} */ s) => s && typeof s.name === 'string' && s.name)
@@ -72,7 +79,7 @@ export function planFromSpec(spec, ledger = null) {
72
79
  }
73
80
  // a prose step says what it does not check (PART 1b, RF5): the person judges the text at Accept
74
81
  const allNotes = [
75
- ...(Array.isArray(spec?.closeDecl?.notes) ? spec.closeDecl.notes.filter((/** @type {any} */ n) => typeof n === 'string' && n) : []),
82
+ ...(Array.isArray(spec?.closeDecl?.notes) && !carriesOneList(spec.closeDecl) ? spec.closeDecl.notes.filter((/** @type {any} */ n) => typeof n === 'string' && n) : []),
76
83
  ...proseNotChecked(spec?.closeDecl),
77
84
  ];
78
85
  // code's notes on which written forms of a still-checked fact were not used are "How the page was read", not Not checked
@@ -99,11 +106,17 @@ export function planFromSpec(spec, ledger = null) {
99
106
  if (s.fromLine === null) { alwaysOn.push(s.name); continue; }
100
107
  // a check that serves several job lines is shown under EACH line it serves (no new element: the same check line, repeated)
101
108
  const served = lines.filter((l) => /** @type {number[]} */ (s.fromLine).includes(l.n));
102
- for (const line of served) line.checks.push({ name: s.name, cls: s.cls, ...(s.by ? { by: s.by } : {}), ...(s.stage ? { stage: s.stage } : {}) });
103
- if (served.length === 0) loose.push({ name: s.name, cls: s.cls, ...(s.by ? { by: s.by } : {}), ...(s.stage ? { stage: s.stage } : {}) });
109
+ for (const line of served) line.checks.push({ name: s.name, cls: s.cls, ...(s.by ? { by: s.by } : {}), ...(s.stage ? { stage: s.stage } : {}), ...(s.key ? { key: s.key } : {}) });
110
+ if (served.length === 0) loose.push({ name: s.name, cls: s.cls, ...(s.by ? { by: s.by } : {}), ...(s.stage ? { stage: s.stage } : {}), ...(s.key ? { key: s.key } : {}) });
104
111
  }
105
- // an always-on guard that the drafter said covers a job line is shown under that line too ("› check · always-on: <guard>")
106
- for (const g of Array.isArray(spec?.closeDecl?.guardLines) ? spec.closeDecl.guardLines : []) {
112
+ // the write fence is a job-level `$` row of the signed list (hamr 2026-11-15): one check that serves no one line
113
+ for (const c of checksOfClose(spec?.closeDecl ?? {}).filter((x) => x.key === FENCE_KEY)) loose.push({ name: c.text, cls: null, by: 'default', key: FENCE_KEY });
114
+ // a `~` rule the write fence keeps (a repo job's list; code proved the claim at drafting) is a check of its own line, kept by the fence
115
+ for (const c of checksOfClose(spec?.closeDecl ?? {}, spec?.jobLines ?? null).filter((x) => x.fence !== undefined)) {
116
+ lines.find((l) => l.n === c.line)?.checks.push({ name: c.text, cls: null, by: 'you', key: c.key, fence: true });
117
+ }
118
+ // an always-on guard that the drafter said covers a job line is shown under that line too ("› check · always-on: <guard>"); a close with the one list says none (code cannot prove a guard keeps a rule: Not checked)
119
+ for (const g of carriesOneList(spec?.closeDecl) ? [] : Array.isArray(spec?.closeDecl?.guardLines) ? spec.closeDecl.guardLines : []) {
107
120
  if (!g || typeof g.guard !== 'string' || !Array.isArray(g.lines)) continue;
108
121
  for (const line of lines.filter((l) => g.lines.includes(l.n))) (line.always ??= []).push(g.guard);
109
122
  }
@@ -112,7 +125,7 @@ export function planFromSpec(spec, ledger = null) {
112
125
  // a refusal of ONE ~ rule (PART 1b, RF16) names the rule in the person's words, so the row reads as that rule's Not checked; a list row of another kind names its fact when it has one
113
126
  const ruleText = line && Number.isInteger(r.rule) ? lineRules(spec.jobLines.find((/** @type {any} */ l) => l?.n === r.line))[Number(r.rule) - 1] : (r.label ?? null);
114
127
  // a list row that is not a fact or a rule (a phrase, a count) is named by its words: the draft log's, else the text after the key's kind prefix
115
- const named = line && !ruleText && r.fromList && r.key ? listRowName(r.kind, r.key, ledger?.find((x) => x.key === r.key)?.words) : null;
128
+ const named = line && !ruleText && r.fromList && r.key && r.kind !== 'stage' ? listRowName(r.kind, r.key, ledger?.find((x) => x.key === r.key)?.words) : null;
116
129
  const text = ruleText ? `"${ruleText}" — ${r.reason}` : (named ? `${named} — ${r.reason}` : r.reason);
117
130
  if (line) { line.refused.push(text); if (r.by) refusedBy[text] = r.by; }
118
131
  }
@@ -149,7 +162,7 @@ export function planFromConfirm(jobLines, plan) {
149
162
  const loose = [];
150
163
  // the person's picks are drawn once, from `plan.picked` (their words, with `kept from last draft`) as `[you picked]` check rows: a close row for the same pick is not a second row
151
164
  const hasPicked = Array.isArray(plan?.picked) && plan.picked.length > 0;
152
- for (const c of items.filter((x) => !(hasPicked && /** @type {any} */ (x).by === 'you' && !(/** @type {any} */ (x).key)))) {
165
+ for (const c of items.filter((x) => !(hasPicked && /** @type {any} */ (x).by === 'you' && (/** @type {any} */ (x).pick === true || !(/** @type {any} */ (x).key))))) {
153
166
  const by = /** @type {any} */ (c).by === null ? {} : { by: /** @type {'agent'|'you'|'default'} */ (/** @type {any} */ (c).by ?? 'agent') };
154
167
  const served = lines.filter((l) => Array.isArray(c.fromLine) && c.fromLine.includes(l.n));
155
168
  const key = typeof (/** @type {any} */ (c).key) === 'string' ? { key: /** @type {any} */ (c).key } : {};
@@ -179,16 +192,36 @@ export const AUDIT_NO_RESULT = 'no result recorded';
179
192
  * (`results`: stage name to passed), never re-derived; a row no verdict was recorded for says so. A Not checked row's result is "not checked" (its reason is in its words).
180
193
  * The write fence is enforced per write by the gate, so its row reads the gate's own record of THIS run (hamr ruling A, 2026-11-13): `blocked` = the write/edit attempts the gate denied
181
194
  * (`held · N writes blocked`), or `null` when the run's gate record is missing (said in plain words, never "held").
195
+ * Each row reads ITS OWN recorded result when the close recorded one (`rowRes`, piece 4: `{results: key -> {result, why?}, unclaimed: line -> words}`), else (a close recorded before rows existed) the verdict of its stage.
196
+ * A gap no row owns is its own failed item of its line, in the gap's words.
182
197
  * @param {JobPlan} plan @param {string[]} guards @param {Map<string, boolean>|null} results @param {number|null} [blocked] @param {boolean} [closeRan] the results are a CLOSE's (the latest), so a declared stage missing from them was not reached (the close stops at its first red); else a stage no verdict was recorded for reads none
198
+ * @param {{results: Map<string, {result: string, why?: string}>, unclaimed: Map<number, string[]>}|null} [rowRes]
183
199
  * @returns {{checks: AuditRow[], notChecked: AuditRow[], always: AuditRow[]}}
184
200
  */
185
- export function auditChecksOf(plan, guards, results, blocked = null, closeRan = false) {
201
+ export function auditChecksOf(plan, guards, results, blocked = null, closeRan = false, rowRes = null) {
186
202
  /** @param {string|undefined|null} stage @returns {'passed'|'failed'|'none'|'not-reached'} */
187
203
  const verdict = (stage) => (!stage || !results ? 'none' : (!results.has(stage) ? (closeRan ? 'not-reached' : 'none') : (results.get(stage) ? 'passed' : 'failed')));
188
204
  /** @type {AuditRow[]} */
189
205
  const checks = [];
190
- for (const l of plan.lines) for (const c of l.checks) checks.push({ text: `line ${l.n} · ${c.name}`, by: c.by ?? null, result: verdict(c.stage) });
191
- for (const c of plan.loose) checks.push({ text: `other · ${c.name}`, by: c.by ?? null, result: verdict(c.stage) });
206
+ /** one row: its own recorded result when there is one, else its stage's verdict @param {{by?: any, stage?: string, key?: string, fence?: true}} c @param {string} text @returns {AuditRow} */
207
+ const rowOf = (c, text) => {
208
+ // the fence row reads the gate's own record of THIS run (never a stage verdict): held · N writes blocked, or the record is missing
209
+ if (c.key === FENCE_KEY || c.fence === true) {
210
+ const by = c.fence === true ? /** @type {'you'} */ ('you') : /** @type {'default'} */ ('default');
211
+ return blocked === null
212
+ ? { text, by, result: /** @type {'record-missing'} */ ('record-missing'), word: "the gate's record for this run is missing", key: String(c.key) }
213
+ : { text, by, result: /** @type {'held'} */ ('held'), word: `held · ${blocked} ${blocked === 1 ? 'write' : 'writes'} blocked`, key: String(c.key) };
214
+ }
215
+ const own = c.key ? rowRes?.results.get(c.key) : undefined;
216
+ if (!own) return { text, by: c.by ?? null, result: verdict(c.stage), ...(c.key ? { key: c.key } : {}) };
217
+ // `unread`: the line's file could not be read, so this row was not looked at: never passed, never failed
218
+ return { text, by: c.by ?? null, result: own.result === 'passed' ? 'passed' : own.result === 'failed' ? 'failed' : 'none', ...(own.result === 'failed' && own.why ? { why: own.why } : {}), key: String(c.key) };
219
+ };
220
+ for (const l of plan.lines) {
221
+ for (const c of l.checks) checks.push(rowOf(c, `line ${l.n} · ${c.name}`));
222
+ for (const u of rowRes?.unclaimed.get(l.n) ?? []) checks.push({ text: `line ${l.n} · ${u}`, by: null, result: 'failed' });
223
+ }
224
+ for (const c of plan.loose) checks.push(rowOf(c, `other · ${c.name}`));
192
225
  /** @type {AuditRow[]} */
193
226
  const notChecked = [];
194
227
  const by = plan.notCheckedBy ?? {};
@@ -79,7 +79,7 @@ import {
79
79
  import { thinkingJobText } from '../thinking.js';
80
80
  import { ticketFilterWords } from '../ticketfilter.js';
81
81
  import { filterUnsure } from '../ticketlabels.js';
82
- import { judgedFilesOf, lineRules, stepFileRel, proseNotCheckedItems } from '../rubricstep.js';
82
+ import { judgedFilesOf, lineRules, stepFileRel, proseNotCheckedItems, carriesOneList, checksOfClose } from '../rubricstep.js';
83
83
  import { factPartOf, factSentence, ruleWords, moneyAs } from '../facts.js';
84
84
  import { createSettingsRoutes } from './settingsroutes.js';
85
85
  import { planFromSpec, auditChecksOf } from './jobplan.js';
@@ -1240,6 +1240,31 @@ function rubricStagesOf(spec) {
1240
1240
  return stages.filter((/** @type {any} */ s) => s && s.kind === 'rubric-step' && s.params && Number.isInteger(s.params.step));
1241
1241
  }
1242
1242
 
1243
+ /**
1244
+ * The per-row results of the run's FINAL close (Addendum 2026-11-14 (c) piece 4): what its stage entries recorded in `rows` (`{key, result, why?}`) and `unclaimed` (words of a gap no row owns), keyed by
1245
+ * the signed list's row key / by job line. A close recorded before rows existed (an older run) yields empty maps: every reader then keeps the stage verdict. Read, never re-derived.
1246
+ * @param {any[]} records @param {any} spec
1247
+ * @returns {{results: Map<string, {result: string, why?: string}>, unclaimed: Map<number, string[]>}}
1248
+ */
1249
+ export function rowResultsFromRecords(records, spec) {
1250
+ /** @type {Map<string, {result: string, why?: string}>} */
1251
+ const results = new Map();
1252
+ /** @type {Map<number, string[]>} */
1253
+ const unclaimed = new Map();
1254
+ const oc = records.findLast((r) => r && (r.type === 'close-verdict' || r.type === 'outer-close') && Array.isArray(r.stages));
1255
+ if (!oc) return { results, unclaimed };
1256
+ const lineOf = new Map(rubricStagesOf(spec).map((/** @type {any} */ s) => [s.name, s.params.step]));
1257
+ for (const st of oc.stages) {
1258
+ if (!st || typeof st.name !== 'string') continue;
1259
+ for (const r of Array.isArray(st.rows) ? st.rows : []) {
1260
+ if (r && typeof r.key === 'string' && typeof r.result === 'string') results.set(r.key, { result: r.result, ...(typeof r.why === 'string' ? { why: r.why } : {}) });
1261
+ }
1262
+ const line = lineOf.get(st.name);
1263
+ if (line !== undefined && Array.isArray(st.unclaimed) && st.unclaimed.length) unclaimed.set(line, st.unclaimed.filter((/** @type {unknown} */ u) => typeof u === 'string'));
1264
+ }
1265
+ return { results, unclaimed };
1266
+ }
1267
+
1243
1268
  /** what the Result tab's open door asks, after the door's own head words */
1244
1269
  export const RESULT_DOOR_ASK = 'the checks passed; is this what you wanted?';
1245
1270
 
@@ -1533,6 +1558,31 @@ function stepChecksOf(records, spec) {
1533
1558
  };
1534
1559
  }
1535
1560
 
1561
+ /**
1562
+ * The Result tab's checks of a repo close that carries the one list (Addendum 2026-11-15 (d)): drawn from the list's rows only, by the Audit's own reader ({@link auditChecksFor}), each with its tag and its OWN result: an `!` stage row its
1563
+ * recorded verdict, a `$` guard row its guard stage, the `$` fence row and a fence-kept `~` row the gate's record of the run, a Not checked row none. The head and the counts stay the close's own. A close with no list, or a rubric close, is returned as it was.
1564
+ * @param {any} base what {@link checksOf} read @param {any} row @param {any[]} records @param {any} spec @param {{ home?: string, sessionsRoot?: string }} opts
1565
+ */
1566
+ function repoRowChecks(base, row, records, spec, opts) {
1567
+ const cd = spec?.closeDecl;
1568
+ if (!base || !carriesOneList(cd) || (Array.isArray(cd.stages) ? cd.stages : []).some((/** @type {any} */ x) => x && x.kind === 'rubric-step')) return base;
1569
+ const ac = auditChecksFor(row, records, spec, opts);
1570
+ if (!ac) return base;
1571
+ const tag = (/** @type {any} */ by) => (by === 'you' ? '~ [you] ' : by === 'agent' ? '! [agent] ' : by === 'default' ? '$ [default] ' : '');
1572
+ const grey = (/** @type {string} */ word) => ({ sign: '\u00b7', word });
1573
+ const mk = (/** @type {any} */ r) => {
1574
+ const standing = r.result === 'passed' ? { passed: true, notReached: false, status: STATUS.passed }
1575
+ : r.result === 'failed' ? { passed: false, notReached: false, status: STATUS.failed }
1576
+ : r.result === 'held' ? { passed: true, notReached: false, status: { sign: STATUS.passed.sign, word: String(r.word) } }
1577
+ : r.result === 'record-missing' ? { passed: false, notReached: true, status: grey(String(r.word)) }
1578
+ : r.result === 'not-reached' ? { passed: false, notReached: true, status: NOT_REACHED }
1579
+ : r.result === 'not-checked' ? { passed: false, notReached: true, status: grey('not checked') }
1580
+ : { passed: false, notReached: true, status: grey('no result recorded') };
1581
+ return { name: r.key ?? r.text, question: `${tag(r.by)}${r.text}`, ...standing, value: null, baseline: null, direction: null, baselineKind: null, notes: typeof r.why === 'string' && r.why ? r.why : null };
1582
+ };
1583
+ return { ...base, stages: [...ac.checks, ...ac.notChecked].map(mk) };
1584
+ }
1585
+
1536
1586
  /**
1537
1587
  * The generic Result tab's "The checks" box, from the run's FINAL close record (the last `outer-close` or fix-loop staged `close-verdict`): each stage's plain question ({@link stageQuestionText}'s one
1538
1588
  * owner, through the spec's own declaration), its pass/fail word from the status table, and the number the close read. A run the close never reached
@@ -1623,7 +1673,7 @@ function genericResultOf(runid, row, records, spec, opts) {
1623
1673
  job: { asked: jobTextFromSpec(spec) || (typeof start?.goal === 'string' ? start.goal : ''), scope: writeScope },
1624
1674
  ticket,
1625
1675
  changed: changedOf(records, writeScope),
1626
- checks: checksOf(records, spec),
1676
+ checks: repoRowChecks(checksOf(records, spec), row, records, spec, opts),
1627
1677
  work: workOf(row, records),
1628
1678
  run: {
1629
1679
  spent: spentUsd === null ? 'unknown' : `${complete ? '' : 'at least '}${panelMoney2(spentUsd)}`,
@@ -1760,8 +1810,16 @@ export function getRunResult(runid, /** @type {{ home?: string, sessionsRoot?: s
1760
1810
  const fp = factPartOf(st.params);
1761
1811
  const di = delivered.map((d, i) => ({ d, i })).filter(({ d }) => stepOfDelivered(d.path) === n).pop() ?? null;
1762
1812
  const passed = stagePassedIn(records, st.name);
1813
+ // each row of the line with its OWN mark (piece 4), from the final close's per-row record; a row the record has no result for (an older run) reads the stage's mark
1814
+ const rowRes = rowResultsFromRecords(records, spec);
1815
+ const checkRows = (plan.lines.find((l) => l.n === n)?.checks ?? []).map((c) => {
1816
+ const got = c.key ? rowRes.results.get(c.key) : undefined;
1817
+ return { ...(c.key ? { key: c.key } : {}), text: c.name, by: c.by ?? null, result: got ? (got.result === 'unread' ? 'none' : got.result) : (passed ? 'passed' : 'none'), ...(got?.why ? { why: got.why } : {}) };
1818
+ });
1763
1819
  /** @type {any} */
1764
1820
  const out = {
1821
+ checkRows,
1822
+ unclaimed: rowRes.unclaimed.get(n) ?? [],
1765
1823
  notChecked: tiedToLine(n),
1766
1824
  ...(plan.notCheckedBy ? { notCheckedBy: plan.notCheckedBy } : {}),
1767
1825
  n, text: jl && typeof jl.text === 'string' ? jl.text : '', rules: jl ? lineRules(jl) : [], kind: fp ? 'facts' : 'text', passed,
@@ -3362,8 +3420,10 @@ function stageOfCheck(c) {
3362
3420
  * @param {any} spec
3363
3421
  * @returns {string|null}
3364
3422
  */
3365
- function successFromSpec(spec) {
3423
+ export function successFromSpec(spec) {
3366
3424
  if (!spec || typeof spec !== 'object') return null;
3425
+ // a one-list job (Addendum 2026-11-14 (c) piece 3): the checks ARE its rows, in the card's own words, never the stage names
3426
+ if (carriesOneList(spec.closeDecl)) return checksOfClose(spec.closeDecl, spec.jobLines ?? null).map((c) => c.text).join(' · ');
3367
3427
  const stages = Array.isArray(spec.close) ? spec.close
3368
3428
  : (spec.closeDecl && Array.isArray(spec.closeDecl.stages) ? spec.closeDecl.stages : null);
3369
3429
  if (!stages) return null;
@@ -3393,7 +3453,7 @@ function auditChecksFor(row, records, spec, opts) {
3393
3453
  const got = checksOf(records, spec);
3394
3454
  const results = got ? new Map(got.stages.filter((/** @type {any} */ x) => !x.notReached).map((/** @type {any} */ x) => [x.name, x.passed === true])) : null;
3395
3455
  const rows = scopedAuditRows(row, records);
3396
- return auditChecksOf(plan, guards, results, rows === null ? null : writesBlocked(rows), got !== null && got.notReached !== undefined);
3456
+ return auditChecksOf(plan, guards, results, rows === null ? null : writesBlocked(rows), got !== null && got.notReached !== undefined, rowResultsFromRecords(records, spec));
3397
3457
  }
3398
3458
 
3399
3459
  /**
@@ -3412,7 +3472,7 @@ function auditChecksFor(row, records, spec, opts) {
3412
3472
  * @param {any} spec
3413
3473
  * @returns {string|null}
3414
3474
  */
3415
- function guardrailsFromSpec(spec) {
3475
+ export function guardrailsFromSpec(spec) {
3416
3476
  if (!spec || typeof spec !== 'object') return null;
3417
3477
  const writeScope = Array.isArray(spec.writeScope) && spec.writeScope.every((s) => typeof s === 'string')
3418
3478
  ? spec.writeScope : null;
@@ -3420,7 +3480,7 @@ function guardrailsFromSpec(spec) {
3420
3480
  ? `write fence — the run may only change files matching: ${writeScope.join(', ')}` : null;
3421
3481
  if (spec.closeDecl && typeof spec.closeDecl.lang === 'string' && typeof spec.verdictType === 'string') {
3422
3482
  try {
3423
- const lines = confirmProtections({ verdictType: spec.verdictType, lang: spec.closeDecl.lang, writeScope });
3483
+ const lines = confirmProtections({ verdictType: spec.verdictType, lang: spec.closeDecl.lang, writeScope, closeDecl: spec.closeDecl });
3424
3484
  if (lines.length > 0) return lines.join(' · ');
3425
3485
  } catch { /* falls through to the write-fence-only line below */ }
3426
3486
  }
package/src/planrun.js CHANGED
@@ -1773,6 +1773,8 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
1773
1773
  // arbiter-owned fact reaches a stage: through the ctx, never through the
1774
1774
  // declaration. A command close has no human stage to hand it to.
1775
1775
  humanRuling: liveRuling,
1776
+ // the signed one check list: each stage entry of the close's records carries a RESULT PER ROW (report-only; no verdict reads it)
1777
+ list: Array.isArray(job.closeDecl?.list) ? job.closeDecl.list : null,
1776
1778
  // REPORT-ONLY: what a rubric-step stage's cited checks read (bareguard `full.evidence`), recorded as `rubric-evidence` for the Result
1777
1779
  // tab's highlights. No verdict, gap, governor or money path reads it. Masked HERE with the run's one `scrub`: the `text` is a quote from
1778
1780
  // the frozen page record, and the spine is append-only. Masking moves offsets, so an entry whose text changed keeps NO spans.
@@ -73,6 +73,11 @@ export const PROMPT_REGISTERS = Object.freeze([
73
73
  // (F198 item 2), built inline inside `middle` and appended to `w.ask([...])`
74
74
  Object.freeze({ file: 'src/planrun.js', name: 'middle()\'s facts-only "The close\'s own numbers so far" block (inline template, not a const)' }),
75
75
 
76
+ // src/fencepointcall.js — the repo job's pointing call (a `~` rule the AI points at a file the write fence keeps; code proves it)
77
+ Object.freeze({ file: 'src/fencepointcall.js', name: 'FENCE_POINT_SYSTEM' }),
78
+ Object.freeze({ file: 'src/fencepointcall.js', name: 'FENCE_POINT_SCHEMA (property descriptions)' }),
79
+ Object.freeze({ file: 'src/fencepointcall.js', name: 'fencePointUserText() (inline template, not a const)' }),
80
+
76
81
  // src/checklist.js — the one check list of a rubric job: the list call's system text and schema descriptions, the drafter's list block, the code-written refusal words
77
82
  Object.freeze({ file: 'src/checklist.js', name: 'LEDGER_SYSTEM' }),
78
83
  Object.freeze({ file: 'src/checklist.js', name: 'LEDGER_SCHEMA (property descriptions)' }),