@hadooppei/hwcode 1.0.10 → 1.0.12

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

@@ -7,13 +7,26 @@ Persist only knowledge that is likely to be useful in future sessions:
 - verified engineering rules, successful procedures, or expensive failed approaches;
 - reusable architecture, testing, debugging, deployment, or operational knowledge.
 Do not persist task summaries, guesses, temporary IDs, credentials, secrets, private data, or facts recoverable by simply reading the repository.
-Use storageHint "rule" only for short, precise, high-value instructions. Use "topic" for multi-step SOPs and detailed experience.
-Use action "revise" only when the delta explicitly corrects prior knowledge; otherwise use "add" or "reinforce".
+Do not persist mutable inventory such as current cloud resources, names, availability, status, timestamps, or account snapshots. Preserve the discovery method or selection rule instead. If useful procedure is mixed with volatile facts, remove the volatile facts.
+Treat failed, unsupported, invalid, or corrected operations as negative evidence. Never present an operation as valid when the supplied evidence says it failed; use only a verified alternative or record an explicit warning. Never invent commands or parameters absent from successful 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.
+Relevant existing knowledge may be supplied. If a candidate has the same intent as an existing item, do not add a translated, renamed, or reformatted duplicate. Set targetId to that exact existing ID and action to "reinforce" when the existing content remains correct, or "revise" only when the delta explicitly proves a correction. Use targetId null only for genuinely new knowledge.
 Scope may be "global" only for an explicit user directive intended across projects; otherwise use "project".
