@piagent/platform 1.51.2 → 1.52.0

package/packages/piagent-core/managed/language-environment.mjs

@@ -121,10 +121,14 @@ function linkGradleDistributions(source, target) {
   }
 }
 
+// The per-project package cache a sandboxed command may write.
+export function cacheDirectory(userHome, repositoryTop) {
+  const root = process.platform === 'linux' ? path.join(process.env.XDG_CACHE_HOME || path.join(userHome, '.cache'), 'piagent/sandbox') : path.join(userHome, 'Library/Caches/Piagent/sandbox');
+  return path.join(root, createHash('sha256').update(repositoryTop).digest('hex').slice(0, 24));
+}
 export function languageEnvironment({ userHome, repositoryTop, home }) {
   const linux = process.platform === 'linux';
-  const root = linux ? path.join(process.env.XDG_CACHE_HOME || path.join(userHome, '.cache'), 'piagent/sandbox') : path.join(userHome, 'Library/Caches/Piagent/sandbox');
-  const cache = path.join(root, createHash('sha256').update(repositoryTop).digest('hex').slice(0, 24));
+  const cache = cacheDirectory(userHome, repositoryTop), root = path.dirname(cache);
   fs.mkdirSync(cache, { recursive: true, mode: 0o700 });
   fs.chmodSync(cache, 0o700);
   const now = new Date(); try { fs.utimesSync(cache, now, now); } catch { /* best effort */ }

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

@@ -1,11 +1,12 @@
+import { callName } from './role-names.mjs';
 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
+// A helper's objection to its brief and a review finding 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
@@ -50,7 +51,7 @@ 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).
+// brief), review (blocking and major findings) 
 export function addItems(managed, source, role, list, { required } = {}) {
   const run = managed.run;
   if (!run || !list?.length) return [];
@@ -64,7 +65,7 @@ export function addItems(managed, source, role, list, { required } = {}) {
   }
   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 itemText = i => `${i.id} [${i.source === 'brief' ? i.kind : i.source === 'review' ? i.kind : 'failed claim'}] ${callName(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);
@@ -75,7 +76,7 @@ export function saveLedger(managed) {
 // 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.',
+    description: 'Record your decision on an objection a helper raised (its id, such as o1): a brief objection or a review finding. 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) => {
@@ -87,7 +88,7 @@ export function resolveTool(owner) {
       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.` : '';
+      const back = args.decision === 'rejected' && item.required ? ` The ${callName(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 } };
     } };
 }
@@ -125,12 +126,12 @@ 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'); }
+    await note(`Harness: the ${callName(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: callName(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 });
+    await note(`Harness: the ${callName(rejected.role)} subagent keeps its objection; the member decides.\n${itemText(rejected)}`, { phase: 'dispute', role: rejected.role, id: rejected.id });
     return true;
   }
   const asked = run.decidedAsked ??= new Set(), pending = undecided(run).filter(item => !asked.has(item.id));
@@ -142,7 +143,7 @@ export async function settleLedger(managed, run, { note, send, signal }) {
 
 // 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 const undecided = run => open(run);
 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.`;
 }

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

@@ -1,4 +1,5 @@
-import { briefIssues, currentPlan, planText, verifyVerdicts } from './workflow.mjs';
+import { callName } from './helper-roles.mjs';
+import { briefIssues, currentPlan, planText } from './workflow.mjs';
 import { addItems, itemText, ledgerOf, setStatus } from './ledger.mjs';
 export { resolveTool } from './ledger.mjs';
 
@@ -42,10 +43,10 @@ export function anchorText(manager, 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.`);
+  if (run.disputes.some(d => d.source === role && d.brief)) throw Error(`managed-helper-disputed: the ${callName(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.`);
   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')}`);
+  if (blocked.length) throw Error(`managed-objection-open: the ${callName(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.');
@@ -67,29 +68,11 @@ export async function relayObjection(managed, role, reply, harness) {
   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}`,
+    content: second ? `Harness: the ${callName(role)} subagent objected to a brief a second time for this message; the exchange stops and the member decides.\n${list}`
+      : `Harness: the ${callName(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 })), 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.`;
+  if (second) return `\n\n[Harness] The ${callName(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.`;
+  return `\n\n[Harness] The ${callName(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; 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');
-    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/role-names.mjs

@@ -0,0 +1,6 @@
+// A helper's working name (what the main agent calls it) and its Harness role
+// (Studio's grant). No imports: ledger.mjs and copies.mjs need these names
+// without loading helper-roles.mjs, which imports workflow.mjs (a cycle).
+export const ROLE_NAMES = Object.freeze({ explore: 'scout', scout: 'research', advisor: 'advisor', general: 'general', review: 'review' });
+export const HELPER_ROLES = Object.freeze(Object.values(ROLE_NAMES));
+export const callName = role => Object.keys(ROLE_NAMES).find(name => ROLE_NAMES[name] === role) ?? role;

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

@@ -14,18 +14,15 @@ import { nativeManagedModel, isVendor, piProvider, studioAPI, studioPath } from
 import { fetchOriginTool } from './repository-operation.mjs';
 import { describeFailure, failureCode, failureText } from '../runtime/managed-failure.mjs';
 import { enableCompanyTurnRetry, wrapRoleStreams, conversationSession } from './request-stream.mjs'; import { StudioLink, closeRun } from './studio-link.mjs';
-import { trackToolFailures } from './tool-failures.mjs';
-import { fastServed, fastSetter, fastState, recordFast, restoreFast } from './fast-mode.mjs';
-import { runHelper } from './helper-run.mjs';
-import { askTool } from './member-questions.mjs';
-import { setTimeout as sleep } from 'node:timers/promises';
+import { trackToolFailures } from './tool-failures.mjs'; import { fastServed, fastSetter, fastState, recordFast, restoreFast } from './fast-mode.mjs';
+import { runHelper } from './helper-run.mjs'; import { sweepGeneral } from './general-clone.mjs'; import { askTool } from './member-questions.mjs';
 import { stageCompaction, compactEarly, backOffFailedCompaction, trackCompaction, boundRequestImages } from './compaction.mjs';
 import { readPatchDigest, readPatchSnapshot, readChangedFiles, readHead, readRepositoryHeads } from './patch-snapshot.mjs';
-import { memberTurn } from './continuation.mjs';
+import { memberTurn } from './continuation.mjs'; import { setTimeout as sleep } from 'node:timers/promises';
 import { workflowPolicy, repositoryChecks, sessionPlanTool, currentPlan, workflowPrompt, RunProcess, completionGate, pendingBaseline, pendingPaths, pendingHead, processEditTools } from './workflow.mjs';
 import { workflowContextTool, workflowContextExtension } from './workflow-context.mjs';
 import { beforeDelegate, resolveTool } from './objections.mjs'; import { fanOut, withDroppedNote } from './copies.mjs'; import { withMemberMcp } from './member-mcp.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 { HELPER_CALLS, HELPER_ROLES, ROLE_NAMES, callName, 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';
 import { alwaysBypass, restorePermission, recordBypass, permissionSetter } from './permission.mjs';
@@ -463,19 +460,21 @@ export class ManagedSession {
       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, ...more }, signal, { harness = false } = {}) {
+  async delegate({ role: name, task, title, since, ...more }, signal, { harness = false } = {}) {
+    const role = ROLE_NAMES[name]; // the helper's working name -> its Harness role
     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(', ')}` : ''}.`);
+    if (!enabled.includes(role)) throw Error(`managed-helper-not-configured: the company Harness has no ${name} subagent${enabled.length ? `; use ${enabled.map(callName).join(', ')}` : ''}.`);
+    if (role === 'general' && (more.copies || more.split)) throw Error('managed-general-single: the general helper runs one at a time, each in its own clone; call it again for the next piece of work after merging the first.');
+    if (role === 'general') this.orphans = sweepGeneral(this);
     // Studio lets each helper role run HELPER_CALLS times per run (one user
     // message), each helper the member asked for counted (copies.mjs). Say so at once.
     const asked = fanOut(this.session?.sessionManager, role, more, harness), fan = asked?.dropped ? null : asked;
-    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.`);
+    if ((this.helperCalls.get(role) ?? 0) + (fan?.n ?? 1) > HELPER_CALLS) throw Error(`managed-helper-limit: the ${name} 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.
+    // While a helper works (a general helper running a long suite) the main agent is quiet: a beat each
+    // minute tells the dashboard's watchdog (it stops a turn after 15 silent minutes) that the turn is working.
     const beat = setInterval(() => this.notify({ type: 'managed_helper_progress', role }), this.helperBeatMs ?? HELPER_BEAT_MS); beat.unref?.();
     try { return withDroppedNote(await job, role, asked); } finally { clearInterval(beat); this.helpers.delete(role); this.publishHelpers(); }
   }
@@ -495,6 +494,7 @@ export class ManagedSession {
     if (this.disposed) return;
     this.disposed = true;
     await this.session?.abort(); await Promise.allSettled([...this.helpers.values()]);
+    for (const root of this.liveClones ?? []) fs.rmSync(root, { recursive: true, force: true });
     this.session?.dispose(); await this.boundary?.dispose(); await this.broker.dispose();
   }
 }

package/packages/piagent-core/managed/tool-boundary.mjs

@@ -4,9 +4,7 @@ import { BoundaryTerminals } from './terminal-boundary.mjs';
 import { ToolFreshness } from './tool-freshness.mjs';
 import { BoundaryQueue } from './boundary-queue.mjs';
 import { workspaceWorkerPins, verifyWorkspaceWorker } from './workspace-worker-pins.mjs'; import { snapshotRuntime } from './runtime-snapshot.mjs';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
+import fs from 'node:fs'; import os from 'node:os'; import path from 'node:path';
 import { execFileSync, spawn } from 'node:child_process';
 import net from 'node:net';
 import { StringDecoder } from 'node:string_decoder';
@@ -208,7 +206,7 @@ export class ManagedToolBoundary {
   // readOnly: the project cannot be written. commands: bash is offered all
   // the same (a helper that runs checks); it writes only to its temporary
   // directory, and has no network.
-  constructor({ cwd, sdkRoot, protectedRoots = [], readOnly = false, commands = false, node = process.execPath, identity, userHome: home, searchTools = true, skills: skillFolders = [], proxyPorts }) {
+  constructor({ cwd, sdkRoot, protectedRoots = [], readOnly = false, commands = false, node = process.execPath, identity, userHome: home, searchTools = true, skills: skillFolders = [], readRoots = [], proxyPorts }) {
     // macOS: Seatbelt. Linux, and Windows through WSL2: bubblewrap (linux-sandbox.mjs).
     this.linux = process.platform === 'linux';
     if (process.platform !== 'darwin' && !(this.linux && BWRAP)) throw new Error('managed-sandbox-unavailable');
@@ -249,6 +247,8 @@ export class ManagedToolBoundary {
     const skills = [...new Set(skillFolders.flatMap(dir => { try { return [fs.realpathSync(dir)]; } catch { return []; } }))]
       .filter(dir => dir !== '/' && !/[\x00-\x1f\x7f]/.test(dir) && !narrowed.some(root => inside(root, dir)) && !inside(userHome, dir)
         && (!inside(dir, userHome) || agentFolders.some(root => inside(dir, root)) || !path.relative(userHome, dir).startsWith('.')));
+    // readRoots: folders the runtime opens for reading only (the general helper's borrowed git objects).
+    skills.push(...readRoots.map(dir => fs.realpathSync(dir)).filter(dir => dir !== '/' && !narrowed.some(root => inside(root, dir))));
     this.userHome = userHome;
     // Only for commands the user approved (run_with_network); credentials stay
     // denied, and so do reference folders: what a command with network can

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

@@ -119,22 +119,6 @@ export function reviewFindings(text) {
   }
   return null;
 }
-// The verify helper re-checks a result on its own: claims against the code and
-// primary sources, the repository's checks on the current code.
-export const VERIFY_PROMPT = `You verify a result for the company coding assistant, independently of whoever produced it. For each claim or requirement in the brief: read the code it is about, run the repository checks that cover it with bash, and confirm external facts against primary sources (official documentation, the project's own repository) with web_search and web_fetch. Commands run offline and the project is read-only for them: a check that must write into the project or reach the network fails for that reason. Report such a claim as unverifiable and say why; do not work around the sandbox. Never mark a claim pass without evidence you saw. ${BRIEF_CHECK} End your answer with one JSON object in a \`\`\`json block: {"verdicts":[{"claim":"what was checked","status":"pass|fail|unverifiable","evidence":"file:line, the command and its result, or the source URL"}],${BRIEF_ISSUES_JSON},"summary":"one sentence"}. Use an empty brief_issues list when the brief is sound. You cannot change files or delegate.`;
-// The verifier's verdicts from its answer; null when it gave no valid JSON.
-export function verifyVerdicts(text) {
-  const blocks = [...String(text).matchAll(/```json\s*([\s\S]*?)```/g)].map(m => m[1]);
-  for (const raw of blocks.reverse()) {
-    try {
-      const value = JSON.parse(raw);
-      if (!Array.isArray(value?.verdicts)) continue;
-      return value.verdicts.filter(v => ['pass', 'fail', 'unverifiable'].includes(v?.status) && typeof v.claim === 'string' && v.claim.trim()).slice(0, 40)
-        .map(v => ({ status: v.status, claim: clip(v.claim, 500), evidence: clip(v.evidence, 500) }));
-    } catch { /* not this block */ }
-  }
-  return null;
-}
 const where = f => f.file ? ` ${f.file}${f.line ? ':' + f.line : ''}` : '';
 export const findingText = f => `[${f.severity}]${where(f)} — ${f.issue}${f.evidence ? `\n   Evidence: ${f.evidence}` : ''}`;
 
@@ -170,10 +154,10 @@ export class RunProcess {
       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,
       // The objection ledger (ledger.mjs), disagreements handed to the
-      // member, the claims verify marked failed, the reviews the main agent
+      // member, 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,
+      ledger: [], disputes: [], mainReviews: 0, minorFindings: 0,
       sentAt: null, sentDigest: null, rejudged: false, reviewSettled: false,
       // How much of the suite the member wants run (check-questions.mjs).
       scopeChoice: null, scopeWords: null, fullAsked: asksFullChecks(request), pushAllowedOn: undefined,
@@ -356,27 +340,6 @@ export async function completionGate(managed, run, signal) {
         }
       }
     }
-    // Claims the verify subagent marked failed, under a required verify: back
-    // to the agent once, then checked again with its answer; still failing,
-    // the member decides.
-    if (policy.verify === 'require' && run.verifyFails.length && !run.claimsDone) {
-      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 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)'}${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.
     // A rejected premise objection goes back to its helper; then what the

package/packages/piagent-core/package.json

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

package/packages/piagent-core/runtime/managed-failure.d.mts

@@ -1,4 +1,4 @@
-export type ManagedFailure = { role: "main" | "scout" | "research" | "verify" | "review"; code: string; kind: string; requestId: string | null; local: boolean };
+export type ManagedFailure = { role: "main" | "scout" | "research" | "advisor" | "general" | "review"; code: string; kind: string; requestId: string | null; local: boolean };
 export function failureKind(code: string): string;
 export function failureIsLocal(code: string): boolean;
 export function failureCode(raw: unknown): string;

package/packages/piagent-core/runtime/managed-failure.mjs

@@ -113,7 +113,7 @@ const CODES = {
   // Studio is stopped or restarting behind it, or the way to it failed.
   'studio-gateway-unavailable': ['unreachable', "Studio's gateway answered that Studio is not reachable"],
 };
-const ROLES = { main: 'main agent', scout: 'scout subagent', research: 'research subagent', verify: 'verify subagent', review: 'review subagent' };
+const ROLES = { main: 'main agent', scout: 'scout subagent', research: 'research subagent', advisor: 'advisor subagent', general: 'general subagent', review: 'review subagent' };
 const REQUEST = /\b([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\b/;
 const PROVIDER_SERVER_ERROR = /^(?:Error Code )?(?:server_error|api_error|internal_error|internal_server_error|overloaded_error|undefined):|An error occurred while processing your request|"type"\s*:\s*"(?:api_error|overloaded_error)"|\bOverloaded\b/i;
 const NETWORK = /fetch failed|econnrefused|econnreset|enotfound|ehostunreach|etimedout|socket hang up|network|connection error|terminated|timed? ?out|aborted due to timeout/i;
@@ -203,8 +203,8 @@ export function parseFailure(raw) {
   const text = String(raw ?? '');
   if (!text.trim()) return null;
   const code = failureCode(text);
-  const role = /^Agent Watch (main agent|(?:scout|research|verify|review) subagent): /.exec(text)?.[1]?.split(' ')[0]
-    ?? /(scout|research|verify|review) subagent/.exec(text)?.[1] ?? 'main';
+  const role = /^Agent Watch (main agent|(?:scout|research|advisor|general|review) subagent): /.exec(text)?.[1]?.split(' ')[0]
+    ?? /(scout|research|advisor|general|review) subagent/.exec(text)?.[1] ?? 'main';
   const request = failureIsLocal(code) ? null : REQUEST.exec(text)?.[1] ?? null;
   return { role, code, kind: failureKind(code), requestId: request, local: failureIsLocal(code) };
 }