@piagent/platform 1.35.1 → 1.36.1

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

@@ -15,6 +15,7 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { CLIENT_AGENT } from './client-agent.mjs';
+import { failureCode, failureText } from '../runtime/managed-failure.mjs';
 
 // Codes whose cause is Studio or the way to it: Studio, its gateway or its
 // connector did not answer (stopped, restarting, an update), or Agent Watch
@@ -34,6 +35,13 @@ const LOG_BYTES = 2 * 1024 * 1024, QUEUE = 50, BATCH = 20, SEND_TRIES = 5;
 const MIN_PAUSE_MS = 2_000, MAX_PAUSE_MS = 30_000, MAX_STREAK_PAUSE_MS = 5 * 60_000, BEAT_TIMEOUT_MS = 5_000;
 // After Studio was away, Agent Watch gets this long to reach it again.
 export const BROKER_GRACE_MS = 10 * 60_000;
+// Agent Watch could not reach Studio while Studio answers here: its way to
+// Studio failed for a moment (a gateway's 5xx, a dropped connection, a slow
+// answer). Found on 2026-10-22: one such failure renewing the grant stopped a
+// 25-minute task at once. It is asked again, pausing longer each time, until
+// it has failed for this long without a request going through; then it fails
+// as before (Agent Watch itself is broken, not the way to Studio).
+export const BROKER_RETRY_MS = 3 * 60_000;
 
 const header = (headers, name) => {
   if (!headers) return null;
@@ -74,7 +82,7 @@ export class StudioLink {
     if (seen.boot) this.last = { boot: seen.boot, version: seen.version ?? this.last.version };
   }
   // A request went through: the next wait starts with a short pause again.
-  ok() { this.streak = 0; }
+  ok() { this.streak = 0; this.brokerSince = null; }
   waits(code) { return STUDIO_WAIT_CODES.has(code); }
   // Studio or the way to it, whatever Studio's heartbeat says now.
   always(code) { return this.waits(code) && !conditional(code); }
@@ -107,7 +115,7 @@ export class StudioLink {
     if (signal?.aborted) throw signal.reason ?? Error('aborted');
     if (!this.waits(code)) return null;
     const first = conditional(code) ? await this.beat(signal) : null;
-    if (first?.state === 'ready' && !this.justBack()) return null;
+    if (first?.state === 'ready' && !this.justBack() && !this.brokerRetry(code)) return null;
     const controller = new AbortController(), stop = () => controller.abort(signal?.reason);
     signal?.addEventListener('abort', stop, { once: true });
     this.waiting.add(controller);
@@ -115,7 +123,8 @@ export class StudioLink {
     const seen = new Set(first ? [first.state] : []);
     this.log({ kind: 'studio_wait', state: 'start', id: event.id, phase, role, code, version: event.before.version, conversation });
     this.notify({ type: 'managed_studio_wait', id: event.id, role, phase, code, state: 'start', waitedMs: 0 });
-    this.status(`Studio is not answering (${code}). Waiting; the work goes on by itself when Studio is back. Esc stops.`);
+    this.status(first?.state === 'ready' ? `Agent Watch could not reach Studio (${code}). Asking again; the work goes on by itself. Esc stops.`
+      : `Studio is not answering (${code}). Waiting; the work goes on by itself when Studio is back. Esc stops.`);
     // Failing again right after a wait (Studio answers, the request does
     // not): each such wait starts with a longer pause, up to five minutes.
     let pause = Math.min(MAX_STREAK_PAUSE_MS, this.minPauseMs * 2 ** Math.min(this.streak, 8));
@@ -147,7 +156,15 @@ export class StudioLink {
   async needed(code, signal) {
     if (signal?.aborted) throw signal.reason ?? Error('aborted');
     if (!this.waits(code)) return false;
-    return !(conditional(code) && (await this.beat(signal)).state === 'ready' && !this.justBack());
+    return !(conditional(code) && (await this.beat(signal)).state === 'ready' && !this.justBack() && !this.brokerRetry(code, false));
+  }
+  // An Agent Watch failure on a Studio that answers: asked again within
+  // BROKER_RETRY_MS of the first one since a request last went through.
+  brokerRetry(code, start = true) {
+    if (!BROKER.test(code)) return false;
+    const since = this.brokerSince ?? this.now();
+    if (start) this.brokerSince = since;
+    return this.now() - since < (this.brokerRetryMs ?? BROKER_RETRY_MS);
   }
   justBack() { return !!this.recoveredAt && this.now() - this.recoveredAt < (this.brokerGraceMs ?? BROKER_GRACE_MS); }
 
@@ -239,3 +256,16 @@ export function resumeMessage(wait, code) {
     content: `Harness: your last step was cut off because ${why} [${code}]; Studio answers again after about ${minutes} min. 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: wait.cause, waitedMs: wait.waited_ms, code } };
 }
+
+// A broker call (closing the round's run) when Agent Watch's way to Studio
+// fails for a moment: asked again while the link waits, so a passing gateway
+// error does not fail a turn whose work is done.
+export async function viaLink(link, ask, { conversation = null, runId = null } = {}) {
+  for (;;) {
+    try { return await ask(); }
+    catch (error) {
+      const code = failureCode(failureText(error));
+      if (!(await link?.waitUntilBack({ phase: 'broker', code, conversation, runId }).catch(() => null))) throw error;
+    }
+  }
+}

package/packages/piagent-core/package.json

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