-Return: {"candidates":[{"key":"stable semantic key","title":"...","summary":"...","keywords":["..."],"scope":"global|project","body":"markdown body","evidence":["verified evidence"],"confidence":0.0,"storageHint":"rule|topic","action":"add|reinforce|revise","explicitUserDirective":false}]}
+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.
+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.
+Return: {"candidates":[{"key":"stable semantic key","targetId":"existing-id or null","title":"...","summary":"one complete sentence","keywords":["..."],"scope":"global|project","body":"markdown body","evidence":["verified evidence"],"confidence":0.0,"storageHint":"rule|topic","action":"add|reinforce|revise","explicitUserDirective":false,"durability":"stable"}]}
 Return {"candidates":[]} when nothing meets the threshold.`;
-export function buildKnowledgeExtractionPrompt(projectRoot, delta) {
-    return `Project root: ${projectRoot}\n\n<conversation_delta>\n${delta}\n</conversation_delta>`;
+export function buildKnowledgeExtractionPrompt(projectRoot, delta, context = "", existing = []) {
+    const related = existing.length > 0 ? JSON.stringify(existing) : "[]";
+    return [
+        `Project root: ${projectRoot}`,
+        "",
+        "<relevant_existing_knowledge>", related, "</relevant_existing_knowledge>",
+        "",
+        "<prior_validation_context>", context, "</prior_validation_context>",
+        "",
+        "<conversation_delta>", delta, "</conversation_delta>",
+    ].join("\n");
 }
 export function parseCandidateEnvelope(text) {
     const trimmed = text.trim();
@@ -22,10 +35,78 @@ export function parseCandidateEnvelope(text) {
     const end = unfenced.lastIndexOf("}");
     if (start < 0 || end <= start)
         throw new Error("Knowledge reviewer did not return a JSON object");
-    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);
+    let strictError;
+    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);
+    }
+    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;
+    }
+    return -1;
 }
 export function knowledgeDeltaDigest(delta) {
     return createHash("sha256").update(delta).digest("hex");

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

@@ -0,0 +1,20 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { userRuntimePaths } from "../runtime/paths.js";
+export function writeKnowledgeReviewStatus(status, home) {
+    const path = userRuntimePaths(home).knowledgeStatus;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(status, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    renameSync(temporary, path);
+    chmodSync(path, 0o600);
+}
+export function readKnowledgeReviewStatus(home) {
+    try {
+        const parsed = JSON.parse(readFileSync(userRuntimePaths(home).knowledgeStatus, "utf8"));
+        return parsed.version === 1 && parsed.protocolVersion === 3 ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -6,6 +6,8 @@ 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 { sanitizeKnowledgeText } from "./sanitize.js";
 import { findNextReviewTask } from "./session-scanner.js";
 import { commitKnowledgeReview, ensureKnowledgeDirectories, loadCurrentManifest } from "./store.js";
 if (!parentPort)
@@ -21,6 +23,11 @@ let leaderToken = "";
 let standbySocket;
 let electionPending = false;
 let activeTask;
+let activeAttempt = 0;
+let activeStartedAt = 0;
+let activeDeadlineTimer;
+let reviewStatus;
+const reviewAttempts = new Map();
 function send(message) {
     parentPort.postMessage(message);
 }
@@ -29,12 +36,74 @@ function coordinatorPath() {
         ? `\\\\.\\pipe\\hwcode-knowledge-v3-${Buffer.from(home).toString("hex").slice(0, 16)}`
         : paths.knowledgeCoordinatorSocket;
 }
-function writeLeaderMetadata() {
+function writeLeaderMetadata(electedAt) {
     writeFileSync(paths.knowledgeLeader, `${JSON.stringify({
-        protocolVersion: 3, leaderToken, pid: process.pid, electedAt: new Date().toISOString(),
+        protocolVersion: 3, leaderToken, pid: process.pid, electedAt,
     }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
     chmodSync(paths.knowledgeLeader, 0o600);
 }
+function publishReviewStatus() {
+    if (!reviewStatus)
+        return;
+    reviewStatus.updatedAt = new Date().toISOString();
+    try {
+        writeKnowledgeReviewStatus(reviewStatus, home);
+    }
+    catch (error) {
+        send({ type: "review_failed", error: `Unable to write knowledge status: ${error instanceof Error ? error.message : String(error)}` });
+    }
+}
+function boundedError(error) {
+    return sanitizeKnowledgeText(error instanceof Error ? error.message : String(error)).slice(0, 1_000);
+}
+function beginReview(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 });
+        activeTask = undefined;
+        send({ type: "review_cancel", requestId: task.requestId, reason: error });
+        send({ type: "review_failed", requestId: task.requestId, error });
+    }, KNOWLEDGE_RUNTIME_DEFAULTS.review.modelTimeoutMs + 5_000);
+    activeDeadlineTimer.unref();
+    if (reviewStatus) {
+        reviewStatus.activeReview = {
+            reviewKey: task.reviewKey,
+            sessionKey: task.sessionKey,
+            sessionFileHash: task.sessionFileHash,
+            projectKey: task.projectKey,
+            attempt: activeAttempt,
+            startedAt: new Date(activeStartedAt).toISOString(),
+        };
+        publishReviewStatus();
+    }
+}
+function finishReview(task, outcome, detail) {
+    clearTimeout(activeDeadlineTimer);
+    activeDeadlineTimer = undefined;
+    if (!reviewStatus)
+        return;
+    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),
+        generationId: detail.generationId,
+        result: detail.result,
+        error: detail.error === undefined ? undefined : boundedError(detail.error),
+    };
+    if (outcome === "saved")
+        reviewAttempts.delete(task.reviewKey);
+    publishReviewStatus();
+}
 function removeLeaderMetadata(token) {
     try {
         const current = JSON.parse(readFileSync(paths.knowledgeLeader, "utf8"));
@@ -63,7 +132,17 @@ function scheduleElection(delay = Math.floor(Math.random() * 500)) {
 function stepDown(reason) {
     if (activeTask)
         send({ type: "review_cancel", requestId: activeTask.requestId, reason });
+    if (reviewStatus) {
+        reviewStatus.state = "stepped-down";
+        reviewStatus.stepDownReason = reason;
+        reviewStatus.activeReview = undefined;
+        publishReviewStatus();
+    }
     activeTask = undefined;
+    clearTimeout(activeDeadlineTimer);
+    activeDeadlineTimer = undefined;
+    activeAttempt = 0;
+    activeStartedAt = 0;
     const token = leaderToken;
     leaderToken = "";
     for (const socket of standbySockets)
@@ -85,6 +164,7 @@ function stepDown(reason) {
     }
     if (token)
         removeLeaderMetadata(token);
+    reviewStatus = undefined;
 }
 function becomeStandby(socket) {
     standbySocket = socket;
@@ -162,6 +242,7 @@ function connectToLeader(probe = 0) {
 function becomeLeader(server) {
     leaderServer = server;
     leaderToken = randomUUID();
+    const electedAt = new Date().toISOString();
     server.unref();
     server.on("connection", (socket) => {
         standbySockets.add(socket);
@@ -176,7 +257,11 @@ function becomeLeader(server) {
         stepDown("coordinator-server-failed");
         scheduleElection();
     });
-    writeLeaderMetadata();
+    writeLeaderMetadata(electedAt);
+    reviewStatus = {
+        version: 1, protocolVersion: 3, state: "leader", pid: process.pid, leaderToken, electedAt, updatedAt: electedAt,
+    };
+    publishReviewStatus();
     send({ type: "leadership", state: "leader", leaderToken });
     void scanForReview();
 }
@@ -204,15 +289,22 @@ function attemptElection() {
 async function scanForReview() {
     if (!leaderServer || !leaderToken || activeTask || !sessionsRoot || !eligible)
         return;
+    if (reviewStatus) {
+        reviewStatus.lastScanAt = new Date().toISOString();
+        reviewStatus.lastScanError = undefined;
+        publishReviewStatus();
+    }
     try {
         const manifest = loadCurrentManifest(home);
         const task = findNextReviewTask(sessionsRoot, manifest.reviews);
         if (!task)
             return;
         activeTask = task;
+        beginReview(task);
         if (!task.delta) {
             const result = commitKnowledgeReview([], task, leaderToken, home);
             const generationId = loadCurrentManifest(home).generationId;
+            finishReview(task, "saved", { generationId, result });
             send({ type: "review_saved", requestId: task.requestId, generationId, result });
             if (generationId) {
                 send({ type: "generation_changed", generationId });
@@ -225,8 +317,14 @@ async function scanForReview() {
         send({ type: "review_request", leaderToken, requestId: task.requestId, task });
     }
     catch (error) {
+        if (activeTask)
+            finishReview(activeTask, "failed", { error });
+        else if (reviewStatus) {
+            reviewStatus.lastScanError = { at: new Date().toISOString(), error: boundedError(error) };
+            publishReviewStatus();
+        }
         activeTask = undefined;
-        send({ type: "review_failed", error: error instanceof Error ? error.message : String(error) });
+        send({ type: "review_failed", error: boundedError(error) });
     }
 }
 function handleReviewResult(message) {
@@ -239,6 +337,7 @@ function handleReviewResult(message) {
             throw new Error(message.error || "Knowledge review returned no content");
         const result = commitKnowledgeReview(parseCandidateEnvelope(message.raw), task, leaderToken, home);
         const generationId = loadCurrentManifest(home).generationId;
+        finishReview(task, "saved", { generationId, result });
         send({ type: "review_saved", requestId: task.requestId, generationId, result });
         if (generationId) {
             send({ type: "generation_changed", generationId });
@@ -247,7 +346,8 @@ function handleReviewResult(message) {
         committed = true;
     }
     catch (error) {
-        send({ type: "review_failed", requestId: task.requestId, error: error instanceof Error ? error.message : String(error) });
+        finishReview(task, "failed", { error });
+        send({ type: "review_failed", requestId: task.requestId, error: boundedError(error) });
     }
     finally {
         activeTask = undefined;

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

@@ -22,3 +22,23 @@ export function compactKnowledgeText(value, maxChars) {
         .trim()
         .slice(0, maxChars);
 }
+export function compactKnowledgeSummary(value, maxChars) {
+    const normalized = sanitizeKnowledgeText(value).replace(/\s+/gu, " ").trim();
+    if (normalized.length <= maxChars || maxChars <= 0)
+        return normalized.slice(0, Math.max(0, maxChars));
+    if (maxChars === 1)
+        return "…";
+    const limit = maxChars - 1;
+    const prefix = normalized.slice(0, limit);
+    const minimumBoundary = Math.floor(limit * 0.6);
+    const sentenceEnd = Math.max(prefix.lastIndexOf("。"), prefix.lastIndexOf("！"), prefix.lastIndexOf("？"), prefix.lastIndexOf("."), prefix.lastIndexOf("!"), prefix.lastIndexOf("?"));
+    if (sentenceEnd >= minimumBoundary)
+        return prefix.slice(0, sentenceEnd + 1).trimEnd();
+    const next = normalized.charAt(limit);
+    if (/[A-Za-z0-9]/u.test(prefix.at(-1) ?? "") && /[A-Za-z0-9]/u.test(next)) {
+        const wordBoundary = Math.max(prefix.lastIndexOf(" "), prefix.lastIndexOf("-"), prefix.lastIndexOf("/"));
+        if (wordBoundary >= minimumBoundary)
+            return `${prefix.slice(0, wordBoundary).trimEnd()}…`;
+    }
+    return `${prefix.trimEnd()}…`;
+}

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

@@ -6,6 +6,8 @@ import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.js";
 import { knowledgeDeltaDigest } from "./extractor.js";
 import { sanitizeKnowledgeText } 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;
 function hash(value, length = 64) {
     return createHash("sha256").update(value).digest("hex").slice(0, length);
 }
@@ -23,11 +25,11 @@ function textContent(content) {
 }
 function reviewPiece(entry, index) {
     if (entry.type === "compaction" || entry.type === "branch_summary") {
-        return { index, priority: 1, category: "summary", text: `[summary]\n${sanitizeKnowledgeText(entry.summary).slice(0, 6_000)}` };
+        return { index, priority: 2, category: "summary", text: `[summary]\n${sanitizeKnowledgeText(entry.summary).slice(0, 6_000)}` };
     }
     if (entry.type === "custom" && entry.customType.startsWith("hwcode-workflow")) {
         return {
-            index, priority: 0, category: "workflow",
+            index, priority: 1, category: "workflow",
             text: `[workflow_state:${entry.customType}]\n${sanitizeKnowledgeText(JSON.stringify(entry.data ?? {})).slice(0, 6_000)}`,
         };
     }
@@ -35,10 +37,11 @@ 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));
+    const content = sanitizeKnowledgeText(textContent(message.content).replace(INJECTED_SKILL_RE, "[loaded skill omitted]"));
     if (!content)
         return undefined;
-    const priority = role === "user" ? 0 : role === "toolResult" ? 3 : 2;
+    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)}` };
@@ -50,16 +53,49 @@ function buildDelta(entries) {
         user: 14_000, workflow: 6_000, summary: 4_000, assistant: 8_000, tool: 4_000,
     };
     let remaining = KNOWLEDGE_RUNTIME_DEFAULTS.review.maxDeltaChars;
-    for (const piece of pieces.slice().sort((left, right) => left.priority - right.priority || left.index - right.index)) {
+    for (const piece of pieces.slice().sort((left, right) => {
+        if (left.priority !== right.priority)
+            return left.priority - right.priority;
+        if (left.category === right.category && left.category !== "user")
+            return right.index - left.index;
+        return left.index - right.index;
+    })) {
         if (remaining <= 0)
             break;
-        const text = piece.text.slice(0, Math.min(remaining, categoryRemaining[piece.category]));
+        const separatorCharacters = selected.length > 0 ? 2 : 0;
+        if (remaining <= separatorCharacters)
+            break;
+        const text = piece.text.slice(0, Math.min(remaining - separatorCharacters, categoryRemaining[piece.category]));
         if (text)
             selected.push({ ...piece, text });
-        remaining -= text.length;
+        remaining -= text.length + separatorCharacters;
         categoryRemaining[piece.category] -= text.length;
     }
-    return selected.sort((left, right) => left.index - right.index).map((piece) => piece.text).join("\n\n");
+    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));
+    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)));
+    if (latestWorkflow && !evidence.includes(latestWorkflow))
+        evidence.push(latestWorkflow);
+    let remaining = KNOWLEDGE_RUNTIME_DEFAULTS.review.maxPriorContextChars;
+    const selected = [];
+    for (const piece of evidence.slice().sort((left, right) => right.index - left.index)) {
+        if (remaining <= 0)
+            break;
+        const separatorCharacters = selected.length > 0 ? 2 : 0;
+        if (remaining <= separatorCharacters)
+            break;
+        const text = piece.text.slice(0, remaining - separatorCharacters);
+        if (text)
+            selected.push({ ...piece, text });
+        remaining -= text.length + separatorCharacters;
+    }
+    return selected.sort((left, right) => left.index - right.index).map((piece) => piece.text).join("\n\n")
+        .slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxPriorContextChars);
 }
 function projectRootForSession(header, branch) {
     for (const entry of branch.slice().reverse()) {
@@ -128,6 +164,7 @@ export function readReviewTask(sessionFile, cursor, now = Date.now()) {
     if (pending.length === 0)
         return undefined;
     const delta = buildDelta(pending);
+    const context = cursorIndex >= 0 ? buildValidationContext(branch.slice(0, cursorIndex + 1)) : "";
     const firstEntryId = pending[0].id;
     const lastEntryId = pending[pending.length - 1].id;
     const deltaDigest = knowledgeDeltaDigest(delta || `${firstEntryId}\0${lastEntryId}`);
@@ -138,7 +175,7 @@ export function readReviewTask(sessionFile, cursor, now = Date.now()) {
     return {
         requestId: randomUUID(), reviewKey, sessionId: header.id, sessionKey, sessionFileHash,
         projectRoot, projectKey: projectKnowledgeKey(projectRoot),
-        firstEntryId, lastEntryId, delta, deltaDigest, fileSize: stat.size, fileMtimeMs: stat.mtimeMs,
+        firstEntryId, lastEntryId, context, delta, deltaDigest, fileSize: stat.size, fileMtimeMs: stat.mtimeMs,
     };
 }
 export function findNextReviewTask(sessionsRoot, reviews, now = Date.now()) {

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

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.js";
 import { userRuntimePaths } from "../runtime/paths.js";
-import { compactKnowledgeText, sanitizeKnowledgeText } from "./sanitize.js";
+import { compactKnowledgeSummary, compactKnowledgeText, sanitizeKnowledgeText } from "./sanitize.js";
 const STORAGE = KNOWLEDGE_RUNTIME_DEFAULTS.storage;
 const SAFE_ID_RE = /^[a-z0-9][a-z0-9-]{0,79}$/u;
 const SAFE_GENERATION_RE = /^[0-9TZ-]+-[a-f0-9]{12}$/u;
@@ -101,6 +101,57 @@ function normalizeSlug(value) {
 function normalizedFingerprint(candidate) {
     return createHash("sha256").update(`${candidate.scope}\0${candidate.key.trim().toLowerCase()}`).digest("hex");
 }
+function comparisonTerms(value) {
+    return new Set((value.normalize("NFKC").toLowerCase().match(/\p{Script=Han}+|[\p{L}\p{N}]+/gu) ?? [])
+        .filter((term) => term.length >= 2));
+}
+function containment(left, right) {
+    const minimum = Math.min(left.size, right.size);
+    if (minimum === 0)
+        return 0;
+    let shared = 0;
+    for (const term of left)
+        if (right.has(term))
+            shared++;
+    return shared / minimum;
+}
+function semanticDuplicateScore(candidate, entry) {
+    if (candidate.scope !== entry.scope || candidate.storageHint !== entry.track)
+        return 0;
+    const titleScore = containment(comparisonTerms(candidate.title), comparisonTerms(entry.title));
+    const keywordScore = containment(comparisonTerms(candidate.keywords.join(" ")), comparisonTerms(entry.keywords.join(" ")));
+    if (titleScore < 0.8 || keywordScore < 0.5)
+        return 0;
+    return titleScore * 0.7 + keywordScore * 0.3;
+}
+function semanticDuplicateIndex(candidate, catalog) {
+    let bestIndex = -1;
+    let bestScore = 0;
+    for (const [index, entry] of catalog.items.entries()) {
+        const score = semanticDuplicateScore(candidate, entry);
+        if (score > bestScore) {
+            bestIndex = index;
+            bestScore = score;
+        }
+    }
+    return bestIndex;
+}
+function unsupportedOperations(value) {
+    return [...value.matchAll(/\bOperation\s+([A-Za-z][A-Za-z0-9]+)\s+is not supported\b/gu)]
+        .map((match) => match[1].toLowerCase());
+}
+function contradictsVerifiedFailures(body, validationText) {
+    const normalizedBody = body.toLowerCase();
+    for (const operation of unsupportedOperations(validationText)) {
+        const index = normalizedBody.search(new RegExp(`\\b${operation}\\b`, "u"));
+        if (index < 0)
+            continue;
+        const context = normalizedBody.slice(Math.max(0, index - 80), index + operation.length + 80);
+        if (!/(?:not supported|unsupported|do not|don't|avoid|不支持|不要|避免)/u.test(context))
+            return true;
+    }
+    return false;
+}
 function contentHash(candidate) {
     return createHash("sha256").update(`${candidate.title}\0${candidate.summary}\0${candidate.body}`).digest("hex");
 }
@@ -110,13 +161,15 @@ function asStringArray(value, maxItems) {
     return [...new Set(value.filter((item) => typeof item === "string")
             .map((item) => compactKnowledgeText(item, 240)).filter(Boolean))].slice(0, maxItems);
 }
-function normalizeCandidate(value, projectKey) {
+function normalizeCandidate(value, projectKey, validationText) {
     if (!value || typeof value !== "object")
         return undefined;
     const raw = value;
     if (typeof raw.key !== "string" || typeof raw.title !== "string" || typeof raw.summary !== "string"
         || typeof raw.body !== "string" || typeof raw.confidence !== "number")
         return undefined;
+    if (raw.durability !== "stable")
+        return undefined;
     if (raw.confidence < KNOWLEDGE_RUNTIME_DEFAULTS.review.minimumConfidence)
         return undefined;
     const explicitUserDirective = raw.explicitUserDirective === true;
@@ -125,17 +178,22 @@ function normalizeCandidate(value, projectKey) {
     const evidence = asStringArray(raw.evidence, 8);
     if (!body || evidence.length === 0)
         return undefined;
+    if (contradictsVerifiedFailures(body, validationText))
+        return undefined;
     const requestedTrack = raw.storageHint === "rule" ? "rule" : "topic";
     const ruleEligible = body.length <= STORAGE.maxRuleChars && body.split("\n").length <= STORAGE.maxRuleFileLines
+        && body.split(/\n\s*\n/gu).length === 1
         && (explicitUserDirective || raw.confidence >= 0.9);
+    const targetId = typeof raw.targetId === "string" && SAFE_ID_RE.test(raw.targetId) ? raw.targetId : undefined;
     return {
-        key: compactKnowledgeText(raw.key, 160), title: compactKnowledgeText(raw.title, STORAGE.maxTitleChars),
-        summary: compactKnowledgeText(raw.summary, STORAGE.maxSummaryChars),
+        key: compactKnowledgeText(raw.key, 160), targetId,
+        title: compactKnowledgeText(raw.title, STORAGE.maxTitleChars),
+        summary: compactKnowledgeSummary(raw.summary, STORAGE.maxSummaryChars),
         keywords: asStringArray(raw.keywords, STORAGE.maxKeywordCount).map((keyword) => keyword.toLowerCase()),
         scope, body, evidence, confidence: Math.min(1, raw.confidence),
         storageHint: requestedTrack === "rule" && ruleEligible ? "rule" : "topic",
         action: raw.action === "revise" ? "revise" : raw.action === "reinforce" ? "reinforce" : "add",
-        explicitUserDirective,
+        explicitUserDirective, durability: "stable",
     };
 }
 function renderKnowledgeFile(candidate) {
@@ -267,16 +325,30 @@ export function commitKnowledgeReview(values, task, leaderToken, home = homedir(
         const catalog = structuredClone(current.catalog);
         const result = { saved: 0, updated: 0, pending: 0, skipped: 0 };
         for (const value of values.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates)) {
-            const candidate = normalizeCandidate(value, task.projectKey);
+            const candidate = normalizeCandidate(value, task.projectKey, `${task.context ?? ""}\n${task.delta}`);
             if (!candidate) {
                 result.skipped++;
                 continue;
             }
             const fingerprint = normalizedFingerprint(candidate);
             const hash = contentHash(candidate);
-            const existingIndex = catalog.items.findIndex((item) => item.fingerprint === fingerprint);
+            const targetIndex = candidate.targetId
+                ? catalog.items.findIndex((item) => item.id === candidate.targetId && applicable(item, task.projectKey))
+                : -1;
+            if (candidate.targetId && targetIndex < 0) {
+                result.skipped++;
+                continue;
+            }
+            let existingIndex = targetIndex >= 0
+                ? targetIndex
+                : catalog.items.findIndex((item) => item.fingerprint === fingerprint);
+            let semanticReinforcement = false;
+            if (existingIndex < 0) {
+                existingIndex = semanticDuplicateIndex(candidate, catalog);
+                semanticReinforcement = existingIndex >= 0;
+            }
             const existing = existingIndex >= 0 ? catalog.items[existingIndex] : undefined;
-            if (existing?.contentHash === hash) {
+            if (existing && (existing.contentHash === hash || candidate.action === "reinforce" || semanticReinforcement)) {
                 existing.evidenceCount += candidate.evidence.length;
                 existing.updatedAt = new Date().toISOString();
                 result.updated++;
@@ -299,8 +371,9 @@ export function commitKnowledgeReview(values, task, leaderToken, home = homedir(
             const relativeFile = `${track === "rule" ? "rules" : "topics"}/${id}.md`;
             atomicWrite(join(temporary, relativeFile), renderKnowledgeFile(candidate));
             const entry = {
-                id, fingerprint, contentHash: hash, title: candidate.title, summary: candidate.summary,
-                keywords: candidate.keywords, scope: candidate.scope, track, file: relativeFile,
+                id, fingerprint: existing?.fingerprint ?? fingerprint, contentHash: hash,
+                title: candidate.title, summary: candidate.summary,
+                keywords: candidate.keywords, scope: existing?.scope ?? candidate.scope, track, file: relativeFile,
                 evidenceCount: (existing?.evidenceCount ?? 0) + candidate.evidence.length,
                 createdAt: existing?.createdAt ?? now, updatedAt: now,
             };

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,
-        modelTimeoutMs: 120_000,
-        maxDeltaChars: 30_000,
-        maxCandidates: 8,
+        modelTimeoutMs: 180_000,
+        maxDeltaChars: 12_000,
+        maxPriorContextChars: 4_000,
+        maxExistingContextItems: 5,
+        maxExistingBodyItems: 2,
+        maxExistingBodyChars: 600,
+        maxCandidates: 3,
         minimumConfidence: 0.72,
     }),
     storage: Object.freeze({
-        maxRuleChars: 600,
-        maxRuleFileLines: 40,
+        maxRuleChars: 320,
+        maxRuleFileLines: 6,
         maxRulesPromptChars: 12_000,
         maxMemoryChars: 25_000,
         maxMemoryLines: 200,

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

@@ -40,6 +40,7 @@ export function userRuntimePaths(home = homedir()) {
         // Unix-domain socket paths are short on purpose (macOS caps them at roughly 104 bytes).
         knowledgeCoordinatorSocket: join(root, "knowledge-v3.sock"),
         knowledgeLeader: join(knowledge, "runtime", "leader.json"),
+        knowledgeStatus: join(knowledge, "runtime", "status.json"),
         knowledgeCommitLock: join(knowledge, "runtime", "commit.lock"),
         knowledgeElectionLock: join(knowledge, "runtime", "election.lock"),
     };