@piagent/platform 1.35.0 → 1.36.0

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

@@ -6,7 +6,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { MemoryOutbox, memoryScope, scopeID } from './memory-outbox.mjs';
-import { CheckLessons } from './memory-lessons.mjs';
+import { CheckLessons } from './memory-lessons.mjs'; import { SkillFeedback } from './skill-feedback.mjs'; import { RoundServes, FEEDBACK_PROTOCOL } from './memory-serves.mjs';
 import { CLIENT_AGENT } from './client-agent.mjs'; import { knownCapabilities, refreshCapabilities } from './studio-capabilities.mjs';
 import { redactedText } from '../runtime/managed-failure.mjs';
 import { git, repoKey, repositoryAt, findRepositories, topDirs, eventFor, commitChanges } from './memory-repos.mjs';
@@ -43,7 +43,7 @@ export function turnRecord(messages, changedFiles = [], lessons = []) {
   };
   const parts = [];
   // Preserve evidence and the final answer before budgeting member input.
-  const lessonText = lessons.slice(0, 3).map(l => `${l.line} Evidence: ${l.failed_call} → ${l.passed_call}; fingerprint ${l.fingerprint}; ${l.at}.`).join('\n');
+  const lessonText = lessons.slice(0, 3).map(l => `${l.line} Evidence: ${l.failed_call} ${l.kind === 'tool_error' ? 'and' : '→'} ${l.passed_call}; fingerprint ${l.fingerprint}; ${l.at}.`).join('\n');
   const memberBudget = MAX_TURN - 13000 - Buffer.byteLength(lessonText);
   const member = safeClip(asked.map(a => `Member: ${a}`).join('\n\n'), memberBudget);
   if (member) parts.push(member);
