@hadooppei/hwcode 1.0.16 → 1.0.20

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

@@ -5,8 +5,8 @@ import { homedir } from "node:os";
 import { parentPort, workerData } from "node:worker_threads";
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.js";
 import { userRuntimePaths } from "../runtime/paths.js";
-import { parseCandidateEnvelope } from "./extractor.js";
-import { writeKnowledgeReviewStatus } from "./review-status.js";
+import { parseKnowledgeReviewEnvelope } from "./extractor.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) {
@@ -354,7 +430,8 @@ function handleReviewResult(message) {
     try {
         if (message.error || message.raw === undefined)
             throw new Error(message.error || "Knowledge review returned no content");
-        const result = commitKnowledgeReview(parseCandidateEnvelope(message.raw), task, leaderToken, home);
+        const envelope = parseKnowledgeReviewEnvelope(message.raw);
+        const result = commitKnowledgeReview(envelope.candidates, task, leaderToken, home, envelope.episodeDecisions);
         const generationId = loadCurrentManifest(home).generationId;
         finishReview(task, "saved", { generationId, result });
         send({ type: "review_saved", requestId: task.requestId, generationId, result });
@@ -365,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

@@ -4,11 +4,11 @@ import { resolve } from "node:path";
 import { buildContextEntries, parseSessionEntries, } from "@earendil-works/pi-coding-agent";
 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;
@@ -41,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,
@@ -78,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)));
@@ -183,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)
@@ -268,13 +310,23 @@ export function readReviewTask(sessionFile, cursor, now = Date.now()) {
     const pending = branch.slice(cursorIndex + 1);
     if (pending.length === 0)
         return undefined;
-    const delta = buildDelta(pending);
+    const pendingEntryIds = new Set(pending.map((entry) => entry.id));
+    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 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(`${delta || `${firstEntryId}\0${lastEntryId}`}\0${recallQuery}\0${loadedIds.join("\0")}`);
+    const deltaDigest = knowledgeDeltaDigest([
+        delta || `${firstEntryId}\0${lastEntryId}`, recallQuery, loadedIds.join("\0"),
+        JSON.stringify(evidence), JSON.stringify(episodes),
+    ].join("\0"));
     const sessionFileHash = hash(resolve(sessionFile), 16);
     const sessionKey = hash(header.id, 24);
     const reviewKey = hash(`${header.id}\0${firstEntryId}\0${lastEntryId}\0${deltaDigest}`);
@@ -283,10 +335,11 @@ export function readReviewTask(sessionFile, cursor, now = Date.now()) {
         requestId: randomUUID(), reviewKey, sessionId: header.id, sessionKey, sessionFileHash,
         projectRoot, projectKey: projectKnowledgeKey(projectRoot),
         firstEntryId, lastEntryId, context, delta, recallQuery, loadedKnowledgeIds: loadedIds,
+        evidence, episodes,
         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 };
@@ -303,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;