@piagent/platform 1.44.1 → 1.44.2

package/packages/piagent-core/managed/helper-roles.mjs

@@ -12,12 +12,30 @@ export const HELPER_ROLES = Object.freeze(['scout', 'research', 'verify', 'revie
 export const helperRoles = manifest => HELPER_ROLES.filter(role => manifest?.harness?.configuration?.[role]);
 const WIDE_READING = 'when understanding the task needs more reading than a few batches of files, such as a flow across many modules of an unfamiliar codebase';
 const NETWORK_COMMANDS = 'run_with_network only when a command itself needs the internet or starts a local server or browser, such as end-to-end tests (the user approves each one)';
-// How the main agent reaches the web. With a research helper it has no web
-// tools: searching and reading pages happen on the helper's model.
-export function webPrompt(roles) {
-  return roles.includes('research')
-    ? ` Shell commands run without network and you have no web tools: hand anything on the web (current information, news, documentation, releases, error messages) to the research helper, and use ${NETWORK_COMMANDS}.`
-    : ` Shell commands run without network: use web_search for current information or documentation, web_fetch to read a public https page, and ${NETWORK_COMMANDS}.`;
+// With a research helper the main agent may still look one thing up itself:
+// the Harness's workflow.main_web_lookups (0 to 5, default 0) web_search and
+// web_fetch calls per member message. Anything wider is the helper's work.
+export const MAIN_WEB_LOOKUPS_MAX = 5;
+export function mainWebLookups(manifest) {
+  const n = manifest?.harness?.configuration?.workflow?.main_web_lookups;
+  return Number.isInteger(n) && n >= 0 && n <= MAIN_WEB_LOOKUPS_MAX ? n : 0;
+}
+// The main agent's web tools, counted against the current run's lookups.
+export function limitedWebTools(tools, currentRun, limit) {
+  return tools.map(tool => ({ ...tool, execute: async (...args) => {
+    const run = currentRun();
+    if (run && ++run.webLookups > limit) throw Error(`managed-web-lookups-spent: you used your ${limit} quick web lookup(s) for this message. Hand the rest of the web work to the research helper (delegate role "research").`);
+    return tool.execute(...args);
+  } }));
+}
+// How the main agent reaches the web. With a research helper, searching and
+// reading pages happen on the helper's model, beyond a few quick lookups.
+export function webPrompt(roles, lookups = 0) {
+  if (!roles.includes('research'))
+    return ` Shell commands run without network: use web_search for current information or documentation, web_fetch to read a public https page, and ${NETWORK_COMMANDS}.`;
+  return lookups > 0
+    ? ` Shell commands run without network. For one quick fact (a version, a flag, one documentation page) use web_search or web_fetch yourself, at most ${lookups} call(s) per member message; hand anything wider on the web (several sources, comparisons, news, research) to the research helper, and use ${NETWORK_COMMANDS}.`
+    : ` Shell commands run without network and you have no web tools: hand anything on the web (current information, news, documentation, releases, error messages) to the research helper, and use ${NETWORK_COMMANDS}.`;
 }
 export function helperPrompt(roles) {
   const lines = [];

package/packages/piagent-core/managed/risk-lanes.mjs

@@ -0,0 +1,38 @@
+// Risk lanes (the Harness's workflow.lanes, on unless Studio sets it false):
+// the configured policy is the standard lane, sized on the patch the run made.
+// A tiny change (few files and lines, nothing sensitive) ends after its
+// checks, without a review; a risky one (a complex request, a sensitive file,
+// a wide patch) has a suggested check and review required. "off" stays off.
+export const LANE_LIMITS = Object.freeze({ tinyFiles: 2, tinyLines: 40, riskyFiles: 12, riskyLines: 400 });
+const SENSITIVE = /(^|\/)(migrations?|auth|security|secrets?|permissions?|\.github|infra|terraform|helm|k8s)(\/|$)|(^|\/)(Dockerfile|docker-compose[^/]*|\.gitlab-ci\.yml|package\.json|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|go\.mod|go\.sum|Cargo\.toml|Cargo\.lock|pyproject\.toml|uv\.lock|AGENTS\.md|\.env[^/]*)$|\.(sql|tf|pem|key)$/i;
+export const sensitivePath = file => SENSITIVE.test(String(file ?? ''));
+// Files and changed lines of a patch snapshot (readPatchSnapshot); null when
+// it cannot be read. A new text file counts its lines, a binary one as one.
+export function patchStats(snapshot) {
+  let value;
+  try { value = JSON.parse(snapshot?.patch); } catch { return null; }
+  if (!value || typeof value !== 'object') return null;
+  const paths = new Set(); let lines = 0;
+  for (const line of String(value.patch ?? '').split('\n')) {
+    if (line.startsWith('diff --git ')) paths.add(line.match(/^diff --git a\/(.+) b\/\1$/)?.[1] ?? line.slice(11));
+    else if (/^[+-]/.test(line) && !/^(\+\+\+|---) /.test(line)) lines += 1;
+  }
+  for (const file of Array.isArray(value.untracked) ? value.untracked : []) {
+    if (typeof file?.path !== 'string') continue;
+    paths.add(file.path); lines += file.encoding === 'utf8' ? String(file.contents ?? '').split('\n').filter((l, i, all) => l || i < all.length - 1).length : 1;
+  }
+  return { files: paths.size, lines, paths: [...paths] };
+}
+// An unreadable patch is standard: the configured policy applies.
+export function changeLane(stats, { complex = false } = {}) {
+  if (!stats) return 'standard';
+  const L = LANE_LIMITS;
+  if (complex || stats.paths.some(sensitivePath) || stats.files > L.riskyFiles || stats.lines > L.riskyLines) return 'risky';
+  return stats.files <= L.tinyFiles && stats.lines <= L.tinyLines ? 'tiny' : 'standard';
+}
+export function lanePolicy(policy, lane) {
+  if (!policy.lanes || lane === 'standard') return policy;
+  if (lane === 'tiny') return { ...policy, review: 'off' };
+  const up = mode => mode === 'suggest' ? 'require' : mode;
+  return { ...policy, verify: up(policy.verify), review: up(policy.review) };
+}

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

@@ -25,7 +25,7 @@ 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 { HELPER_CALLS, HELPER_ROLES, helperRoles, helperPrompt, webPrompt, delegateDescription } from './helper-roles.mjs'; import { delegateParameters, delegateArgs, SPEC_PROMPT } from './helper-settlement.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';
 import { restorePermission, recordBypass, permissionSetter } from './permission.mjs';
@@ -114,9 +114,9 @@ export class ManagedSession {
     self.wrapStreams(self.modelRuntime, 'main');
     const customTools = processEditTools(self, self.boundary.tools(api));
     customTools.push(fetchOriginTool(self));
-    // With a research helper the web is its work: search results and pages
-    // are read on its cheaper model, not in the main agent's context.
+    // With a research helper the web is its work (pages read on its cheaper model), beyond the Harness's few quick lookups.
     if (!helperRoles(manifest).includes('research')) customTools.push(...self.webTools(self.modelRuntime, 'main'));
+    else if (mainWebLookups(manifest)) customTools.push(...limitedWebTools(self.webTools(self.modelRuntime, 'main'), () => self.run, mainWebLookups(manifest)));
     // Commands with network, and with Docker when this machine has an engine.
     customTools.push(...commandTools(self));
     // Every helper role passes the tool's schema: Pi fixes a tool's schema
@@ -135,7 +135,7 @@ export class ManagedSession {
     const agentsFiles = projectInstructions(self.cwd, self.boundary.repositoryTop);
     self.checks = repositoryChecks(agentsFiles, self.cwd, self.boundary.repositoryTop);
     // The Harness workflow (possibly changed on a later enrollment) adds its process to the prompt.
-    const loader = managedResourceLoader(api, { systemPrompt: () => BASE_PROMPT + referencePrompt(self.boundary.userHome) + TEST_PROMPT + servicesPrompt(self.boundary) + webPrompt(helperRoles(manifest)) + helperPrompt(helperRoles(self.manifest)) + workflowPrompt(workflowPolicy(self.manifest), self.checks), agentsFiles,
+    const loader = managedResourceLoader(api, { systemPrompt: () => BASE_PROMPT + referencePrompt(self.boundary.userHome) + TEST_PROMPT + servicesPrompt(self.boundary) + webPrompt(helperRoles(manifest), mainWebLookups(manifest)) + helperPrompt(helperRoles(self.manifest)) + workflowPrompt(workflowPolicy(self.manifest), self.checks), agentsFiles,
       skills: self.resources.skills, prompts: self.resources.prompts, themes: terminalExtensions.length ? await loadPiagentThemes(sdk) : [], ...await inlineExtensions(api, sdk, self.cwd,
         [...terminalExtensions, workflowContextExtension(self.cwd, () => self.session.sessionManager)]) });
     const settings = api.SettingsManager.inMemory({ retry: { enabled: false, provider: { maxRetries: 0 } }, cacheWarming: 'off', enableInstallTelemetry: false, enableAnalytics: false, enableSkillCommands: true });

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

@@ -5,6 +5,7 @@ import { failureCode } from '../runtime/managed-failure.mjs';
 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';
 
 // 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.
@@ -17,7 +18,7 @@ export function workflowPolicy(manifest) {
   const mode = value => MODES.includes(value) ? value : 'suggest';
   const loops = Number.isInteger(w.max_fix_loops) && w.max_fix_loops >= 0 && w.max_fix_loops <= 3 ? w.max_fix_loops : 2;
   // A review needs a review helper; without one in the Harness it is off.
-  return { plan: mode(w.plan), verify: mode(w.verify), review: config.review ? mode(w.review) : 'off', maxFixLoops: loops };
+  return { plan: mode(w.plan), verify: mode(w.verify), review: config.review ? mode(w.review) : 'off', maxFixLoops: loops, lanes: w.lanes !== false };
 }
 
 // Checks come from the repository: a "## Checks" section in AGENTS.md (code
@@ -150,6 +151,10 @@ export function workflowPrompt(policy, checks) {
   }
   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.');
+  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.`);
+  }
   return lines.length ? `\n\nProcess for code changes (company Harness):\n${lines.join('\n')}\n${process.platform === 'darwin' ? 'End-to-end and UI checks run in bash with the project\'s Playwright (@playwright/test; add it with npm when the project lacks it) and the browsers installed on this Mac, against a server the test or start_process starts; while a local proxy listens they need run_with_network. When Playwright\'s browsers are missing, ask with run_on_host to run `npx playwright install chromium`.' : 'End-to-end tests that start a local server and a browser run through run_with_network, which the user approves.'} If a check cannot run because the machine lacks something (a runtime such as a JDK, Docker, a database or another service, the network), do not stop there: request the approval that makes it run (run_with_network, run_with_docker, start_docker, or run_on_host to install what is missing) or ask the member with ask_user; never install or start anything without that approval.\nA command stops after 10 minutes and anything left running in the background stops when the turn ends: run the checks that cover your change first and a long suite in parts, not in the background.${process.platform === 'darwin' ? ' A dev server, watcher or local service you need across turns runs with start_process (read it with process_output, stop it with stop_process).' : ''}` : '';
 }
 
@@ -241,7 +246,9 @@ export class RunProcess {
       // 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 });
+      sentAt: null, sentDigest: null, rejudged: false, reviewSettled: false, objectionsAsked: false,
+      // The patch's risk lane (workflow.lanes) and the main agent's own web lookups.
+      lane: null, laneStats: null, laneDigest: null, webLookups: 0 });
   }
   // Plan "require" on a complex task that has no plan yet.
   planMissing(plan) {
@@ -299,7 +306,18 @@ export class RunProcess {
 // A finding, a failed claim or an objection to a brief is the agent's to fix
 // or answer; the same disagreement a second time goes to the member.
 export async function completionGate(managed, run, signal) {
-  const session = managed.session, policy = run.policy;
+  const session = managed.session, configured = run.policy;
+  let policy = configured;
+  // The lane of the patch as it is now, read again only when it changed.
+  const laneOf = async digest => {
+    if (!configured.lanes) return configured;
+    if (run.laneDigest === null || run.laneDigest !== digest) {
+      let stats = null;
+      try { stats = patchStats(await managed.patchSnapshot?.()); } catch { /* unreadable: standard */ }
+      run.lane = changeLane(stats, run); run.laneStats = stats ? { files: stats.files, lines: stats.lines } : null; run.laneDigest = digest;
+    }
+    return lanePolicy(configured, run.lane);
+  };
   const digestOf = async () => { try { return await (managed.changeDigest ?? managed.patchDigest).call(managed); } catch { return null; } };
   const reviewDigestOf = async () => { try { return await managed.patchDigest(); } catch { return null; } };
   const stopped = () => signal?.aborted || ['aborted', 'error'].includes(session.messages.findLast(m => m.role === 'assistant')?.stopReason);
@@ -316,6 +334,7 @@ export async function completionGate(managed, run, signal) {
     // A check that passed still counts when the turn was cut off after it.
     if (run.changed) run.verified = run.verifiedOn(digest);
     run.docsOnly = run.changed && onlyNonCode(managed.ownPaths);
+    policy = run.changed ? await laneOf(digest) : configured;
     if (stopped()) { interrupted = run.changed; break; }
     if (run.changed) {
       const reviewDigest = managed.review ? await reviewDigestOf() : null;
@@ -424,7 +443,8 @@ export async function completionGate(managed, run, signal) {
     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);
   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 } } }, { triggerTurn: false });
+    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 });
 }
 
 // The run's process sees each edit and command: plan guard before, check

package/packages/piagent-core/package.json

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