@piagent/platform 1.46.0 → 1.46.1

package/packages/piagent-core/managed/ledger.mjs

@@ -0,0 +1,187 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { briefIssues } from './workflow.mjs';
+
+// The objection ledger: what a helper holds against the main agent's work in
+// one run (one member message), and what the main agent decided about it.
+// A helper's objection to its brief, a review finding and a failed verify
+// claim are one kind of item: open until the main agent resolves it with
+// resolve_objection (accepted with what it changed, or rejected with what it
+// checked and why), and a rejection of a required item goes back to the
+// helper once; a disagreement that remains goes to the member. The run's
+// items and decisions are one session entry when the run ends.
+export const LEDGER_ENTRY = 'agent-watch-objections';
+// A brief objection that blocks file changes until it is resolved: the brief
+// rests on a premise the code contradicts, or on a reading the member's words
+// contradict, and the helper pointed at a place that exists.
+const PREMISE = new Set(['wrong_premise', 'conflicts_with_request']);
+const DECISIONS = ['accepted', 'rejected'];
+// After this many refused answers a model that cannot resolve an item goes on;
+// the run reports the item as left without a decision.
+export const LEDGER_REFUSALS = 3;
+const MAX_ITEMS = 60, READ_LIMIT = 5 * 1024 * 1024;
+
+// "file:line" in a piece of evidence; null when it names none.
+export function evidenceRef(text) {
+  const m = String(text ?? '').match(/(?:^|[\s(`'"])((?:[\w@.-]+\/)*[\w@.-]*[\w-]\.[A-Za-z0-9]+):(\d+)\b/);
+  return m ? { file: m[1], line: Number(m[2]) } : null;
+}
+// Whether the place exists in the project: 'ok', 'missing' (no such file, or
+// the file is shorter), or null when there is nothing to check or the file is
+// outside the project or too large to read.
+export function checkRef(cwd, ref) {
+  if (!cwd || !ref?.file || path.isAbsolute(ref.file) || ref.file.split(/[\\/]/).includes('..')) return null;
+  let real;
+  try { real = fs.realpathSync(path.join(cwd, ref.file)); } catch { return 'missing'; }
+  const root = fs.realpathSync(cwd);
+  if (real !== root && !real.startsWith(root + path.sep)) return null;
+  try {
+    const stat = fs.statSync(real);
+    if (!stat.isFile()) return 'missing';
+    if (!ref.line) return 'ok';
+    if (stat.size > READ_LIMIT) return null;
+    return fs.readFileSync(real, 'utf8').split('\n').length >= ref.line ? 'ok' : 'missing';
+  } catch { return null; }
+}
+
+const clip = (value, n) => typeof value === 'string' ? value.trim().slice(0, n) : '';
+export const ledgerOf = run => run?.ledger ?? [];
+const open = run => ledgerOf(run).filter(i => i.status === 'open');
+export const blockingItems = run => open(run).filter(i => i.required && i.source === 'brief');
+
+// Adds items from one helper answer. `source`: brief (an objection to the
+// brief), review (blocking and major findings) or verify (failed claims).
+export function addItems(managed, source, role, list, { required } = {}) {
+  const run = managed.run;
+  if (!run || !list?.length) return [];
+  const added = [];
+  for (const raw of list) {
+    if (run.ledger.length >= MAX_ITEMS) break;
+    const evidence = clip(raw.evidence, 500), ref = raw.file ? { file: raw.file, line: raw.line ?? null } : evidenceRef(evidence), place = checkRef(managed.cwd, ref);
+    const must = source === 'brief' ? PREMISE.has(raw.kind) && !!evidence && place !== 'missing' : source === 'review' ? raw.kind === 'blocking' : !!required;
+    const item = { id: `o${run.ledger.length + 1}`, source, role, kind: raw.kind, detail: clip(raw.detail, 500), evidence, ...(ref ? { ref } : {}), ...(place ? { place } : {}), required: must, status: 'open' };
+    run.ledger.push(item); added.push(item);
+  }
+  return added;
+}
+export const itemText = i => `${i.id} [${i.source === 'brief' ? i.kind : i.source === 'review' ? i.kind : 'failed claim'}] ${i.role}: ${i.detail}${i.evidence ? ` (evidence: ${i.evidence}${i.place === 'missing' ? '; the harness found no such place' : ''})` : ''}`;
+export const setStatus = (item, status, extra = {}) => Object.assign(item, { status, ...extra });
+export function saveLedger(managed) {
+  const items = ledgerOf(managed.run);
+  if (items.length) try { managed.session.sessionManager.appendCustomEntry(LEDGER_ENTRY, { items, at: new Date().toISOString() }); } catch { /* the report still counts them */ }
+}
+
+// resolve_objection: the main agent's decision on one item, kept with what it
+// checked. An accepted item names what changed; a rejected one says why.
+export function resolveTool(owner) {
+  return { name: 'resolve_objection', label: 'Objection',
+    description: 'Record your decision on an objection a helper raised (its id, such as o1): a brief objection, a review finding or a failed verify claim. Check it first at the place its evidence names. accepted: you agree; say what you changed (a corrected brief, the plan, the code). rejected: say what you checked (file:line, a command and its result) and why the objection does not hold; a rejected required objection goes back to the helper, and a disagreement that remains goes to the member.',
+    parameters: { type: 'object', properties: { id: { type: 'string', maxLength: 10 }, decision: { type: 'string', enum: DECISIONS }, checked: { type: 'string', minLength: 1, maxLength: 300 },
+      change: { type: 'string', maxLength: 300 }, reason: { type: 'string', maxLength: 500 } }, required: ['id', 'decision', 'checked'], additionalProperties: false },
+    execute: async (_id, args) => {
+      const item = ledgerOf(owner.run).find(i => i.id === args?.id);
+      if (!item) throw Error(`managed-objection-unknown: no objection ${String(args?.id).slice(0, 10)} in this message; the open ones are ${open(owner.run).map(i => i.id).join(', ') || 'none'}.`);
+      if (!['open', 'noted'].includes(item.status)) throw Error(`managed-objection-settled: ${item.id} is already ${item.status}.`);
+      if (!DECISIONS.includes(args.decision) || !clip(args.checked, 300)) throw Error('managed-objection-invalid: send decision accepted or rejected, and what you checked.');
+      if (args.decision === 'accepted' && !clip(args.change, 300)) throw Error('managed-objection-invalid: an accepted objection names what you changed (the brief, the plan or the code).');
+      if (args.decision === 'rejected' && !clip(args.reason, 500)) throw Error('managed-objection-invalid: a rejected objection says why it does not hold.');
+      const resolution = { decision: args.decision, checked: clip(args.checked, 300), ...(args.change ? { change: clip(args.change, 300) } : {}), ...(args.reason ? { reason: clip(args.reason, 500) } : {}) };
+      setStatus(item, args.decision, { resolution });
+      const back = args.decision === 'rejected' && item.required ? ` The ${item.role} subagent judges your reason before the turn ends.` : '';
+      return { content: [{ type: 'text', text: `Recorded: ${item.id} ${args.decision}.${back}` }], details: { id: item.id, decision: args.decision } };
+    } };
+}
+
+// Before an edit or a command that may change files: an open premise
+// objection is resolved first. `answer` names the model answer the call came
+// from, so calls sent together count once.
+export function ledgerGuard(run, answer) {
+  const items = blockingItems(run);
+  if (!items.length) return;
+  run.ledgerRefusals ??= new Set();
+  if (!run.ledgerRefusals.has(answer) && run.ledgerRefusals.size >= LEDGER_REFUSALS) { run.ledgerSkipped = true; return; }
+  run.ledgerRefusals.add(answer);
+  throw Error(`managed-objection-open: resolve ${items.map(i => i.id).join(', ')} with resolve_objection before changing files.\n${items.map(itemText).join('\n')}`);
+}
+
+// The receipt's counts (report version 3): objections to briefs, those the
+// main agent decided, the disagreements handed to the member.
+export function briefCounts(run) {
+  const briefs = ledgerOf(run).filter(i => i.source === 'brief');
+  return { objections: briefs.length, answered: briefs.filter(i => ['accepted', 'rejected', 'withdrawn'].includes(i.status)).length };
+}
+
+// A required rejection the helper has not judged yet; the harness asks it.
+export const toRejudge = run => ledgerOf(run).filter(i => i.source === 'brief' && i.required && i.status === 'rejected' && !i.rejudged);
+export function rejudgeBrief(item) {
+  return `You objected to the brief the main agent gave you:\n[${item.kind}] ${item.detail}${item.evidence ? `\nYour evidence: ${item.evidence}` : ''}\n\nThe main agent rejected the objection.\nWhat it checked: ${item.resolution.checked}\nIts reason: ${item.resolution.reason}\n\nJudge its reason against the code and the member's words. When the reason holds, end with an empty brief_issues list. When your objection still holds, repeat it in brief_issues with evidence; the member then decides.`;
+}
+
+// One step of the completion gate (true: the gate goes round again). A
+// rejected premise objection goes back to its helper, which withdraws it or
+// keeps it for the member; then the items the main agent never decided are
+// put to it once, with no new review.
+export async function settleLedger(managed, run, { note, send, signal }) {
+  const rejected = toRejudge(run)[0];
+  if (rejected) {
+    rejected.rejudged = true; let reply;
+    await note(`Harness: the ${rejected.role} subagent judges the main agent's reason for rejecting ${rejected.id}.`, { phase: 'rejudge', role: rejected.role, id: rejected.id });
+    try { reply = (await managed.delegate({ role: rejected.role, task: rejudgeBrief(rejected) }, signal, { harness: true })).content.map(p => p.text).join('\n'); }
+    catch { return true; }
+    if (!briefIssues(reply)?.length) { setStatus(rejected, 'withdrawn'); return true; }
+    setStatus(rejected, 'disputed'); run.disputes.push({ source: rejected.role, brief: true });
+    await note(`Harness: the ${rejected.role} subagent keeps its objection; the member decides.\n${itemText(rejected)}`, { phase: 'dispute', role: rejected.role, id: rejected.id });
+    return true;
+  }
+  const pending = undecided(run);
+  if (!pending.length || run.decideAsked) return false;
+  run.decideAsked = true;
+  await send(decideText(pending), { phase: 'answer', ids: pending.map(i => i.id), issues: pending.slice(0, 10).map(i => ({ kind: i.kind, detail: i.detail })) });
+  return true;
+}
+
+// What the main agent still has to decide before the turn ends: required
+// items, review findings above minor, brief objections it never answered.
+export const undecided = run => open(run).filter(i => i.required || i.source !== 'verify');
+export function decideText(items) {
+  return `Harness: ${items.length} objection(s) have no decision yet:\n${items.map(i => '- ' + itemText(i)).join('\n')}\nCheck each at the place its evidence names, then record your decision with resolve_objection: accepted with what you changed, or rejected with what you checked and why. Minor review findings need nothing; no new review follows.`;
+}
+// The final status line's words about the ledger.
+export function ledgerWords(run) {
+  const items = ledgerOf(run), count = s => items.filter(i => i.status === s).length, words = [];
+  if (!items.length && !run.minorFindings) return null;
+  for (const [status, label] of [['accepted', 'accepted'], ['rejected', 'rejected'], ['withdrawn', 'withdrawn by the helper'], ['cleared', 'cleared by a later check'], ['disputed', 'for the member'], ['open', 'left without a decision'], ['noted', 'noted']])
+    if (count(status)) words.push(`${count(status)} ${label}`);
+  if (run.minorFindings) words.push(`${run.minorFindings} minor finding(s) listed`);
+  return `objections: ${words.join(', ')}`;
+}
+
+// A review of this turn's patch replaces the findings of the one before it:
+// its blocking and major findings are the items, its minor ones only counted.
+// A finding it repeats keeps its item (and the main agent's decision); one it
+// no longer reports is cleared, or withdrawn when the agent had rejected it.
+const sameFinding = (item, f) => (item.ref?.file ?? null) === (f.file || null) && (item.ref?.line === f.line || item.detail === clip(f.issue, 500));
+export function recordFindings(managed, findings) {
+  const run = managed.run;
+  if (!run || !findings) return;
+  // A re-review after a fix read only the files changed since: an item about another file stands.
+  const focus = managed.reviewFocus?.files ? new Set(managed.reviewFocus.files) : null;
+  const kept = findings.filter(f => f.severity !== 'minor'), live = ledgerOf(run).filter(i => i.source === 'review' && ['open', 'rejected'].includes(i.status)
+    && (!focus || i.kind === 'blocking' || !i.ref?.file || focus.has(i.ref.file)));
+  for (const item of live) if (!kept.some(f => f.severity === item.kind && sameFinding(item, f))) setStatus(item, item.status === 'open' ? 'cleared' : 'withdrawn');
+  addItems(managed, 'review', 'review', kept.filter(f => !live.some(i => i.kind === f.severity && sameFinding(i, f))).map(f => ({ kind: f.severity, detail: f.issue, evidence: f.evidence, file: f.file || null, line: f.line })));
+  run.minorFindings = findings.length - kept.length;
+}
+// The files changed since the last review of this turn's patch, for a
+// re-review after a fix; null when that cannot be told.
+export async function reviewFocus(managed) {
+  const before = managed.reviewFiles, now = before ? await managed.changedFiles?.() : null;
+  if (!before || !now) return null;
+  const files = [...new Set([...before.keys(), ...now.keys()])].filter(name => before.get(name) !== now.get(name)).sort();
+  return files.length ? { files: files.slice(0, 200) } : null;
+}
+// The main agent's decisions on items of one source, for the helper that judges them again.
+export function decisionsText(run, source) {
+  const decided = ledgerOf(run).filter(i => i.source === source && i.resolution);
+  return decided.length ? `\n\nThe main agent's recorded decisions:\n${decided.map(i => `- ${i.detail}: ${i.resolution.decision}; checked: ${i.resolution.checked}${i.resolution.reason ? `; reason: ${i.resolution.reason}` : ''}${i.resolution.change ? `; changed: ${i.resolution.change}` : ''}`).join('\n')}` : '';
+}

package/packages/piagent-core/managed/objections.mjs

@@ -1,10 +1,12 @@
 import { briefIssues, currentPlan, planText, verifyVerdicts } from './workflow.mjs';
+import { addItems, itemText, ledgerOf, setStatus } from './ledger.mjs';
+export { resolveTool } from './ledger.mjs';
 
 // A helper may object to the brief it was given, with evidence. It never
-// decides and never does other work instead: the main agent decides and has
-// to answer the objection (a corrected brief, another approach, or why the
-// objection does not hold). The same helper objecting a second time in a run
-// stops the exchange, and the member decides.
+// decides and never does other work instead: the main agent decides and
+// records its decision in the ledger (ledger.mjs): accepted with what it
+// changed, or rejected with what it checked and why. The same helper
+// objecting a second time in a run stops the exchange, and the member decides.
 
 // The member's own words for a helper: the current message and, while a
 // message only continues earlier work ("tiếp tục", a short follow-up), the
@@ -33,41 +35,61 @@ export function anchorText(manager, harness) {
 }
 
 // Before a helper starts: once a helper objected twice in a run the member
-// decides, so the main agent cannot send it another brief before then. A
-// new brief to a helper that objected answers that objection.
-export function beforeDelegate(run, role, harness) {
+// decides, so the main agent cannot send it another brief before then. An
+// open premise objection of the role is resolved with resolve_objection
+// first; a new brief answers any other objection of the role. A review the
+// main agent asks for itself: none under a required review (the harness
+// reviews the final patch), else once, and again only after blocking findings.
+export function beforeDelegate(run, role, harness, { since = null, review = null, changed = false, asked = false } = {}) {
   if (!run || harness) return;
   if (run.disputes.some(d => d.source === role && d.brief)) throw Error(`managed-helper-disputed: the ${role} subagent objected to your briefs twice for this message, so the member decides. Tell them what it objects to and what you decided; do not delegate to it again before their next message.`);
-  for (const objection of run.objections) if (objection.role === role) objection.answered = true;
+  const mine = ledgerOf(run).filter(i => i.source === 'brief' && i.role === role && i.status === 'open');
+  const blocked = mine.filter(i => i.required);
+  if (blocked.length) throw Error(`managed-objection-open: the ${role} subagent objected to your brief; record your decision with resolve_objection before you brief it again.\n${blocked.map(itemText).join('\n')}`);
+  // Reviewers the member asked for (copies.mjs) run at their word.
+  if (role === 'review' && !since && changed && !asked) {
+    if (run.policy.review === 'require') throw Error('managed-review-by-harness: the harness reviews the final patch when you finish; do not ask for a review yourself. Finish the change and its checks.');
+    if (run.mainReviews > 0 && !(review?.stale && review.blocking > 0)) throw Error('managed-review-once: this change was reviewed already. Fix its blocking findings and ask again only then; fix major findings or reject them with resolve_objection; minor findings need nothing.');
+  }
+  if (role === 'review' && !since) run.mainReviews = (run.mainReviews ?? 0) + 1;
+  for (const item of mine) setStatus(item, 'accepted', { resolution: { decision: 'accepted', checked: 'sent the role a new brief', change: 'a new brief' } });
 }
 
-const issueText = (issue, i) => `${i + 1}. [${issue.kind}] ${issue.detail}${issue.evidence ? ` (evidence: ${issue.evidence})` : ''}`;
-// After a helper answered: an objection to the main agent's brief is
-// recorded, shown to the member and handed to the main agent with the answer.
-// Returns the note the main agent reads under the helper's answer ('' when
-// there is none). The harness's own briefs (its review, its re-check) are
-// fixed text: an objection to one only restates the member's request, so
-// it is not relayed.
+// After a helper answered: an objection to the main agent's brief goes into
+// the ledger, is shown to the member and handed to the main agent with the
+// answer. Returns the note the main agent reads under the helper's answer
+// ('' when there is none). The harness's own briefs (its review, its
+// re-check) are fixed text: an objection to one only restates the member's
+// request, so it is not relayed.
 export async function relayObjection(managed, role, reply, harness) {
   const run = managed.run, issues = harness ? null : briefIssues(reply);
   if (!run || !issues?.length) return '';
-  const second = run.objections.some(o => o.role === role), list = issues.map(issueText).join('\n');
-  run.objections.push({ role, issues, answered: false, disputed: second });
-  if (second) run.disputes.push({ source: role, brief: true });
+  const second = ledgerOf(run).some(i => i.source === 'brief' && i.role === role), items = addItems(managed, 'brief', role, issues), list = items.map(itemText).join('\n');
+  if (second) { run.disputes.push({ source: role, brief: true }); for (const item of items) setStatus(item, 'disputed'); }
   await managed.session.sendCustomMessage({ customType: 'agent-watch-process', display: true,
     content: second ? `Harness: the ${role} subagent objected to a brief a second time for this message; the exchange stops and the member decides.\n${list}`
       : `Harness: the ${role} subagent objected to the brief the main agent gave it:\n${list}`,
-    details: { phase: second ? 'dispute' : 'objection', role, by: 'main', issues: issues.map(({ kind, detail }) => ({ kind, detail })) } }, { triggerTurn: false });
-  return second ? `\n\n[Harness] The ${role} subagent objected to your brief again. This is its second objection for this message, so the harness ends the exchange: do not delegate to it again before the member's next message. Tell the member plainly what it objects to and what you decided, and let them decide.`
-    : `\n\n[Harness] The ${role} subagent objected to your brief (see brief_issues above). You decide, but answer the objection before you act on this answer: send it a corrected brief, change your approach, or tell the member why the objection does not hold. A second objection from it for this message goes to the member.`;
+    details: { phase: second ? 'dispute' : 'objection', role, by: 'main', issues: issues.map(({ kind, detail }) => ({ kind, detail })), ids: items.map(i => i.id) } }, { triggerTurn: false });
+  if (second) return `\n\n[Harness] The ${role} subagent objected to your brief again. This is its second objection for this message, so the harness ends the exchange: do not delegate to it again before the member's next message. Tell the member plainly what it objects to and what you decided, and let them decide.`;
+  const blocking = items.filter(i => i.required);
+  return `\n\n[Harness] The ${role} subagent objected to your brief:\n${list}\nCheck each at the place its evidence names, then record your decision with resolve_objection (accepted with what you changed, or rejected with what you checked and why).${blocking.length ? ` Until you do, file changes are refused: ${blocking.map(i => i.id).join(', ')} say${blocking.length === 1 ? 's' : ''} the brief rests on a wrong premise or conflicts with the request.` : ''} A rejected objection goes back to the helper; a second objection from it for this message goes to the member.`;
 }
 
-// Verify's verdicts, counted for the receipt. Under a required verify the
-// failed claims are the run's to settle; once the agent has been sent back
-// with them, only the harness's own re-check replaces them.
-export function recordVerdicts(run, reply, harness, details) {
-  const found = verifyVerdicts(reply);
+// Verify's verdicts, counted for the receipt; its failed claims go into the
+// ledger (required under a required verify, noted otherwise). Under a
+// required verify the failed claims are the run's to settle; once the agent
+// has been sent back with them, only the harness's own re-check replaces
+// them, and a claim it no longer fails is cleared.
+export function recordVerdicts(managed, reply, harness, details) {
+  const run = managed.run, found = verifyVerdicts(reply);
   details.verdicts = found ? Object.fromEntries(['pass', 'fail', 'unverifiable'].map(s => [s, found.filter(v => v.status === s).length])) : null;
-  if (run && found && (harness || !run.claimsAsked)) run.verifyFails = found.filter(v => v.status === 'fail');
+  if (run && found && (harness || !run.claimsAsked)) {
+    run.verifyFails = found.filter(v => v.status === 'fail');
+    const failed = new Set(run.verifyFails.map(v => v.claim)), required = run.policy.verify === 'require';
+    for (const item of ledgerOf(run)) if (item.source === 'verify' && ['open', 'rejected', 'noted'].includes(item.status) && !failed.has(item.detail)) setStatus(item, 'cleared');
+    const known = new Set(ledgerOf(run).filter(i => i.source === 'verify' && i.status !== 'cleared').map(i => i.detail));
+    const added = addItems(managed, 'verify', 'verify', run.verifyFails.filter(v => !known.has(v.claim)).map(v => ({ kind: 'fail', detail: v.claim, evidence: v.evidence })), { required });
+    if (!required) for (const item of added) setStatus(item, 'noted');
+  }
   return found ? ' · ' + Object.entries(details.verdicts).filter(([, n]) => n).map(([s, n]) => `${n} ${s}`).join(', ') : '';
 }

package/packages/piagent-core/managed/patch-snapshot.mjs

@@ -176,6 +176,15 @@ export function reviewParts(snapshot, size = REVIEW_PART_BYTES) {
   return { parts: parts.length ? parts : [{ files: [], text: `Patch snapshot ${snapshot.digest}: every changed file is too large to review.${skipped}` }], omitted };
 }
 
+// A re-review after a fix (focus: the files changed since the last review)
+// reads only the parts that hold one of them: the other parts were reviewed
+// and have not changed. Without such a part, or in one part, all of it.
+export function focusParts(review, focus) {
+  if (!focus?.files?.length || review.parts.length < 2) return review;
+  const files = new Set(focus.files), kept = review.parts.filter(part => part.files?.some(file => files.has(file)));
+  return kept.length ? { ...review, parts: kept } : review;
+}
+
 // One answer from the review of every part: each part's summary, then the
 // findings of all parts (most severe first) and their objections to the brief
 // in one JSON block. `parsed`: every part gave its JSON.

package/packages/piagent-core/managed/session.mjs

@@ -8,7 +8,7 @@ import { ensureSearchTools, trustSystemCertificates } from './toolchain.mjs';
 import { inlineExtensions, managedResourceLoader, projectInstructions } from './resource-loader.mjs';
 import { fetchPublicPage, fetchLimits } from './web-fetch.mjs'; import { guardFetch } from './fetch-guard.mjs'; import { UNTRUSTED_RULE } from './untrusted.mjs';
 import { searchForRole } from './web-search.mjs';
-import { shareGrant, releaseGrant } from './grant-share.mjs';
+import { shareGrant, releaseGrant, slotArgs } from './grant-share.mjs';
 import { managedThinkingLevels, nearestLevel } from './capabilities.mjs';
 import { nativeManagedModel, isVendor, piProvider, studioAPI, studioPath } from './native-catalog.mjs';
 import { fetchOriginTool } from './repository-operation.mjs';
@@ -24,7 +24,7 @@ import { readPatchDigest, readPatchSnapshot, readChangedFiles, readHead } from '
 import { memberTurn } from './continuation.mjs';
 import { workflowPolicy, repositoryChecks, sessionPlanTool, currentPlan, workflowPrompt, RunProcess, completionGate, pendingBaseline, pendingPaths, pendingHead, processEditTools } from './workflow.mjs';
 import { workflowContextTool, workflowContextExtension } from './workflow-context.mjs';
-import { beforeDelegate } from './objections.mjs';
+import { beforeDelegate, resolveTool } from './objections.mjs'; import { fanOut } from './copies.mjs';
 import { HELPER_CALLS, HELPER_ROLES, helperRoles, helperPrompt, webPrompt, delegateDescription, mainWebLookups, limitedWebTools } from './helper-roles.mjs'; import { delegateParameters, delegateArgs, SPEC_PROMPT } from './helper-settlement.mjs';
 import { loadAgentResources } from './agent-skills.mjs';
 import { loadPiagentThemes } from '../runtime/terminal/terminal-style.mjs';
@@ -75,8 +75,9 @@ async function patiently(ask, times) {
     catch (error) { if (attempt >= times || !BUSY.test(String(error?.message))) throw error; await sleep(1500 * attempt); }
   }
 }
-function verifyGrant(grant, manifest, role) {
-  if (!grant || !sameAuthority(grant, manifest.authority) || grant.role !== role || !Number.isSafeInteger(grant.fence) || grant.fence < 1
+function verifyGrant(grant, manifest, key) {
+  const { role, slot = 1 } = slotArgs(key); // a helper beside another of its role: role#slot (grant-share.mjs)
+  if (!grant || !sameAuthority(grant, manifest.authority) || grant.role !== role || (grant.slot ?? 1) !== slot || !Number.isSafeInteger(grant.fence) || grant.fence < 1
     || !/^as_run_[a-f0-9-]{36}_[\w-]{43}$/.test(grant.token) || !(['claude', 'codex'].includes(grant.provider) || isVendor(grant.provider))
     || !manifest.models.some(m => m.id === grant.model_id && m.owned_by === grant.provider && m.provider_model_id === grant.provider_model_id)) throw Error('managed-grant-invalid');
 }
@@ -128,7 +129,7 @@ export class ManagedSession {
     if (roles.length) customTools.push({ name: 'delegate', label: 'Subagent', description: delegateDescription(roles) + SPEC_PROMPT,
       parameters: delegateParameters(), // the brief and its structured fields (helper-settlement.mjs)
       execute: (_id, args, signal) => self.delegate(delegateArgs(self, args), signal) });
-    customTools.push(sessionPlanTool(self));
+    customTools.push(sessionPlanTool(self), ...(roles.length ? [resolveTool(self)] : [])); // the objection ledger's decisions (ledger.mjs)
     // The member decides what the request leaves open: numbered options, or their own words.
     customTools.push(workflowContextTool(() => self.session.sessionManager));
     customTools.push(askTool(self), ...memoryToolsFor(self, agentDir)); // team memory's tools, once Studio answered memory here (memory.mjs)
@@ -459,20 +460,19 @@ export class ManagedSession {
     this.review = { ...this.review, stale: true };
     this.session.sessionManager.appendCustomEntry('agent-watch-review', this.review);
     await this.session.sendCustomMessage({ customType: 'agent-watch-review-status', display: true,
-      content: 'Review is stale: code changed after review. Obtain a new review for the current patch.', details: this.review }, { triggerTurn: false });
+      content: 'Review is stale: code changed after review. Ask for another review only after fixing blocking findings; under a required review the harness reviews the final patch.', details: this.review }, { triggerTurn: false });
   }
   // `harness`: the completion gate asks, not the main agent (its brief, its turn).
-  async delegate({ role, task, title, since }, signal, { harness = false } = {}) {
+  async delegate({ role, task, title, since, ...more }, signal, { harness = false } = {}) {
     if (!this.grant || !HELPER_ROLES.includes(role) || typeof task !== 'string' || !task.trim() || task.length > 12000 || this.helpers.has(role)) throw Error('managed-helper-unavailable');
     const enabled = helperRoles(this.manifest);
     if (!enabled.includes(role)) throw Error(`managed-helper-not-configured: the company Harness has no ${role} subagent${enabled.length ? `; use ${enabled.join(', ')}` : ''}.`);
-    // Studio gives a run each helper role once. Say so at once instead of
-    // letting the main agent retry a call that cannot succeed.
     // Studio lets each helper role run HELPER_CALLS times per run (one user
-    // message). Say so at once instead of asking for a grant it refuses.
-    if ((this.helperCalls.get(role) ?? 0) >= HELPER_CALLS) throw Error(`managed-helper-limit: the ${role} subagent already ran ${HELPER_CALLS} times for this user message. Go on with what it returned, or use it again after the next user message.`);
-    beforeDelegate(this.run, role, harness);
-    const job = this.runHelper(role, task, signal, harness, title, role === 'review' && typeof since === 'string' && since.trim() ? since.trim() : null); this.helpers.set(role, job); this.publishHelpers();
+    // message), each helper the member asked for counted (copies.mjs). Say so at once.
+    const fan = fanOut(this.session?.sessionManager, role, more, harness);
+    if ((this.helperCalls.get(role) ?? 0) + (fan?.n ?? 1) > HELPER_CALLS) throw Error(`managed-helper-limit: the ${role} subagent already ran ${HELPER_CALLS} times for this user message. Go on with what it returned, or use it again after the next user message.`);
+    beforeDelegate(this.run, role, harness, { since, review: this.review, changed: (this.ownPaths?.size ?? 0) > 0, asked: !!fan });
+    const job = this.runHelper(role, task, signal, harness, title, role === 'review' && typeof since === 'string' && since.trim() ? since.trim() : null, fan); this.helpers.set(role, job); this.publishHelpers();
     // While a helper works (a verify running a long suite) the main agent is
     // quiet: a beat each minute tells the dashboard's watchdog, which stops a
     // turn after 15 minutes without an event, that the turn is working.
@@ -490,7 +490,7 @@ export class ManagedSession {
   notify(event) {
     for (const listener of [...this.listeners]) { try { listener(event); } catch { /* a listener's failure is its own */ } }
   }
-  runHelper(role, task, signal, harness, title, since = null) { return runHelper(this, role, task, signal, harness, { verifyGrant, patiently, title: typeof title === 'string' ? title : '', since }); }
+  runHelper(role, task, signal, harness, title, since = null, fan = null) { return runHelper(this, role, task, signal, harness, { verifyGrant, patiently, title: typeof title === 'string' ? title : '', since, fan }); }
   async dispose() {
     if (this.disposed) return;
     this.disposed = true;

package/packages/piagent-core/managed/toolchain.mjs

@@ -74,13 +74,17 @@ export function searchToolPath(name, userHome = os.homedir()) {
   return null;
 }
 export async function ensureSearchTools(sdkRoot, userHome = os.homedir(), timeoutMs = 60_000) {
-  const missing = ['rg', 'fd'].filter(name => !searchToolPath(name, userHome));
-  if (!missing.length) return;
   let manager;
   try { manager = await import(pathToFileURL(path.join(sdkRoot, 'dist/utils/tools-manager.js')).href); } catch { return; }
+  // The company terminal looks fd up the way Pi does (its bin folder, then a
+  // PATH of /usr/bin:/bin) and, offline, never downloads it: without fd there
+  // @ file completion shows nothing, even with fd under /opt/homebrew/bin.
+  const missing = ['rg', 'fd'].filter(name => !searchToolPath(name, userHome) || !manager.getToolPath?.(name));
+  if (!missing.length) return;
   await Promise.all(missing.map(async name => {
     try {
-      const found = await Promise.race([manager.ensureTool(name, true), new Promise(resolve => setTimeout(resolve, timeoutMs).unref())]);
+      // Pi 1.3 takes a status callback here; the former `silent` flag (true) made it throw before downloading.
+      const found = await Promise.race([manager.ensureTool(name), new Promise(resolve => setTimeout(resolve, timeoutMs).unref())]);
       if (typeof found === 'string' && path.isAbsolute(found) && executable(found)) downloaded.set(name, found);
     } catch { /* grep/find fall back to the built-in search */ }
   }));

package/packages/piagent-core/managed/workflow.mjs

@@ -6,6 +6,7 @@ import { TsDiagnostics } from './ts-diagnostics.mjs';
 import { checkpointsOf } from './checkpoints.mjs';
 import { discoverDeliveryContext } from './delivery-context.mjs';
 import { LANE_LIMITS, patchStats, changeLane, lanePolicy } from './risk-lanes.mjs';
+import { briefCounts, decisionsText, ledgerGuard, ledgerOf, ledgerWords, reviewFocus, saveLedger, setStatus, settleLedger } from './ledger.mjs';
 
 // The process layer of the company harness: a plan for multi-step work, the
 // repository's checks after a code change, an independent review of the patch.
@@ -149,8 +150,10 @@ export function workflowPrompt(policy, checks) {
     const list = checks.commands.length ? `${checks.commands.map(c => '`' + c + '`').join(', ')}${checks.source === 'detected' ? ' (detected; the repository declares none in AGENTS.md "## Checks")' : ''}` : 'none declared: choose the tests, type check or build that cover the change';
     lines.push(`- Verify: after changing code, run the repository checks that cover the change and fix failures before you finish. Repository checks: ${list}.${policy.verify === 'require' ? ' The turn does not end until a check has passed on the final code.' : ''}`);
   }
-  if (policy.review !== 'off') lines.push(policy.review === 'require' ? '- Review: the harness reviews the final patch with an independent reviewer; blocking findings come back to you to fix, or to answer when a finding is wrong: the reviewer then judges your answer, and a disagreement that remains goes to the member.'
-    : '- Review: before you finish a code change, ask the review helper (delegate role "review") to review the patch, then fix blocking findings.');
+  // What each severity asks: blocking is fixed or argued, major decided, minor only listed.
+  const severities = ' Blocking findings: fix them, or reject one with resolve_objection and the reviewer judges your reason; a disagreement that remains goes to the member. Major findings: fix them or reject them with resolve_objection; no new review follows. Minor findings are listed for the member and need nothing.';
+  if (policy.review !== 'off') lines.push(policy.review === 'require' ? `- Review: when you finish, the harness reviews the final patch with an independent reviewer, and after a fix only what you changed; do not ask for a review yourself.${severities}`
+    : `- Review: when your code change is finished, ask the review helper (delegate role "review") once; ask again only after fixing blocking findings.${severities}`);
   if (policy.lanes && (policy.verify !== 'off' || policy.review !== 'off')) {
     const L = LANE_LIMITS;
     lines.push(`- Size: the process follows the size of your change. A small change (at most ${L.tinyFiles} files and ${L.tinyLines} changed lines, no migration, auth, security, CI, dependency or AGENTS.md file) ends after its checks, without a review: do not ask for one. A risky change (a complex request, one of those files, more than ${L.riskyFiles} files or ${L.riskyLines} lines) must pass the checks${policy.review !== 'off' ? ' and the harness review' : ''} even where they are only suggested.`);
@@ -242,11 +245,12 @@ export class RunProcess {
     Object.assign(this, { policy, request: String(request ?? ''), complex, checks, startDigest: null, mutations: 0, lastCheck: null, checksRun: 0, checksFailed: 0,
       reviews: 0, blocking: 0, blockingOpen: 0, fixLoops: 0, planUpdated: false, planRefusals: new Set(), planSkipped: false, unplannedChange: false,
       unknownTools: 0, changed: false, verified: false, docsOnly: false, approvalDeclined: false, reviewed: false, reviewUnavailable: false, outcome: null, legacyOutcome: null,
-      // Helper objections to a brief, disagreements handed to the member, the
-      // claims verify marked failed, and where the harness last sent the
-      // agent back (to read its answer and see whether the code moved).
-      objections: [], disputes: [], verifyFails: [], claimsAsked: false, claimsAt: null, claimsRechecked: false, claimsDone: false,
-      sentAt: null, sentDigest: null, rejudged: false, reviewSettled: false, objectionsAsked: false,
+      // The objection ledger (ledger.mjs), disagreements handed to the
+      // member, the claims verify marked failed, the reviews the main agent
+      // asked for, and where the harness last sent the agent back (to read
+      // its answer and see whether the code moved).
+      ledger: [], disputes: [], verifyFails: [], claimsAsked: false, claimsAt: null, claimsRechecked: false, claimsDone: false, mainReviews: 0, minorFindings: 0,
+      sentAt: null, sentDigest: null, rejudged: false, reviewSettled: false, decideAsked: false,
       // The patch's risk lane (workflow.lanes) and the main agent's own web lookups.
       lane: null, laneStats: null, laneDigest: null, webLookups: 0 });
   }
@@ -295,7 +299,7 @@ export class RunProcess {
       verified: this.verified, reviews: count(this.reviews), reviewed: this.reviewed, blocking: count(this.blocking), blocking_open: Math.min(this.blockingOpen, this.blocking, 1000),
       fix_loops: this.fixLoops, outcome: (version === 3 ? this.outcome : this.legacyOutcome) ?? fallback,
       ...(version >= 2 ? { plan_skipped: this.planSkipped, unknown_tools: count(this.unknownTools) } : {}),
-      ...(version === 3 ? { objections: count(this.objections.length), objections_answered: count(this.objections.filter(o => o.answered && !o.disputed).length), disputes: count(this.disputes.length) } : {}) };
+      ...(version === 3 ? { objections: count(briefCounts(this).objections), objections_answered: count(briefCounts(this).answered), disputes: count(this.disputes.length) } : {}) };
   }
 }
 
@@ -355,15 +359,18 @@ export async function completionGate(managed, run, signal) {
       }
       if (policy.review === 'require' && !fresh && !run.reviewSettled) {
         // After a round of findings the reviewer also reads the agent's answer to them.
-        const answer = run.sentAt !== null ? answerSince(run.sentAt) : '';
-        const brief = `Review the current patch against the member's request.\n\nChecks: ${run.verified ? 'a repository check passed on this code' : 'no check has passed on this code'}.${answer ? `\n\nThe main agent's answer to your previous blocking findings (the code changed after it):\n${answer}` : ''}`;
+        const answer = run.sentAt !== null ? answerSince(run.sentAt) + decisionsText(run, 'review') : '';
+        // After a fix the reviewer checks its blocking findings and the files changed since.
+        const focus = run.sentAt !== null ? await reviewFocus(managed) : null, previous = (review?.findings ?? []).filter(f => f.severity === 'blocking').map((f, i) => `${i + 1}. ${findingText(f)}`).join('\n');
+        const brief = `Review the current patch against the member's request.\n\nChecks: ${run.verified ? 'a repository check passed on this code' : 'no check has passed on this code'}.${answer ? `\n\nThe main agent's answer to your previous blocking findings (the code changed after it):\n${answer}` : ''}${focus ? `\n\nSince your last review only these files changed: ${focus.files.join(', ')}. Judge whether each previous blocking finding is fixed (repeat it when it is not) and review the changes in these files; the rest of the patch was reviewed and has not changed.${previous ? `\nYour previous blocking findings:\n${previous}` : ''}` : ''}`;
+        managed.reviewFocus = focus;
         try { await managed.delegate({ role: 'review', task: brief }, signal, { harness: true }); }
         catch (error) {
           run.reviewUnavailable = !stopped(); run.reviewUnavailableReason = reviewUnavailableReason(error?.message); interrupted = stopped();
           // Why the review could not run, as a code only (the report says "failed").
           if (run.reviewUnavailable) try { session.sessionManager.appendCustomEntry('agent-watch-failure-detail', { role: 'review', code: failureCode(error?.message) }); } catch { /* the report still says it */ }
           break;
-        }
+        } finally { managed.reviewFocus = null; }
         continue;
       }
       if (policy.review === 'require' && fresh && (review.blocking ?? 0) > 0 && !run.reviewSettled) {
@@ -373,7 +380,7 @@ export async function completionGate(managed, run, signal) {
           // reviewer reads that answer once and judges its findings again.
           run.rejudged = true;
           await note('Harness: the main agent answered the review instead of changing the code; the reviewer judges its answer.', { phase: 'rejudge', role: 'review' });
-          const brief = `Judge your previous blocking findings on this patch again. The main agent answered them without changing the code:\n${answerSince(run.sentAt) || '(no answer)'}\n\nYour previous blocking findings:\n${list}\n\nKeep a finding as blocking when the answer does not hold against the code; leave it out when the answer is right.`;
+          const brief = `Judge your previous blocking findings on this patch again. The main agent answered them without changing the code:\n${answerSince(run.sentAt) || '(no answer)'}${decisionsText(run, 'review')}\n\nYour previous blocking findings:\n${list}\n\nKeep a finding as blocking when the answer does not hold against the code; leave it out when the answer is right.`;
           try { await managed.delegate({ role: 'review', task: brief }, signal, { harness: true }); }
           catch { if (stopped()) { interrupted = true; break; } run.reviewSettled = true; }
           continue;
@@ -381,11 +388,12 @@ export async function completionGate(managed, run, signal) {
         if (run.sentDigest === digest) {
           // It heard the answer and kept its findings: the member decides.
           run.reviewSettled = true; run.disputes.push({ source: 'review' });
+          for (const item of ledgerOf(run)) if (item.source === 'review' && item.kind === 'blocking' && ['open', 'rejected'].includes(item.status)) setStatus(item, 'disputed');
           await note(`Harness: the main agent and the review subagent still disagree after two rounds; the member decides.\n${list}`, { phase: 'dispute', role: 'review', findings: blocking.slice(0, 10) });
         } else if (run.fixLoops >= policy.maxFixLoops) run.reviewSettled = true;
         else {
           run.fixLoops += 1; run.sentDigest = digest; run.sentAt = session.messages.length;
-          await send(`Harness review of the current patch found ${blocking.length} blocking issue(s):\n${list}\nFix them, or explain why an issue is not real: an answer without a code change goes back to the reviewer, who judges it. The patch is reviewed again after your change.`,
+          await send(`Harness review of the current patch found ${blocking.length} blocking issue(s):\n${list}\nFix them, or reject one with resolve_objection (what you checked and why): a rejection without a code change goes back to the reviewer, who judges it. After your fix the reviewer checks these findings and the files you changed, not the whole patch again.`,
             { phase: 'review', loop: run.fixLoops, maxLoops: policy.maxFixLoops, findings: blocking.slice(0, 10) });
           continue;
         }
@@ -398,30 +406,25 @@ export async function completionGate(managed, run, signal) {
       const fails = run.verifyFails, list = fails.map((v, i) => `${i + 1}. ${v.claim}${v.evidence ? `\n   Evidence: ${v.evidence}` : ''}`).join('\n'), claims = fails.slice(0, 10).map(v => ({ claim: v.claim }));
       if (!run.claimsAsked) {
         run.claimsAsked = true; run.claimsAt = session.messages.length;
-        await send(`Harness: the verify subagent marked ${fails.length} claim(s) as failed:\n${list}\nFix the cause, or explain why a verdict is wrong. The verify subagent then checks these claims again with your answer.`, { phase: 'claims', claims });
+        await send(`Harness: the verify subagent marked ${fails.length} claim(s) as failed:\n${list}\nFix the cause, or reject a verdict with resolve_objection (what you checked and why). The verify subagent then checks these claims again with your answer.`, { phase: 'claims', claims });
         continue;
       }
       if (!run.claimsRechecked) {
         run.claimsRechecked = true;
         await note("Harness: the verify subagent checks the failed claims again with the main agent's answer.", { phase: 'rejudge', role: 'verify' });
-        try { await managed.delegate({ role: 'verify', task: `Check these claims again on the current code; they were marked failed before:\n${list}\n\nThe main agent's answer:\n${answerSince(run.claimsAt) || '(no answer)'}\n\nA claim passes only on evidence you see yourself. It stays failed when it does not hold and the result the member asked for depends on it. When the answer shows the claim is not part of what the member asked and the result does not depend on it, mark it unverifiable and say why.` }, signal, { harness: true }); }
+        try { await managed.delegate({ role: 'verify', task: `Check these claims again on the current code; they were marked failed before:\n${list}\n\nThe main agent's answer:\n${answerSince(run.claimsAt) || '(no answer)'}${decisionsText(run, 'verify')}\n\nA claim passes only on evidence you see yourself. It stays failed when it does not hold and the result the member asked for depends on it. When the answer shows the claim is not part of what the member asked and the result does not depend on it, mark it unverifiable and say why.` }, signal, { harness: true }); }
         catch { if (stopped()) { interrupted = run.changed; break; } }
         continue;
       }
       run.claimsDone = true; run.disputes.push({ source: 'verify' });
+      for (const item of ledgerOf(run)) if (item.source === 'verify' && ['open', 'accepted', 'rejected'].includes(item.status)) setStatus(item, 'disputed');
       await note(`Harness: the main agent and the verify subagent still disagree after two rounds; the member decides.\n${list}`, { phase: 'dispute', role: 'verify', claims });
     }
     // Plan "require": a checklist left with open steps is the next round's
     // (continuation.mjs), after this run's checks and review.
-    // An objection no corrected brief followed is answered to the member, once.
-    const open = run.objections.filter(o => !o.answered && !o.disputed);
-    if (open.length && !run.objectionsAsked) {
-      run.objectionsAsked = true;
-      await send(`Harness: ${open.length} objection(s) to a brief got no corrected brief:\n${open.map(o => `- ${o.role} subagent: ${o.issues.map(i => `[${i.kind}] ${i.detail}`).join('; ')}`).join('\n')}\nIn your answer to the member, say in one or two sentences what you decided about ${open.length === 1 ? 'it' : 'each'} and why.`,
-        { phase: 'answer', role: open[0].role, issues: open.flatMap(o => o.issues).slice(0, 10) });
-      for (const o of open) o.answered = true;
-      continue;
-    }
+    // A rejected premise objection goes back to its helper; then what the
+    // main agent never decided is asked once (ledger.mjs).
+    if (await settleLedger(managed, run, { note, send, signal })) continue;
     break;
   }
   // However the code was changed, a complex task under plan "require" that
@@ -434,14 +437,15 @@ export async function completionGate(managed, run, signal) {
   session.sessionManager.appendCustomEntry(BASELINE_ENTRY, { digest: settled ? digest : run.startDigest, settled, outcome: run.outcome, ...(managed.base ? { head: managed.base } : {}),
     ...(settled ? {} : { paths: [...(managed.ownPaths ?? [])].slice(0, 2000) }) });
   if (run.checkpoint) await checkpointsOf(managed).finish(run);
-  if (!run.changed && !run.disputes.length) return;
+  saveLedger(managed);
+  if (!run.changed && !run.disputes.length && !ledgerOf(run).length) return;
   const finalPlan = currentPlan(session.sessionManager), planOpen = run.planUpdated ? finalPlan?.plan?.filter(p => p.status === 'pending' || p.status === 'in_progress').length ?? 0 : 0;
   const status = { verified: run.verified, reviewed: run.reviewed, blockingOpen: run.blockingOpen, checks: run.checksRun, fixLoops: run.fixLoops,
     ...(planOpen ? { planOpen } : {}), ...(run.planSkipped ? { planSkipped: true } : {}), ...(run.disputes.length ? { disputes: run.disputes.length } : {}), ...(run.changed ? {} : { unchanged: true }) };
   const words = [...(run.changed ? [run.verified ? 'a check passed on the final code' : policy.verify === 'off' ? null : run.docsOnly ? 'only documentation changed: no check needed' : 'no check passed on the final code',
     run.reviewed ? (run.blockingOpen ? `review: ${run.blockingOpen} blocking issue(s) still open` : 'review: no blocking issue') : policy.review === 'off' ? null : run.reviewUnavailable ? `review could not run (${run.reviewUnavailableReason})` : 'not reviewed',
     run.planSkipped ? 'code was changed before the required plan existed' : null, planOpen ? `plan: ${planOpen} step(s) not completed` : null] : []),
-    run.disputes.length ? `${run.disputes.length} disagreement(s) between the main agent and a subagent go to the member` : null].filter(Boolean);
+    run.disputes.length ? `${run.disputes.length} disagreement(s) between the main agent and a subagent go to the member` : null, ledgerWords(run)].filter(Boolean);
   await session.sendCustomMessage({ customType: 'agent-watch-process', content: `Process status for this turn: ${run.changed ? 'code changed' : 'no code changed'}; ${words.join('; ') || 'no process step configured'}.`, display: true,
     details: { phase: 'final', outcome: run.outcome, ...status, ...(run.reviewUnavailable ? { reviewUnavailable: run.reviewUnavailableReason } : {}), policy: { verify: policy.verify, review: policy.review },
       ...(configured.lanes && run.lane ? { lane: run.lane, ...(run.laneStats ? { size: run.laneStats } : {}) } : {}) } }, { triggerTurn: false });
@@ -457,6 +461,8 @@ export function processEditTools(session, tools) {
     return { ...tool, execute: async (...args) => {
       const plan = currentPlan(session.session.sessionManager);
       session.run?.beforeEdit(tool.name, plan, session.mainAnswers);
+      // An open premise objection is resolved before files change (ledger.mjs).
+      if (tool.name !== 'bash' || !isReadOnlyCommand(args[1]?.command)) ledgerGuard(session.run, session.mainAnswers);
       // While a required plan is missing, a command that changes files
       // counts as an edit: the code is compared after each command.
       const watch = tool.name === 'bash' && !!session.run?.planMissing(plan) && !session.run.unplannedChange && session.run.startDigest !== null;

package/packages/piagent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piagent/core",
-  "version": "1.46.0",
+  "version": "1.46.1",
   "type": "module",
   "private": true,
   "license": "MIT",