@hadooppei/hwcode 1.0.19 → 1.0.22

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;
@@ -81,8 +81,11 @@ function boundedExcerpt(value, limit = 900) {
     if (clean.length <= limit)
         return clean;
     const lines = clean.split("\n");
-    const significant = lines.filter((line) => FAILURE_RE.test(line) || VERIFICATION_RE.test(line));
-    const selected = [...lines.slice(0, 3), ...significant.slice(0, 5), ...lines.slice(-3)];
+    const priority = (line) => REVERSAL_RE.test(line) ? 0
+        : FAILURE_RE.test(line) && VERIFICATION_RE.test(line) ? 1
+            : FAILURE_RE.test(line) ? 2 : 3;
+    const significant = lines.filter((line) => (REVERSAL_RE.test(line) || FAILURE_RE.test(line) || VERIFICATION_RE.test(line))).sort((left, right) => priority(left) - priority(right));
+    const selected = [...lines.slice(0, 2), ...significant.slice(0, 7), ...lines.slice(-2)];
     return [...new Set(selected)].join("\n").slice(0, limit);
 }
 function compactArguments(args) {
@@ -152,10 +155,8 @@ function entryIdOf(entry, index) {
 function evidenceId(entryId, suffix) {
     return `ev-${digest(`${entryId}\0${suffix}`)}`;
 }
-function outcomeFor(message, text) {
-    if (message.isError === true || FAILURE_RE.test(text))
-        return "failure";
-    return "success";
+function outcomeFor(message) {
+    return message.isError === true ? "failure" : "success";
 }
 function userKind(text) {
     return CORRECTION_RE.test(text) ? "user-correction" : "user-directive";
@@ -189,6 +190,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,11 +203,15 @@ export function buildKnowledgeEvidence(entries) {
         if (role === "toolResult" && text) {
             const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : "";
             const call = calls.get(toolCallId);
-            const outcome = outcomeFor(message, text);
+            // 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);
             const callText = call ? `[call] ${call.name}: ${compactArguments(call.args)}\n` : "";
             evidence.push({
                 id: evidenceId(entryId, toolCallId || "tool"), entryId, timestamp,
-                kind: outcome === "failure" ? "tool-failure" : VERIFICATION_RE.test(text) ? "verification" : "tool-success",
+                kind: outcome === "failure" ? "tool-failure" : "tool-success",
                 subject: evidenceSubject(call, text), operation: operationName(call), outcome,
                 excerpt: boundedExcerpt(`${callText}[result] ${text}`),
             });
@@ -211,7 +220,7 @@ export function buildKnowledgeEvidence(entries) {
         if (role === "assistant" && text && (FAILURE_RE.test(text) || VERIFICATION_RE.test(text) || REVERSAL_RE.test(text))) {
             evidence.push({
                 id: evidenceId(entryId, "assistant"), entryId, timestamp,
-                kind: VERIFICATION_RE.test(text) ? "verification" : "assistant-claim",
+                kind: "assistant-claim",
                 subject: "Assistant diagnosis or conclusion", outcome: "unknown", excerpt: boundedExcerpt(text, 800),
             });
         }

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:
@@ -13,9 +14,11 @@ Treat failed, unsupported, invalid, or corrected operations as negative evidence
 Use storageHint "rule" only for one short imperative instruction of at most 240 characters. A rule must not contain incident narration, example resource names, IDs, timestamps, or evidence details. Use "topic" for multi-step SOPs and detailed experience.
 Rank knowledge by future time saved, repeated failures, hypothesis reversals, user corrections, verified resolution, reuse, and novelty. Do not favor the final task result merely because it completed the objective. Every supplied episode scoring 45 or higher must have an episodeDecisions entry, even when skipped.
 Relevant existing knowledge may be supplied. Cheap recall only proposes related items; it does not prove duplication. Compare execution environment, symptom, and root cause. Use action "reinforce" only when the exact target already covers every claim and there is no new content. Use "extend" for new compatible claims, "correct" when direct evidence disproves old content, "retire" when the whole target is invalid, and "add" for a distinct environment or root cause. Never turn lexical similarity into reinforcement.
+Prefer the most specific existing topic that already covers a claim over a broad conventions or SOP topic.
 Scope may be "global" only for an explicit user directive intended across projects; otherwise use "project".
 The prior validation context is only for checking facts and contradictions; do not persist it again unless the new delta independently reinforces it. Prefer accumulated workflow successfulSteps and failedApproaches over assistant narration.
 Every technical claim must have a stable claim key and cite evidenceIds from the supplied evidence ledger. Tool success, tool failure, and verification evidence outrank assistant narration. Do not support a service-wide or universal claim with one operation-specific failure. Evidence for an unrelated parameter error cannot support an API-version claim.
+Keep each candidate atomic: put separable claim sets in separate candidates, omit any claim without direct cited evidence, and prioritize the highest-value supported candidates. One unsupported claim rejects its entire candidate.
 Each summary must be one complete sentence of at most 160 characters. Keep each topic body under 2200 characters. Escape line breaks and quotes inside JSON strings. Set durability to "stable" only after removing facts likely to change or be cheaply rediscovered. Return at most 3 candidates.
 The body must not repeat the title as a Markdown H1. The storage renderer supplies the H1. Replace any necessary example resource value with an obvious placeholder instead of a real project, namespace, image, network, or resource name.
 Return: {"episodeDecisions":[{"episodeId":"ep-id","decision":"add|reinforce|extend|correct|retire|skip","targetId":"existing-id or omitted","reason":"..."}],"candidates":[{"key":"stable semantic key","identityKey":"platform/runtime/problem/root-cause","targetId":"existing-id or null","episodeIds":["ep-id"],"title":"...","summary":"one complete sentence","keywords":["..."],"scope":"global|project","body":"markdown body or only the new section for extend","claims":[{"key":"stable claim key","text":"one precise claim","evidenceIds":["ev-id"]}],"evidenceIds":["ev-id"],"confidence":0.0,"storageHint":"rule|topic","action":"add|reinforce|extend|correct|retire","explicitUserDirective":false,"durability":"stable"}]}
@@ -37,117 +40,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

@@ -30,14 +30,18 @@ export const KNOWLEDGE_RUNTIME_DEFAULTS = Object.freeze({
         intervalMs: 60_000,
         idleMs: 60_000,
         capabilityPollMs: 5_000,
+        requestTimeoutMs: 45_000,
         modelTimeoutMs: 180_000,
+        maxOutputTokens: 4_096,
+        maxAttempts: 2,
+        maxFailureDetailChars: 4_000,
         maxDeltaChars: 12_000,
         maxPriorContextChars: 4_000,
         maxNarrativeChars: 6_000,
         maxEvidenceItems: 24,
         maxEvidenceChars: 12_000,
         mandatoryEpisodeScore: 45,
-        maxExistingContextItems: 5,
+        maxExistingContextItems: 8,
         maxExistingBodyItems: 2,
         maxExistingBodyChars: 600,
         maxCandidates: 3,