@hadooppei/hwcode 1.0.19 → 1.0.20

package/.pi/extensions/workflows/cloud/provider-tools.ts

@@ -8,7 +8,9 @@ import { toolError, toolOk } from "../../../lib/tool-result.ts";
 import { evaluateCommandArgumentsAccess } from "../../../lib/workspace/access-policy.ts";
 import { prepareCloudExecution } from "../../../lib/workflows/cloud/adapters.ts";
 import { cloudExecutionBlockReason, recordStrategyFailure } from "../../../lib/workflows/cloud/execution.ts";
-import { runProcess, truncateOutput, type ProcessResult } from "../../../lib/workflows/cloud/process.ts";
+import {
+  cloudProviderFailureReason, runProcess, truncateOutput, type ProcessResult,
+} from "../../../lib/workflows/cloud/process.ts";
 import { CLOUD_EXECUTABLES, classifyCloudOperation, getCloudProvider, redactCredentialValues, type CloudOperation } from "../../../lib/workflows/cloud/providers.ts";
 import { cloudArtifactDirectory } from "../../../lib/workflows/cloud/workspace.ts";
 import { WORKFLOW_EXTERNAL_AUDIT_TYPE, cloudDetails } from "../../../lib/workflows/state.ts";
@@ -106,16 +108,44 @@ export function registerCloudProviderTools(pi: ExtensionAPI, runtime: CloudExten
           : await runProcess(params.command, prepared.args, { cwd: cloudArtifactDirectory(activeState), env: prepared.env, signal });
       } finally { prepared.cleanup?.(); }
 
