@hadooppei/hwcode 1.0.19 → 1.0.20

package/.pi/dist/lib/knowledge/evidence.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { sanitizeKnowledgeText } from "./sanitize.js";
+import { containsInjectedSkill, sanitizeKnowledgeText } from "./sanitize.js";
 const FAILURE_RE = /(?:\b(?:error|failed|failure|invalid|unsupported|timeout|timed out|unreachable|servfail|refused)\b|not supported|失败|错误|不支持|超时|无法|不可达)/iu;
 const VERIFICATION_RE = /(?:\b(?:verified|verification|active|running|succeeded|success|http\s*=?\s*200|downloaded newer image)\b|验证通过|运行成功|成功创建|已恢复)/iu;
 const CORRECTION_RE = /(?:\b(?:must|should|always|never|correction|most valuable)\b|必须|应该|不应该|纠正|最有价值|不要|务必)/iu;
@@ -189,6 +189,10 @@ export function buildKnowledgeEvidence(entries) {
         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),
@@ -198,6 +202,10 @@ export function buildKnowledgeEvidence(entries) {
         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/dist/lib/knowledge/extractor.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.js";
+import { compactKnowledgeText } from "./sanitize.js";
 export const KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT = `You are HWCode's background knowledge reviewer.
 Review the supplied structured evidence and conversation delta. Return strict JSON and no markdown.
 Persist only knowledge that is likely to be useful in future sessions:
@@ -37,117 +38,54 @@ export function buildKnowledgeExtractionPrompt(projectRoot, delta, context = "",
     ].join("\n");
 }
 export function parseKnowledgeReviewEnvelope(text) {
-    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) => {
-                if (!item || typeof item !== "object")
-                    return false;
-                const value = item;
-                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) => {
+            if (!item || typeof item !== "object")
+                return false;
+            const value = item;
+            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) {
     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");
-    return JSON.parse(unfenced.slice(start, end + 1));
-}
-export function parseCandidateEnvelope(text) {
-    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;
+    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));
-        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);
     }
     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 = [];
-        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, start) {
-    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) {
     return createHash("sha256").update(delta).digest("hex");

package/.pi/dist/lib/knowledge/review-worker.js

@@ -6,7 +6,7 @@ import { parentPort, workerData } from "node:worker_threads";
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.js";
 import { userRuntimePaths } from "../runtime/paths.js";
 import { parseKnowledgeReviewEnvelope } from "./extractor.js";
-import { writeKnowledgeReviewStatus } from "./review-status.js";
+import { readKnowledgeReviewStatus, writeKnowledgeReviewStatus } from "./review-status.js";
 import { sanitizeKnowledgeText } from "./sanitize.js";
 import { findNextReviewTask } from "./session-scanner.js";
 import { commitKnowledgeReview, ensureKnowledgeDirectories, loadCurrentManifest } from "./store.js";
@@ -54,9 +54,28 @@ function publishReviewStatus() {
     }
 }
 function boundedError(error) {
-    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) {
+    if (!reviewStatus)
+        return;
+    for (const field of ["blockedReviews", "reviewFailures"]) {
+        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) {
+    clearSupersededReviewState(task);
     activeAttempt = (reviewAttempts.get(task.reviewKey) ?? 0) + 1;
     reviewAttempts.set(task.reviewKey, activeAttempt);
     activeStartedAt = Date.now();
@@ -64,11 +83,17 @@ function beginReview(task) {
     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) {
@@ -87,22 +112,57 @@ function finishReview(task, outcome, detail) {
     clearTimeout(activeDeadlineTimer);
     activeDeadlineTimer = undefined;
     if (!reviewStatus)
-        return;
+        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")
+    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, reason) {
     clearTimeout(activeDeadlineTimer);
@@ -149,8 +209,14 @@ function scheduleElection(delay = Math.floor(Math.random() * 500)) {
     timer.unref();
 }
 function stepDown(reason) {
-    if (activeTask)
+    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;
@@ -277,8 +343,17 @@ function becomeLeader(server) {
         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 });
@@ -315,7 +390,8 @@ async function scanForReview() {
     }
     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;
@@ -336,14 +412,14 @@ async function scanForReview() {
         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 });
     }
 }
 function handleReviewResult(message) {
@@ -366,8 +442,8 @@ function handleReviewResult(message) {
         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;

package/.pi/dist/lib/knowledge/sanitize.js

@@ -3,6 +3,14 @@ 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) {
+    return INJECTED_SKILL_MARKER_RE.test(value);
+}
+export function stripInjectedSkillBlocks(value) {
+    return value.replace(INJECTED_SKILL_BLOCK_RE, "");
+}
 export function sanitizeKnowledgeText(value) {
     return value
         .replace(PRIVATE_KEY_RE, "<redacted-private-key>")

package/.pi/dist/lib/knowledge/session-scanner.js

@@ -6,10 +6,9 @@ import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.js";
 import { canonicalizeDirectory } from "../working-directory.js";
 import { buildKnowledgeEpisodes, buildKnowledgeEvidence } from "./evidence.js";
 import { knowledgeDeltaDigest } from "./extractor.js";
-import { sanitizeKnowledgeText } from "./sanitize.js";
+import { containsInjectedSkill, sanitizeKnowledgeText, stripInjectedSkillBlocks } from "./sanitize.js";
 import { projectKnowledgeKey } from "./store.js";
 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;
@@ -42,17 +41,53 @@ function reviewPiece(entry, index) {
         return undefined;
     const message = entry.message;
     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;
     const category = role === "user" ? "user" : role === "toolResult" ? "tool" : "assistant";
     return { index, priority, category, text: `[${role}]\n${content.slice(0, cap)}` };
 }
-function buildDelta(entries) {
-    const pieces = entries.map(reviewPiece).filter((piece) => Boolean(piece));
+function entryId(entry) {
+    const value = entry.id;
+    return typeof value === "string" ? value : undefined;
+}
+function knowledgeLookupResultEntryIds(entries) {
+    const lookupCalls = new Set();
+    const resultEntries = new Set();
+    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;
+                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, excludedEntryIds = new Set()) {
+    const pieces = entries.map((entry, index) => {
+        const id = entryId(entry);
+        return id && excludedEntryIds.has(id) ? undefined : reviewPiece(entry, index);
+    }).filter((piece) => Boolean(piece));
     const selected = [];
     const categoryRemaining = {
         user: 14_000, workflow: 6_000, summary: 4_000, assistant: 8_000, tool: 4_000,
@@ -79,8 +114,11 @@ function buildDelta(entries) {
     return selected.sort((left, right) => left.index - right.index).map((piece) => piece.text).join("\n\n")
         .slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxDeltaChars);
 }
-function buildValidationContext(entries) {
-    const pieces = entries.map(reviewPiece).filter((piece) => Boolean(piece));
+function buildValidationContext(entries, excludedEntryIds = new Set()) {
+    const pieces = entries.map((entry, index) => {
+        const id = entryId(entry);
+        return id && excludedEntryIds.has(id) ? undefined : reviewPiece(entry, index);
+    }).filter((piece) => 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")
         && FAILURE_EVIDENCE_RE.test(piece.text)));
@@ -184,7 +222,10 @@ function buildRecallQuery(entries, ids) {
         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)
@@ -273,10 +314,13 @@ export function readReviewTask(sessionFile, cursor, now = Date.now()) {
     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([
@@ -295,7 +339,7 @@ export function readReviewTask(sessionFile, cursor, now = Date.now()) {
         deltaDigest, fileSize: stat.size, fileMtimeMs: stat.mtimeMs,
     };
 }
-export function findNextReviewTask(sessionsRoot, reviews, now = Date.now()) {
+export function findNextReviewTask(sessionsRoot, reviews, now = Date.now(), excludedReviewKeys = new Set()) {
     const files = discoverSessionFiles(sessionsRoot).map((path) => {
         try {
             return { path, mtimeMs: statSync(path).mtimeMs };
@@ -312,7 +356,7 @@ export function findNextReviewTask(sessionsRoot, reviews, now = Date.now()) {
         const stableCursor = task ? reviews[task.sessionKey] : undefined;
         if (task && stableCursor && stableCursor !== cursor)
             task = readReviewTask(file.path, stableCursor, now);
-        if (task)
+        if (task && !excludedReviewKeys.has(task.reviewKey))
             return task;
     }
     return undefined;

package/.pi/dist/lib/runtime/defaults.js

@@ -31,6 +31,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/extensions/knowledge.ts

@@ -22,6 +22,7 @@ interface ActiveReview {
   leaderToken: string;
   controller: AbortController;
   abortReason?: string;
+  diagnostic?: string;
 }
 
 interface ProcessKnowledgeRuntime {
@@ -117,7 +118,7 @@ function reportWorkerIssue(error: unknown): void {
   const prior = runtime.lastWorkerIssue;
   if (prior?.message === message && now - prior.reportedAt < 60_000) return;
   runtime.lastWorkerIssue = { message, reportedAt: now };
-  const rendered = `HWCode knowledge worker failed: ${message}`;
+  const rendered = `HWCode knowledge worker failed: ${message.slice(0, 600)}`;
   if (runtime.context?.hasUI) runtime.context.ui.notify(rendered, "error");
   else console.error(rendered);
 }
@@ -162,7 +163,7 @@ async function runReview(message: Extract<KnowledgeWorkerOutput, { type: "review
     runtime.activeReview = review;
     timeout = setTimeout(() => {
       if (controller.signal.aborted) return;
-      review!.abortReason = "knowledge-review-model-timeout";
+      review!.abortReason = `knowledge-review-model-timeout after ${KNOWLEDGE_RUNTIME_DEFAULTS.review.modelTimeoutMs}ms${review!.diagnostic ? `; ${review!.diagnostic}` : ""}`;
       controller.abort();
     }, KNOWLEDGE_RUNTIME_DEFAULTS.review.modelTimeoutMs);
     timeout.unref();
@@ -210,6 +211,23 @@ async function runReview(message: Extract<KnowledgeWorkerOutput, { type: "review
         .slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxExistingBodyChars);
       return content ? { ...reference, content } : reference;
     });
+    const prompt = buildKnowledgeExtractionPrompt(
+      message.task.projectRoot,
+      message.task.delta.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxNarrativeChars),
+      message.task.context,
+      related,
+      promptContext.evidence,
+      promptContext.episodes,
+    );
+    review.diagnostic = [
+      `reviewKey=${message.task.reviewKey}`,
+      `model=${ctx.model.provider}/${ctx.model.id}`,
+      `promptChars=${prompt.length}`,
+      `deltaChars=${message.task.delta.length}`,
+      `evidenceItems=${promptContext.evidence.length}`,
+      `episodeItems=${promptContext.episodes.length}`,
+      `existingItems=${related.length}`,
+    ].join("; ");
     const response = await ctx.modelRegistry.complete(
       ctx.model,
       {
@@ -218,14 +236,7 @@ async function runReview(message: Extract<KnowledgeWorkerOutput, { type: "review
           role: "user",
           content: [{
             type: "text",
-            text: buildKnowledgeExtractionPrompt(
-              message.task.projectRoot,
-              message.task.delta.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxNarrativeChars),
-              message.task.context,
-              related,
-              promptContext.evidence,
-              promptContext.episodes,
-            ),
+            text: prompt,
           }],
           timestamp: Date.now(),
         }],
@@ -237,10 +248,14 @@ async function runReview(message: Extract<KnowledgeWorkerOutput, { type: "review
       .map((item) => item.text).join("\n");
     post({ type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId, raw });
   } catch (error) {
-    const reason = review?.controller.signal.aborted
+    const baseReason = review?.controller.signal.aborted
       ? review.abortReason ?? "knowledge-review-interrupted"
       : error instanceof Error ? error.message : String(error);
-    if (reason === "model-executor-is-busy" || isExpectedReviewInterruption(reason)) {
+    const expectedInterruption = baseReason === "model-executor-is-busy" || isExpectedReviewInterruption(baseReason);
+    const reason = review?.diagnostic && !expectedInterruption && !baseReason.includes("reviewKey=")
+      ? `${baseReason}; ${review.diagnostic}`
+      : baseReason;
+    if (expectedInterruption) {
       post({ type: "review_deferred", leaderToken: message.leaderToken, requestId: message.requestId, reason });
     } else {
       post({ type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId, error: reason });
@@ -263,7 +278,7 @@ function handleWorkerMessage(message: KnowledgeWorkerOutput): void {
     cancelActiveReview(message.reason);
     return;
   }
-  if (message.type === "review_failed") reportWorkerIssue(message.error);
+  if (message.type === "review_failed" && message.terminal !== false) reportWorkerIssue(message.error);
 }
 
 function ensureWorker(): Worker | undefined {