@@ -68,7 +68,7 @@ function bounded(promise, signal, late = () => {}) {
 
 export class TeamMemory {
   constructor({ origin, cwd, stateDir, conversationId, scope = () => null, lease = null, renew = null, fetchImpl = fetch, now = () => Date.now(), changed = () => [] }) {
-    this.renew = renew; this.scope = scope; this.lease = lease; this.protocol = 0; this.background = null; this.stats = {};
+    this.renew = renew; this.scope = scope; this.lease = lease; this.protocol = 0; this.background = null; this.stats = {}; this.serves = new RoundServes();
     Object.assign(this, { origin, cwd, stateDir, conversationId, fetchImpl, now, changed, repo: undefined, repos: undefined, folder: null, heads: {}, offUntil: 0, retain: true, briefed: false });
     this.syncScope();
     this.knownPath = stateDir ? path.join(stateDir, 'memory-known.json') : null;
@@ -215,7 +215,7 @@ export class TeamMemory {
     this.retain = answered.every(([, b]) => b.retain_sessions !== false);
     this.count('brief_successes'); if (this.lastBrief === 'ok') this.count('brief_nonempty');
     const heads = {};
-    for (const [r, b] of answered) heads[r.key] = b.git_head ?? null;
+    for (const [r, b] of answered) { heads[r.key] = b.git_head ?? null; this.serves.add(r.key, b.serve_id); }
     this.startBackground(grant, heads);
     const several = repos.length > 1, pages = new Set(), parts = [];
     let facts = 0;
@@ -309,11 +309,12 @@ export class TeamMemory {
         if (own.length) item.files = own.slice(0, 12).map(f => String(f).slice(0, 200));
         if (checks) item.checks = checks;
       }
+      if (this.protocol >= FEEDBACK_PROTOCOL && this.serves.of(r.key).length) item.serves = this.serves.of(r.key);
       if (!box.put(item)) { this.count('queue_rejected'); continue; }
       this.count('queued'); queued = true;
     }
-    // A rebind cannot send the old round using the new key.
-    if (!queued || scopeID(source) !== scopeID(this.scope())) return;
+    // A serve belongs to the round that used it. A rebind cannot send the old round using the new key.
+    this.serves.clear(); if (!queued || scopeID(source) !== scopeID(this.scope())) return;
     await this.#drain(grant, deadline);
   }
 
@@ -331,7 +332,7 @@ export class TeamMemory {
       try {
         if (claim.record.attempts) this.count('write_retries');
         // A round queued for protocol 3 meets a Studio that went back to 2: send the fields 2 knows.
-        const item = this.protocol >= PROTOCOL ? claim.record.item : (({ context, files, checks, ...v2 }) => v2)(claim.record.item);
+        const { serves, ...v3 } = claim.record.item, item = this.protocol >= FEEDBACK_PROTOCOL ? claim.record.item : this.protocol >= PROTOCOL ? v3 : (({ context, files, checks, ...v2 }) => v2)(v3);
         const ack = await this.#post(grant, 'retain', item, WRITE_MS, this.renew, signal);
         if (!ack || ack.status === 'retain_disabled') { this.retain = false; outcome = 'discard'; }
         else if (ack.event_id === claim.record.item.event_id && ack.operation_id && ['pending','processing','completed','failed','cancelled','unknown'].includes(ack.status)) {
@@ -369,7 +370,7 @@ export class TeamMemory {
     if (repository && !picked && this.repos.length > 1) return this.#none(repository);
     this.count(renew?.role && renew.role !== 'main' ? 'helper_search_calls' : 'search_calls');
     return this.#each(picked ? [picked] : this.#about(query), async r => {
-      try { return (await this.#post(grant, 'search', await this.#body(r, { query }), TOOL_MS, renew ?? this.renew))?.text ?? 'Team memory is off for this team.'; }
+      try { const answer = await this.#post(grant, 'search', await this.#body(r, { query }), TOOL_MS, renew ?? this.renew); this.serves.add(r.key, answer?.serve_id); return answer?.text ?? 'Team memory is off for this team.'; }
       catch { return 'Team memory did not answer; go on without it.'; }
     });
   }
@@ -447,7 +448,7 @@ export function attachMemory(self, manager, agentDir, verify) {
   return self.memory;
 }
 export function trackMemoryLessons(self) {
-  self.session.subscribe(event => { try { self.memoryTurn?.checks?.event(event); } catch { /* optional evidence */ } });
+  self.session.subscribe(event => { try { self.memoryTurn?.checks?.event(event); self.memoryTurn?.skills?.event(event); } catch { /* optional evidence */ } });
 }
 // Whether this conversation has team memory now: Studio answered memory for
 // this key recently and has not switched it off since (the Terminal's header).
@@ -464,7 +465,7 @@ export const helperMemoryTools = (managed, grant, renew) => managed.memory?.stat
 export async function openRound(self, manager, text) {
   if (!self.memory) return;
   self.memory.stats = {};
-  const turn = self.memoryTurn = { id: randomUUID(), at: new Date().toISOString(), scope: memoryScope(self.origin, self.manifest), request: text, users: [text], checks: new CheckLessons(self.checks?.commands ?? []) };
+  const turn = self.memoryTurn = { id: randomUUID(), at: new Date().toISOString(), scope: memoryScope(self.origin, self.manifest), request: text, users: [text], checks: new CheckLessons(self.checks?.commands ?? []), skills: SkillFeedback.forRound(self, text) };
   turn.entry = manager.appendCustomEntry('agent-watch-memory-turn', { id: turn.id, at: turn.at, scope: turn.scope });
   try {
     // Preserve the first brief in history; later refreshes are injected by the
@@ -479,6 +480,7 @@ export async function openRound(self, manager, text) {
   } catch { /* memory is optional */ }
 }
 export async function closeRound(self) {
+  try { const t = self.memoryTurn; t?.skills?.close({ checks: t.checks?.last, lessons: t.checks?.lessons ?? [] }); } catch { /* optional evidence */ }
   if (!self.grant || self.preflight || !self.memory || !self.memoryTurn) return;
   const turn = self.memoryTurn, closing = AbortSignal.timeout(CLOSE_MS), started = Date.now();
   let outcome = 'unknown';

package/packages/piagent-core/managed/request-stream.mjs

@@ -257,7 +257,7 @@ function capacityStatus(owner) {
 // run) fails at once, as before. Pi decides by the words of an error, which
 // for a company failure would match "rate limited" or "timeout" in sentences
 // that must not be retried; here it decides by Studio's code only.
-export const TURN_RETRY_CODES = new Set(['upstream_interrupted', 'upstream_incomplete', 'upstream_timeout', 'upstream_unavailable', 'output_limit_exceeded',
+export const TURN_RETRY_CODES = new Set(['upstream_interrupted', 'upstream_incomplete', 'upstream_timeout', 'upstream_unavailable', 'upstream_server_error', 'output_limit_exceeded',
   'connector_unavailable', 'connector_execution_failed', 'inference_unavailable', 'studio-unreachable']);
 export const TURN_RETRY = { maxRetries: 2, baseDelayMs: 2_000 };
 
@@ -278,7 +278,13 @@ export function enableCompanyTurnRetry(session, settings, link = null) {
   settings.applyOverrides({ retry: { enabled: true, ...TURN_RETRY } });
   const prepare = session._prepareRetry;
   if (link && typeof prepare === 'function') session._prepareRetry = async function (message) {
-    if (!studio(message)) return prepare.call(this, message);
+    // Each ask again goes to the member's local log (studio-link.jsonl), so a
+    // task that stopped or went on can be read back later.
+    if (!studio(message)) {
+      const asked = await prepare.call(this, message);
+      if (asked) link.log({ kind: 'turn_retry', code: failureCode(message.errorMessage), attempt: this._retryAttempt });
+      return asked;
+    }
     // Studio answers here and was not away lately (Agent Watch or Studio's
     // connector failed on a running Studio): Pi's own asks again, as before.
     if (!(await link.needed(failureCode(message.errorMessage)).catch(() => false))) return companyTurnRetryable(message) ? prepare.call(this, message) : false;

package/packages/piagent-core/managed/skill-feedback.mjs

@@ -0,0 +1,79 @@
+// Skill feedback (after Cognee's proposal-first skill improvement): which
+// skills a round used, and whether the round ended badly (its last check
+// failed, or a command failed the same way twice). A skill that keeps ending
+// badly gets a proposal file to review under .pi/piagent-state/skill-proposals;
+// Piagent never edits a skill itself and makes no model call for this.
+import fs from 'node:fs';
+import path from 'node:path';
+
+const MIN_FAILURES = 3, MIN_SHARE = 0.5, KEEP = 10, REPROPOSE_MS = 7 * 86400_000;
+const safeName = name => String(name).replace(/[^A-Za-z0-9_.-]/g, '_').slice(0, 80);
+
+export class SkillFeedback {
+  // A managed round's tracker, when the conversation has skills.
+  static forRound(self, text) {
+    if (!self.resources?.skills?.length) return null;
+    const feedback = new SkillFeedback({ cwd: self.cwd, skills: self.resources.skills });
+    feedback.request(text);
+    return feedback;
+  }
+  constructor({ cwd, skills = [], now = Date.now }) {
+    this.cwd = cwd; this.now = now; this.used = new Set();
+    this.skills = skills.filter(s => s?.name && s?.filePath).map(s => ({ name: s.name, file: path.resolve(s.filePath) }));
+  }
+  // A member's /skill:name arrives expanded as a <skill name="..."> block.
+  request(text) {
+    for (const m of String(text ?? '').matchAll(/<skill name="([^"]{1,80})"/g)) if (this.skills.some(s => s.name === m[1])) this.used.add(m[1]);
+  }
+  // The model reading a skill's SKILL.md is the skill being used.
+  event(event) {
+    if (event?.type !== 'tool_execution_start' || event.toolName !== 'read' || typeof event.args?.path !== 'string') return;
+    const file = path.resolve(this.cwd, event.args.path);
+    for (const s of this.skills) if (s.file === file) this.used.add(s.name);
+  }
+  // The round's end: counts for every skill it used; returns the proposals written.
+  close({ checks = 'none', lessons = [] } = {}) {
+    if (!this.used.size || !this.cwd) return [];
+    const errors = lessons.filter(l => l.kind === 'tool_error');
+    const bad = checks === 'failed' || errors.length > 0;
+    const written = [];
+    let dir;
+    // Inside the project's own state folder only: never through a link.
+    try {
+      const state = path.join(fs.realpathSync(this.cwd), '.pi', 'piagent-state');
+      dir = path.join(state, 'skill-proposals');
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+      if (fs.realpathSync(dir) !== dir || fs.lstatSync(dir).isSymbolicLink()) return [];
+    } catch { return []; }
+    for (const name of this.used) {
+      const file = path.join(dir, `${safeName(name)}.json`);
+      let state = { name, uses: 0, failures: [], proposed_at: null };
+      try { state = { ...state, ...JSON.parse(fs.readFileSync(file, 'utf8')) }; } catch { /* first use */ }
+      state.uses++;
+      if (bad) {
+        const detail = checks === 'failed' ? 'the round\'s last check failed' : errors[0].line;
+        state.failures = [...state.failures, { at: new Date(this.now()).toISOString(), detail: String(detail).slice(0, 400) }].slice(-KEEP);
+      }
+      const recent = state.failures.length, share = recent / Math.min(state.uses, KEEP);
+      const due = recent >= MIN_FAILURES && share >= MIN_SHARE && (!state.proposed_at || this.now() - Date.parse(state.proposed_at) > REPROPOSE_MS);
+      if (due) {
+        state.proposed_at = new Date(this.now()).toISOString();
+        const skill = this.skills.find(s => s.name === name);
+        const proposal = path.join(dir, `${safeName(name)}.md`);
+        fs.writeFileSync(proposal, [
+          `# Review the skill "${name}"`, '',
+          `Proposed ${state.proposed_at} by Piagent. Nothing was changed: read the evidence, then edit the skill yourself or delete this file.`, '',
+          `Skill file: ${skill ? path.relative(this.cwd, skill.file) || skill.file : 'unknown'}`, '',
+          `${recent} of the last ${Math.min(state.uses, KEEP)} rounds that used it ended badly:`, '',
+          ...state.failures.map(f => `- ${f.at}: ${f.detail}`), '',
+          'Look for: a step the skill tells the agent to run that no longer works here (a command, flag, path or check),',
+          'instructions that contradict the repository\'s current conventions, or a missing prerequisite.', ''].join('\n'), { mode: 0o600 });
+        written.push(proposal);
+        state.failures = [];
+      }
+      fs.writeFileSync(file, JSON.stringify(state, null, 1), { mode: 0o600 });
+    }
+    this.used.clear();
+    return written;
+  }
+}

package/packages/piagent-core/managed/studio-link.mjs

@@ -151,6 +151,16 @@ export class StudioLink {
   }
   justBack() { return !!this.recoveredAt && this.now() - this.recoveredAt < (this.brokerGraceMs ?? BROKER_GRACE_MS); }
 
+  // A pause Stop can end (a round asked again after a provider's passing failure).
+  async hold(ms, signal) {
+    const controller = new AbortController(), stop = () => controller.abort(signal?.reason);
+    if (signal?.aborted) throw signal.reason ?? Error('aborted');
+    signal?.addEventListener('abort', stop, { once: true });
+    this.waiting.add(controller);
+    try { await this.pause(ms, controller.signal); }
+    finally { signal?.removeEventListener('abort', stop); this.waiting.delete(controller); if (!this.waiting.size) this.status(undefined); }
+  }
+
   // Stop ends every wait at once.
   cancel() { for (const controller of this.waiting) controller.abort(Error('managed-request-aborted')); }
 
@@ -211,6 +221,14 @@ export class StudioLink {
   }
 }
 
+// What the main agent reads when its work goes on after the model provider
+// failed for a passing reason in the middle of the round.
+export function providerResumeMessage(code, attempt, max) {
+  return { customType: 'agent-watch-process', display: true,
+    content: `Harness: your last step was cut off because the model provider failed while answering [${code}]; that is a passing failure on its side (attempt ${attempt} of ${max} to go on). Nothing you asked for is lost: the files and the checklist are as you left them. Check where you were (the checklist, git status, the last command you ran) and continue the member's task from there; do not redo work that is already done.`,
+    details: { phase: 'resume', cause: 'provider', code, attempt, max } };
+}
+
 // What the main agent reads when its work goes on after Studio was back.
 export function resumeMessage(wait, code) {
   const why = { studio_update: `Studio was updated${wait.version_before && wait.version_after ? ` (${wait.version_before} → ${wait.version_after})` : ''}`,

package/packages/piagent-core/package.json

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

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

@@ -52,6 +52,10 @@ const CODES = {
   managed_service_unavailable: ['service', 'Studio could not start the run'],
   upstream_interrupted: ['service', 'the model response was interrupted'],
   upstream_incomplete: ['service', 'the model returned no response'],
+  // The provider's own error event in the middle of an answer (OpenAI
+  // server_error / api_error, Anthropic api_error / overloaded_error): a
+  // passing failure on its side, asked again.
+  upstream_server_error: ['service', 'the model provider failed while answering (a passing error on its side)'],
   // Studio ended the stream: the model wrote past the request's output limit
   // (a degenerate answer), or the request was ended for the member.
   output_limit_exceeded: ['service', 'the model kept writing past its output limit and was stopped'],
@@ -104,6 +108,7 @@ const CODES = {
 };
 const ROLES = { main: 'main agent', scout: 'scout subagent', research: 'research subagent', verify: 'verify 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;
 
 export function failureKind(code) { return CODES[code]?.[0] ?? 'failed'; }
@@ -151,6 +156,9 @@ export function failureCode(raw) {
   const local = /(managed-broker:[A-Za-z_]{1,80}|managed-[a-z-]{1,80}|web-search-empty)/.exec(text)?.[1];
   if (known(local)) return local;
   if (!studio && /\bAPI error \((?:50[234]|52\d|530)\)|^(?:50[234]|52\d|530)\b/.test(text)) return 'studio-gateway-unavailable';
+  // How Pi's providers word the provider's error event inside a streamed
+  // answer (seen 2026-10-21: gpt-6-sol sent api_error mid-answer and the task stopped).
+  if (PROVIDER_SERVER_ERROR.test(text)) return 'upstream_server_error';
   if (studio || /\bAPI error \(\d{3}\)|^\d{3} \{/.test(text)) return 'studio-request-failed';
   // The provider declined the request itself (its usage policy), not Studio:
   // the same request is declined again, so it is said in words.

package/packages/piagent-webui/package.json

@@ -28,7 +28,7 @@
     "@vitejs/plugin-react": "6.0.5",
     "json-schema-to-typescript": "15.0.4",
     "typescript": "7.0.2",
-    "vite": "8.2.1"
+    "vite": "8.2.4"
   },
   "engines": {
     "node": ">=22.19.0"