-      const stdout = truncateOutput(redactCredentialValues(result.stdout, credentials));
-      const stderr = truncateOutput(redactCredentialValues(result.stderr, credentials));
-      pi.appendEntry(CLOUD_AUDIT_TYPE, { vendor: details.vendor, command: params.command, operation, intent: params.intent, approach: params.approach, exitCode: result.code, executedAt: new Date().toISOString() });
-      if (result.code !== 0) {
-        const failed = recordStrategyFailure(details, params.approach, params.command, stderr.trim() || stdout.trim() || `exit code ${result.code}`, CLOUD_RUNTIME_DEFAULTS.workflow.maxFailedApproaches);
+      const redactedStdout = redactCredentialValues(result.stdout, credentials);
+      const redactedStderr = redactCredentialValues(result.stderr, credentials);
+      const providerFailure = cloudProviderFailureReason(redactedStdout, redactedStderr);
+      const stdout = truncateOutput(redactedStdout);
+      const stderr = truncateOutput(redactedStderr);
+      const failureReason = result.code !== 0
+        ? stderr.trim() || stdout.trim() || `exit code ${result.code}`
+        : providerFailure;
+      pi.appendEntry(CLOUD_AUDIT_TYPE, {
+        vendor: details.vendor,
+        command: params.command,
+        operation,
+        intent: params.intent,
+        approach: params.approach,
+        exitCode: result.code,
+        outcome: failureReason ? "failed" : "succeeded",
+        providerFailure: providerFailure ? safeStepText(providerFailure, credentials) : undefined,
+        executedAt: new Date().toISOString(),
+      });
+      if (failureReason) {
+        const failed = recordStrategyFailure(details, params.approach, params.command, failureReason, CLOUD_RUNTIME_DEFAULTS.workflow.maxFailedApproaches);
         runtime.replaceDetails(activeState, failed, failed.terminalFailure ? "failed" : "executing");
         const suffix = failed.terminalFailure
           ? "\n\nTERMINAL FAILURE: Three materially different approaches failed. Explain causes and summarize progress and changes. Do not try another cloud operation."
           : `\n\nDistinct failed approaches: ${failed.failedApproaches.length}/${CLOUD_RUNTIME_DEFAULTS.workflow.maxFailedApproaches}.`;
-        return { content: [{ type: "text" as const, text: `Cloud command failed with exit code ${result.code}.\n${stderr || stdout}${suffix}` }], isError: true, details: { operation, exitCode: result.code, terminalFailure: failed.terminalFailure } };
+        const heading = result.code !== 0
+          ? `Cloud command failed with exit code ${result.code}.`
+          : "Cloud provider reported a failure despite exit code 0.";
+        return {
+          content: [{ type: "text" as const, text: `${heading}\n${stderr || stdout || providerFailure}${suffix}` }],
+          isError: true,
+          details: {
+            operation,
+            exitCode: result.code,
+            providerFailure: Boolean(providerFailure),
+            terminalFailure: failed.terminalFailure,
+          },
+        };
       }
 
       const successfulSteps = [...details.successfulSteps, {

package/.pi/lib/knowledge/evidence.ts

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 
-import { sanitizeKnowledgeText } from "./sanitize.ts";
+import { containsInjectedSkill, sanitizeKnowledgeText } from "./sanitize.ts";
 import type { KnowledgeEpisode, KnowledgeEvidence, KnowledgeEvidenceKind } from "./types.ts";
 
 const FAILURE_RE = /(?:\b(?:error|failed|failure|invalid|unsupported|timeout|timed out|unreachable|servfail|refused)\b|not supported|失败|错误|不支持|超时|无法|不可达)/iu;
@@ -200,6 +200,9 @@ export function buildKnowledgeEvidence(entries: SessionEntry[]): KnowledgeEviden
     const role = typeof message.role === "string" ? message.role : "";
     const text = textContent(content).trim();
     if (role === "user" && text) {
+      // Skill bodies and workflow activation envelopes are injected as user-role messages by
+      // the host. They are execution context, not an explicit human directive to persist.
+      if (containsInjectedSkill(text)) return;
       evidence.push({
         id: evidenceId(entryId, "user"), entryId, timestamp, kind: userKind(text),
         subject: "User requirement or correction", outcome: "unknown", excerpt: boundedExcerpt(text, 700),
@@ -209,6 +212,9 @@ export function buildKnowledgeEvidence(entries: SessionEntry[]): KnowledgeEviden
     if (role === "toolResult" && text) {
       const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : "";
       const call = calls.get(toolCallId);
+      // Recalled knowledge is comparison context, not fresh execution evidence. Treating a
+      // lookup result as verification would let knowledge reinforce itself merely by loading it.
+      if (call?.name === "hwcode_knowledge_lookup") return;
       const outcome = outcomeFor(message, text);
       const callText = call ? `[call] ${call.name}: ${compactArguments(call.args)}\n` : "";
       evidence.push({

package/.pi/lib/knowledge/extractor.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.ts";
+import { compactKnowledgeText } from "./sanitize.ts";
 import type { KnowledgeEpisode, KnowledgeEpisodeDecision, KnowledgeEvidence } from "./types.ts";
 
 export interface ExistingKnowledgeContext {
@@ -65,25 +66,21 @@ export function buildKnowledgeExtractionPrompt(
 }
 
 export function parseKnowledgeReviewEnvelope(text: string): KnowledgeReviewEnvelope {
-  try {
-    const parsed = parseEnvelopeObject(text);
-    if (!Array.isArray(parsed.candidates)) throw new Error("Knowledge reviewer response is missing candidates[]");
-    const validDecisions = new Set(["add", "reinforce", "extend", "correct", "retire", "skip"]);
-    const decisions = Array.isArray(parsed.episodeDecisions)
-      ? parsed.episodeDecisions.filter((item): item is KnowledgeEpisodeDecision => {
-        if (!item || typeof item !== "object") return false;
-        const value = item as Record<string, unknown>;
-        return typeof value.episodeId === "string" && validDecisions.has(String(value.decision))
-          && typeof value.reason === "string";
-      })
-      : [];
-    return {
-      episodeDecisions: decisions,
-      candidates: parsed.candidates.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates),
-    };
-  } catch {
-    return { episodeDecisions: [], candidates: parseCandidateEnvelope(text) };
-  }
+  const parsed = parseEnvelopeObject(text);
+  if (!Array.isArray(parsed.candidates)) throw new Error("Knowledge reviewer response is missing candidates[]");
+  const validDecisions = new Set(["add", "reinforce", "extend", "correct", "retire", "skip"]);
+  const decisions = Array.isArray(parsed.episodeDecisions)
+    ? parsed.episodeDecisions.filter((item): item is KnowledgeEpisodeDecision => {
+      if (!item || typeof item !== "object") return false;
+      const value = item as Record<string, unknown>;
+      return typeof value.episodeId === "string" && validDecisions.has(String(value.decision))
+        && typeof value.reason === "string";
+    })
+    : [];
+  return {
+    episodeDecisions: decisions,
+    candidates: parsed.candidates.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates),
+  };
 }
 
 function parseEnvelopeObject(text: string): Record<string, unknown> {
@@ -91,68 +88,30 @@ function parseEnvelopeObject(text: string): Record<string, unknown> {
   const unfenced = trimmed.replace(/^```(?:json)?\s*/iu, "").replace(/\s*```$/u, "");
   const start = unfenced.indexOf("{");
   const end = unfenced.lastIndexOf("}");
-  if (start < 0 || end <= start) throw new Error("Knowledge reviewer did not return a JSON object");
-  return JSON.parse(unfenced.slice(start, end + 1)) as Record<string, unknown>;
-}
-
-export function parseCandidateEnvelope(text: string): unknown[] {
-  const trimmed = text.trim();
-  const unfenced = trimmed.replace(/^```(?:json)?\s*/iu, "").replace(/\s*```$/u, "");
-  const start = unfenced.indexOf("{");
-  const end = unfenced.lastIndexOf("}");
-  if (start < 0 || end <= start) throw new Error("Knowledge reviewer did not return a JSON object");
-  let strictError: unknown;
+  if (start < 0 || end <= start) {
+    throw new Error([
+      "Knowledge reviewer did not return a complete JSON object",
+      `responseChars=${unfenced.length}`,
+      `responseExcerpt=${JSON.stringify(compactKnowledgeText(unfenced, 1_200))}`,
+    ].join("; "));
+  }
+  const payload = unfenced.slice(start, end + 1);
   try {
-    const parsed = JSON.parse(unfenced.slice(start, end + 1)) as { candidates?: unknown };
-    if (!Array.isArray(parsed.candidates)) throw new Error("Knowledge reviewer response is missing candidates[]");
-    return parsed.candidates.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates);
+    return JSON.parse(payload) as Record<string, unknown>;
   } catch (error) {
-    strictError = error;
-  }
-
-  const arrayKey = /["']candidates["']\s*:/gu.exec(unfenced);
-  const arrayStart = arrayKey ? unfenced.indexOf("[", arrayKey.index + arrayKey[0].length) : -1;
-  if (arrayStart >= 0) {
-    const candidates: unknown[] = [];
-    let inString = false;
-    let escaped = false;
-    for (let index = arrayStart + 1; index < unfenced.length && candidates.length < KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates; index++) {
-      const character = unfenced[index];
-      if (inString) {
-        if (escaped) escaped = false;
-        else if (character === "\\") escaped = true;
-        else if (character === '"') inString = false;
-        continue;
-      }
-      if (character === '"') { inString = true; continue; }
-      if (character !== "{") continue;
-      const objectEnd = balancedObjectEnd(unfenced, index);
-      if (objectEnd < 0) break;
-      try { candidates.push(JSON.parse(unfenced.slice(index, objectEnd + 1))); } catch { /* Salvage other complete candidates. */ }
-      index = objectEnd;
-    }
-    if (candidates.length > 0) return candidates;
-  }
-  throw strictError;
-}
-
-function balancedObjectEnd(value: string, start: number): number {
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let index = start; index < value.length; index++) {
-    const character = value[index];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (character === "\\") escaped = true;
-      else if (character === '"') inString = false;
-      continue;
-    }
-    if (character === '"') { inString = true; continue; }
-    if (character === "{") depth++;
-    else if (character === "}" && --depth === 0) return index;
+    const message = error instanceof Error ? error.message : String(error);
+    const offsetMatch = /position\s+(\d+)/iu.exec(message);
+    const offset = offsetMatch ? Number.parseInt(offsetMatch[1]!, 10) : -1;
+    const excerptStart = offset >= 0 ? Math.max(0, offset - 600) : 0;
+    const excerptEnd = offset >= 0 ? Math.min(payload.length, offset + 600) : Math.min(payload.length, 1_200);
+    const excerpt = compactKnowledgeText(payload.slice(excerptStart, excerptEnd), 1_200);
+    throw new Error([
+      `Knowledge reviewer returned invalid JSON: ${message}`,
+      `responseChars=${payload.length}`,
+      offset >= 0 ? `errorOffset=${offset}` : undefined,
+      `responseExcerpt=${JSON.stringify(excerpt)}`,
+    ].filter(Boolean).join("; "));
   }
-  return -1;
 }
 
 export function knowledgeDeltaDigest(delta: string): string {

package/.pi/lib/knowledge/review-status.ts

@@ -40,6 +40,24 @@ export interface KnowledgeReviewStatus {
     result?: PersistKnowledgeResult;
     error?: string;
   };
+  reviewFailures?: Record<string, {
+    sessionKey: string;
+    sessionFileHash: string;
+    attempts: Array<{
+      attempt: number;
+      failedAt: string;
+      durationMs: number;
+      error: string;
+    }>;
+  }>;
+  blockedReviews?: Record<string, {
+    reviewKey: string;
+    sessionKey: string;
+    sessionFileHash: string;
+    blockedAt: string;
+    attempts: number;
+    error: string;
+  }>;
 }
 
 export function writeKnowledgeReviewStatus(status: KnowledgeReviewStatus, home: string): void {

package/.pi/lib/knowledge/review-worker.ts

@@ -7,7 +7,7 @@ import { parentPort, workerData } from "node:worker_threads";
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.ts";
 import { userRuntimePaths } from "../runtime/paths.ts";
 import { parseKnowledgeReviewEnvelope } from "./extractor.ts";
-import { type KnowledgeReviewStatus, writeKnowledgeReviewStatus } from "./review-status.ts";
+import { readKnowledgeReviewStatus, type KnowledgeReviewStatus, writeKnowledgeReviewStatus } from "./review-status.ts";
 import { sanitizeKnowledgeText } from "./sanitize.ts";
 import { findNextReviewTask } from "./session-scanner.ts";
 import { commitKnowledgeReview, ensureKnowledgeDirectories, loadCurrentManifest } from "./store.ts";
@@ -59,21 +59,44 @@ function publishReviewStatus(): void {
 }
 
 function boundedError(error: unknown): string {
-  return sanitizeKnowledgeText(error instanceof Error ? error.message : String(error)).slice(0, 1_000);
+  return sanitizeKnowledgeText(error instanceof Error ? error.message : String(error))
+    .slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxFailureDetailChars);
+}
+
+function clearSupersededReviewState(task: KnowledgeReviewTask): void {
+  if (!reviewStatus) return;
+  for (const field of ["blockedReviews", "reviewFailures"] as const) {
+    const records = reviewStatus[field];
+    if (!records) continue;
+    for (const [reviewKey, record] of Object.entries(records)) {
+      if (record.sessionKey === task.sessionKey && reviewKey !== task.reviewKey) {
+        delete records[reviewKey];
+        reviewAttempts.delete(reviewKey);
+      }
+    }
+    if (Object.keys(records).length === 0) reviewStatus[field] = undefined;
+  }
 }
 
 function beginReview(task: KnowledgeReviewTask): void {
+  clearSupersededReviewState(task);
   activeAttempt = (reviewAttempts.get(task.reviewKey) ?? 0) + 1;
   reviewAttempts.set(task.reviewKey, activeAttempt);
   activeStartedAt = Date.now();
   clearTimeout(activeDeadlineTimer);
   activeDeadlineTimer = setTimeout(() => {
     if (activeTask?.requestId !== task.requestId) return;
-    const error = "knowledge-review-result-timeout";
-    finishReview(task, "failed", { error });
+    const error = [
+      `knowledge-review-result-timeout after ${KNOWLEDGE_RUNTIME_DEFAULTS.review.modelTimeoutMs + 5_000}ms`,
+      `reviewKey=${task.reviewKey}`,
+      `deltaChars=${task.delta.length}`,
+      `evidenceItems=${task.evidence?.length ?? 0}`,
+      `episodeItems=${task.episodes?.length ?? 0}`,
+    ].join("; ");
+    const terminal = finishReview(task, "failed", { error });
     activeTask = undefined;
     send({ type: "review_cancel", requestId: task.requestId, reason: error });
-    send({ type: "review_failed", requestId: task.requestId, error });
+    send({ type: "review_failed", requestId: task.requestId, error, terminal });
   }, KNOWLEDGE_RUNTIME_DEFAULTS.review.modelTimeoutMs + 5_000);
   activeDeadlineTimer.unref();
   if (reviewStatus) {
@@ -93,24 +116,59 @@ function finishReview(
   task: KnowledgeReviewTask,
   outcome: "saved" | "failed",
   detail: { generationId?: string; result?: PersistKnowledgeResult; error?: unknown },
-): void {
+): boolean {
   clearTimeout(activeDeadlineTimer);
   activeDeadlineTimer = undefined;
-  if (!reviewStatus) return;
+  if (!reviewStatus) return false;
+  const error = detail.error === undefined ? undefined : boundedError(detail.error);
+  const exhausted = outcome === "failed" && activeAttempt >= KNOWLEDGE_RUNTIME_DEFAULTS.review.maxAttempts;
+  const completedAt = new Date().toISOString();
+  const durationMs = Math.max(0, Date.now() - activeStartedAt);
   reviewStatus.activeReview = undefined;
   reviewStatus.lastReview = {
     reviewKey: task.reviewKey,
     sessionKey: task.sessionKey,
     attempt: activeAttempt,
     outcome,
-    completedAt: new Date().toISOString(),
-    durationMs: Math.max(0, Date.now() - activeStartedAt),
+    completedAt,
+    durationMs,
     generationId: detail.generationId,
     result: detail.result,
-    error: detail.error === undefined ? undefined : boundedError(detail.error),
+    error,
   };
-  if (outcome === "saved") reviewAttempts.delete(task.reviewKey);
+  if (outcome === "saved") {
+    reviewAttempts.delete(task.reviewKey);
+    delete reviewStatus.reviewFailures?.[task.reviewKey];
+    clearSupersededReviewState(task);
+  } else {
+    const reviewFailures = reviewStatus.reviewFailures ?? {};
+    const prior = reviewFailures[task.reviewKey];
+    reviewFailures[task.reviewKey] = {
+      sessionKey: task.sessionKey,
+      sessionFileHash: task.sessionFileHash,
+      attempts: [...(prior?.attempts ?? []), {
+        attempt: activeAttempt,
+        failedAt: completedAt,
+        durationMs,
+        error: error ?? "unknown-review-failure",
+      }].slice(-KNOWLEDGE_RUNTIME_DEFAULTS.review.maxAttempts),
+    };
+    reviewStatus.reviewFailures = Object.fromEntries(Object.entries(reviewFailures).slice(-100));
+  }
+  if (exhausted) {
+    const blockedReviews = reviewStatus.blockedReviews ?? {};
+    blockedReviews[task.reviewKey] = {
+      reviewKey: task.reviewKey,
+      sessionKey: task.sessionKey,
+      sessionFileHash: task.sessionFileHash,
+      blockedAt: new Date().toISOString(),
+      attempts: activeAttempt,
+      error: error ?? "unknown-review-failure",
+    };
+    reviewStatus.blockedReviews = Object.fromEntries(Object.entries(blockedReviews).slice(-100));
+  }
   publishReviewStatus();
+  return exhausted;
 }
 
 function deferReview(task: KnowledgeReviewTask, reason: string): void {
@@ -155,7 +213,12 @@ function scheduleElection(delay = Math.floor(Math.random() * 500)): void {
 }
 
 function stepDown(reason: string): void {
-  if (activeTask) send({ type: "review_cancel", requestId: activeTask.requestId, reason });
+  if (activeTask) {
+    const attempts = reviewAttempts.get(activeTask.reviewKey) ?? 1;
+    if (attempts <= 1) reviewAttempts.delete(activeTask.reviewKey);
+    else reviewAttempts.set(activeTask.reviewKey, attempts - 1);
+    send({ type: "review_cancel", requestId: activeTask.requestId, reason });
+  }
   if (reviewStatus) {
     reviewStatus.state = "stepped-down";
     reviewStatus.stepDownReason = reason;
@@ -260,8 +323,16 @@ function becomeLeader(server: Server): void {
     scheduleElection();
   });
   writeLeaderMetadata(electedAt);
+  const priorStatus = readKnowledgeReviewStatus(home);
+  reviewAttempts.clear();
+  for (const [reviewKey, failure] of Object.entries(priorStatus?.reviewFailures ?? {})) {
+    const attempt = Math.max(0, ...failure.attempts.map((item) => item.attempt));
+    if (attempt > 0) reviewAttempts.set(reviewKey, attempt);
+  }
   reviewStatus = {
     version: 1, protocolVersion: 3, state: "leader", pid: process.pid, leaderToken, electedAt, updatedAt: electedAt,
+    blockedReviews: priorStatus?.blockedReviews,
+    reviewFailures: priorStatus?.reviewFailures,
   };
   publishReviewStatus();
   send({ type: "leadership", state: "leader", leaderToken });
@@ -296,7 +367,8 @@ async function scanForReview(): Promise<void> {
   }
   try {
     const manifest = loadCurrentManifest(home);
-    const task = findNextReviewTask(sessionsRoot, manifest.reviews);
+    const blockedReviewKeys = new Set(Object.keys(reviewStatus?.blockedReviews ?? {}));
+    const task = findNextReviewTask(sessionsRoot, manifest.reviews, Date.now(), blockedReviewKeys);
     if (!task) return;
     activeTask = task;
     beginReview(task);
@@ -315,13 +387,14 @@ async function scanForReview(): Promise<void> {
     }
     send({ type: "review_request", leaderToken, requestId: task.requestId, task });
   } catch (error) {
-    if (activeTask) finishReview(activeTask, "failed", { error });
-    else if (reviewStatus) {
+    const failedTask = activeTask;
+    const terminal = failedTask ? finishReview(failedTask, "failed", { error }) : true;
+    if (!failedTask && reviewStatus) {
       reviewStatus.lastScanError = { at: new Date().toISOString(), error: boundedError(error) };
       publishReviewStatus();
     }
     activeTask = undefined;
-    send({ type: "review_failed", error: boundedError(error) });
+    send({ type: "review_failed", requestId: failedTask?.requestId, error: boundedError(error), terminal });
   }
 }
 
@@ -342,8 +415,8 @@ function handleReviewResult(message: Extract<KnowledgeWorkerInput, { type: "revi
     }
     committed = true;
   } catch (error) {
-    finishReview(task, "failed", { error });
-    send({ type: "review_failed", requestId: task.requestId, error: boundedError(error) });
+    const terminal = finishReview(task, "failed", { error });
+    send({ type: "review_failed", requestId: task.requestId, error: boundedError(error), terminal });
   } finally {
     activeTask = undefined;
     if (committed) queueMicrotask(() => void scanForReview());

package/.pi/lib/knowledge/sanitize.ts

@@ -3,6 +3,16 @@ const BEARER_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/giu;
 const JWT_RE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/gu;
 const SECRET_ASSIGNMENT_RE = /\b(access[_-]?key|secret(?:[_-]?(?:access|key))?|password|passwd|token|credential|client[_-]?secret)\b(\s*[:=]\s*)[^\s,;]+/giu;
 const URL_CREDENTIAL_RE = /(https?:\/\/)[^\s/@:]+:[^\s/@]+@/giu;
+const INJECTED_SKILL_BLOCK_RE = /<skill\b[^>]*>[\s\S]*?<\/skill>/giu;
+const INJECTED_SKILL_MARKER_RE = /<skill\b[^>]*>/iu;
+
+export function containsInjectedSkill(value: string): boolean {
+  return INJECTED_SKILL_MARKER_RE.test(value);
+}
+
+export function stripInjectedSkillBlocks(value: string): string {
+  return value.replace(INJECTED_SKILL_BLOCK_RE, "");
+}
 
 export function sanitizeKnowledgeText(value: string): string {
   return value

package/.pi/lib/knowledge/session-scanner.ts

@@ -10,7 +10,7 @@ import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.ts";
 import { canonicalizeDirectory } from "../working-directory.ts";
 import { buildKnowledgeEpisodes, buildKnowledgeEvidence } from "./evidence.ts";
 import { knowledgeDeltaDigest } from "./extractor.ts";
-import { sanitizeKnowledgeText } from "./sanitize.ts";
+import { containsInjectedSkill, sanitizeKnowledgeText, stripInjectedSkillBlocks } from "./sanitize.ts";
 import { projectKnowledgeKey } from "./store.ts";
 import type { KnowledgeReviewCursor, KnowledgeReviewTask } from "./types.ts";
 
@@ -22,7 +22,6 @@ interface ReviewPiece {
 }
 
 const FAILURE_EVIDENCE_RE = /(?:\b(?:error|failed|failure|invalid|unsupported|mistyp(?:e|ed)|typo)\b|not supported|失败|错误|不支持|无效)/iu;
-const INJECTED_SKILL_RE = /<skill\b[^>]*>[\s\S]*?<\/skill>/giu;
 const SAFE_KNOWLEDGE_ID_RE = /^[a-z0-9][a-z0-9-]{0,79}$/u;
 const MAX_RECALL_QUERY_CHARS = 4_000;
 const MAX_LOADED_KNOWLEDGE_IDS = 8;
@@ -54,8 +53,13 @@ function reviewPiece(entry: SessionEntry, index: number): ReviewPiece | undefine
   if (entry.type !== "message" || !entry.message || typeof entry.message !== "object") return undefined;
   const message = entry.message as unknown as Record<string, unknown>;
   const role = typeof message.role === "string" ? message.role : "message";
-  const content = sanitizeKnowledgeText(textContent(message.content).replace(INJECTED_SKILL_RE, "[loaded skill omitted]"));
+  const rawContent = textContent(message.content);
+  const injectedContext = role === "user" && containsInjectedSkill(rawContent);
+  const content = sanitizeKnowledgeText(injectedContext ? stripInjectedSkillBlocks(rawContent) : rawContent);
   if (!content) return undefined;
+  if (injectedContext) {
+    return { index, priority: 3, category: "assistant", text: `[injected_context]\n${content.slice(0, 4_000)}` };
+  }
   const priority = role === "user" ? 0 : role === "toolResult" && FAILURE_EVIDENCE_RE.test(content) ? 2
     : role === "toolResult" ? 4 : 3;
   const cap = role === "user" ? 8_000 : role === "toolResult" ? 1_500 : 4_000;
@@ -63,8 +67,39 @@ function reviewPiece(entry: SessionEntry, index: number): ReviewPiece | undefine
   return { index, priority, category, text: `[${role}]\n${content.slice(0, cap)}` };
 }
 
-function buildDelta(entries: SessionEntry[]): string {
-  const pieces = entries.map(reviewPiece).filter((piece): piece is ReviewPiece => Boolean(piece));
+function entryId(entry: SessionEntry): string | undefined {
+  const value = (entry as unknown as Record<string, unknown>).id;
+  return typeof value === "string" ? value : undefined;
+}
+
+function knowledgeLookupResultEntryIds(entries: SessionEntry[]): Set<string> {
+  const lookupCalls = new Set<string>();
+  const resultEntries = new Set<string>();
+  for (const entry of entries) {
+    const message = messageRecord(entry);
+    const content = message?.content;
+    if (Array.isArray(content)) {
+      for (const raw of content) {
+        if (!raw || typeof raw !== "object") continue;
+        const item = raw as Record<string, unknown>;
+        if (item.type === "toolCall" && item.name === "hwcode_knowledge_lookup" && typeof item.id === "string") {
+          lookupCalls.add(item.id);
+        }
+      }
+    }
+    if (message?.role === "toolResult" && typeof message.toolCallId === "string" && lookupCalls.has(message.toolCallId)) {
+      const id = entryId(entry);
+      if (id) resultEntries.add(id);
+    }
+  }
+  return resultEntries;
+}
+
+function buildDelta(entries: SessionEntry[], excludedEntryIds: ReadonlySet<string> = new Set()): string {
+  const pieces = entries.map((entry, index) => {
+    const id = entryId(entry);
+    return id && excludedEntryIds.has(id) ? undefined : reviewPiece(entry, index);
+  }).filter((piece): piece is ReviewPiece => Boolean(piece));
   const selected: ReviewPiece[] = [];
   const categoryRemaining: Record<ReviewPiece["category"], number> = {
     user: 14_000, workflow: 6_000, summary: 4_000, assistant: 8_000, tool: 4_000,
@@ -87,8 +122,11 @@ function buildDelta(entries: SessionEntry[]): string {
     .slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxDeltaChars);
 }
 
-function buildValidationContext(entries: SessionEntry[]): string {
-  const pieces = entries.map(reviewPiece).filter((piece): piece is ReviewPiece => Boolean(piece));
+function buildValidationContext(entries: SessionEntry[], excludedEntryIds: ReadonlySet<string> = new Set()): string {
+  const pieces = entries.map((entry, index) => {
+    const id = entryId(entry);
+    return id && excludedEntryIds.has(id) ? undefined : reviewPiece(entry, index);
+  }).filter((piece): piece is ReviewPiece => Boolean(piece));
   const latestWorkflow = pieces.filter((piece) => piece.category === "workflow").at(-1);
   const evidence = pieces.filter((piece) => (
     (piece.category === "tool" || piece.category === "assistant" || piece.category === "summary")
@@ -183,7 +221,9 @@ function buildRecallQuery(entries: SessionEntry[], ids: string[]): string {
   for (const entry of entries.slice().reverse()) {
     const message = messageRecord(entry);
     if (!message || message.role !== "user") continue;
-    const text = compactRecallValue(textContent(message.content).replace(INJECTED_SKILL_RE, ""), 800);
+    const raw = textContent(message.content);
+    if (containsInjectedSkill(raw)) continue;
+    const text = compactRecallValue(raw, 800);
     if (text) lines.push(`User request: ${text}`);
     if (lines.filter((line) => line.startsWith("User request:")).length >= 2) break;
   }
@@ -245,10 +285,13 @@ export function readReviewTask(
   const evidenceWindow = cursorIndex >= 0 ? branch.slice(Math.max(0, cursorIndex - 40)) : pending;
   const evidence = buildKnowledgeEvidence(evidenceWindow).filter((item) => pendingEntryIds.has(item.entryId));
   const episodes = buildKnowledgeEpisodes(evidence);
-  const delta = buildDelta(pending);
+  const lookupResultEntryIds = knowledgeLookupResultEntryIds(branch);
+  const delta = buildDelta(pending, lookupResultEntryIds);
   const loadedIds = loadedKnowledgeIds(pending);
   const recallQuery = buildRecallQuery(pending, loadedIds);
-  const context = cursorIndex >= 0 ? buildValidationContext(branch.slice(0, cursorIndex + 1)) : "";
+  const context = cursorIndex >= 0
+    ? buildValidationContext(branch.slice(0, cursorIndex + 1), lookupResultEntryIds)
+    : "";
   const firstEntryId = pending[0].id;
   const lastEntryId = pending[pending.length - 1].id;
   const deltaDigest = knowledgeDeltaDigest([
@@ -272,6 +315,7 @@ export function findNextReviewTask(
   sessionsRoot: string,
   reviews: Record<string, KnowledgeReviewCursor>,
   now = Date.now(),
+  excludedReviewKeys: ReadonlySet<string> = new Set(),
 ): KnowledgeReviewTask | undefined {
   const files = discoverSessionFiles(sessionsRoot).map((path) => {
     try { return { path, mtimeMs: statSync(path).mtimeMs }; } catch { return undefined; }
@@ -283,7 +327,7 @@ export function findNextReviewTask(
     let task = readReviewTask(file.path, cursor, now);
     const stableCursor = task ? reviews[task.sessionKey] : undefined;
     if (task && stableCursor && stableCursor !== cursor) task = readReviewTask(file.path, stableCursor, now);
-    if (task) return task;
+    if (task && !excludedReviewKeys.has(task.reviewKey)) return task;
   }
   return undefined;
 }

package/.pi/lib/knowledge/worker-protocol.ts

@@ -13,7 +13,7 @@ export type KnowledgeWorkerOutput =
   | { type: "review_request"; leaderToken: string; requestId: string; task: KnowledgeReviewTask }
   | { type: "review_cancel"; requestId: string; reason: string }
   | { type: "review_saved"; requestId: string; generationId?: string; result: PersistKnowledgeResult }
-  | { type: "review_failed"; requestId?: string; error: string }
+  | { type: "review_failed"; requestId?: string; error: string; terminal?: boolean }
   | { type: "generation_changed"; generationId: string };
 
 export interface CoordinatorBroadcast {

package/.pi/lib/runtime/defaults.ts

@@ -32,6 +32,8 @@ export const KNOWLEDGE_RUNTIME_DEFAULTS = Object.freeze({
     idleMs: 60_000,
     capabilityPollMs: 5_000,
     modelTimeoutMs: 180_000,
+    maxAttempts: 2,
+    maxFailureDetailChars: 4_000,
     maxDeltaChars: 12_000,
     maxPriorContextChars: 4_000,
     maxNarrativeChars: 6_000,

package/.pi/lib/workflows/cloud/process.ts

@@ -18,6 +18,25 @@ export interface ProcessResult {
   spawnErrorCode?: string;
 }
 
+const BRACKETED_PROVIDER_ERROR_RE = /\[(?:USE|CLI|AUTH|HTTP|SERVER|SYSTEM|SDK)_ERROR\][^\r\n]*/iu;
+const STRUCTURED_PROVIDER_FAILURE_RE = /"kind"\s*:\s*"Status"[\s\S]{0,500}"status"\s*:\s*"(?:failure|failed|error)"/iu;
+const STRUCTURED_ERROR_CODE_RE = /"(?:errorCode|error_code|code)"\s*:\s*(?:"[^"\r\n]+"|\d+)/iu;
+
+/** Detect CLIs that report an API failure in output while incorrectly exiting with code 0. */
+export function cloudProviderFailureReason(stdout: string, stderr: string): string | undefined {
+  const output = `${stderr}\n${stdout}`.trim();
+  if (!output) return undefined;
+  const bracketed = BRACKETED_PROVIDER_ERROR_RE.exec(output)?.[0]?.trim();
+  if (bracketed) return bracketed.slice(0, 2_000);
+  if (STRUCTURED_PROVIDER_FAILURE_RE.test(output) && STRUCTURED_ERROR_CODE_RE.test(output)) {
+    const status = STRUCTURED_PROVIDER_FAILURE_RE.exec(output)?.[0];
+    const code = STRUCTURED_ERROR_CODE_RE.exec(output)?.[0];
+    const message = /"message"\s*:\s*"([^"\r\n]+)"/iu.exec(output)?.[1];
+    return [status, code, message].filter(Boolean).join("; ").slice(0, 2_000);
+  }
+  return undefined;
+}
+
 function captureOutput(current: string, chunk: Buffer): string {
   if (Buffer.byteLength(current, "utf8") >= MAX_CAPTURE_BYTES) return current;
   const remaining = MAX_CAPTURE_BYTES - Buffer.byteLength(current, "utf8");