@hadooppei/hwcode 1.0.11 → 1.0.13

package/.pi/lib/knowledge/store.ts

@@ -11,7 +11,8 @@ import { userRuntimePaths } from "../runtime/paths.ts";
 import { compactKnowledgeSummary, compactKnowledgeText, sanitizeKnowledgeText } from "./sanitize.ts";
 import type {
   KnowledgeCandidate, KnowledgeCatalog, KnowledgeCatalogEntry, KnowledgeManifest, KnowledgeReviewCursor,
-  KnowledgeReviewTask, KnowledgeScope, KnowledgeSnapshot, KnowledgeTrack, PersistKnowledgeResult,
+  KnowledgeReviewTask, KnowledgeScope, KnowledgeSkipReason, KnowledgeSnapshot, KnowledgeTrack,
+  PersistKnowledgeResult,
 } from "./types.ts";
 
 const STORAGE = KNOWLEDGE_RUNTIME_DEFAULTS.storage;
@@ -117,6 +118,67 @@ function normalizedFingerprint(candidate: KnowledgeCandidate): string {
   return createHash("sha256").update(`${candidate.scope}\0${candidate.key.trim().toLowerCase()}`).digest("hex");
 }
 
+function comparisonTerms(value: string): Set<string> {
+  return new Set((value.normalize("NFKC").toLowerCase().match(/\p{Script=Han}+|[\p{L}\p{N}]+/gu) ?? [])
+    .filter((term) => term.length >= 2));
+}
+
+function containment(left: Set<string>, right: Set<string>): number {
+  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: KnowledgeCandidate, entry: KnowledgeCatalogEntry): number {
+  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: KnowledgeCandidate, catalog: KnowledgeCatalog): number {
+  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;
+}
+
+interface UnsupportedOperation {
+  operation: string;
+  service?: string;
+}
+
+function unsupportedOperations(value: string): UnsupportedOperation[] {
+  return [...value.matchAll(/\bOperation\s+([A-Za-z][A-Za-z0-9]+)\s+is not supported\b/gu)].map((match) => {
+    const suffix = value.slice(match.index + match[0].length, match.index + match[0].length + 500);
+    const service = /\bhcloud\s+([A-Za-z][A-Za-z0-9-]*)\s+--help\b/iu.exec(suffix)?.[1]?.toLowerCase();
+    return { operation: match[1]!.toLowerCase(), service };
+  });
+}
+
+function contradictsVerifiedFailures(body: string, validationText: string): boolean {
+  const normalizedBody = body.toLowerCase();
+  for (const unsupported of unsupportedOperations(validationText)) {
+    const operationExpression = unsupported.service
+      ? new RegExp(`\\b(?:hcloud\\s+)?${unsupported.service}\\b[^\\n]{0,120}\\b${unsupported.operation}\\b`, "u")
+      : new RegExp(`\\b${unsupported.operation}\\b`, "u");
+    const index = normalizedBody.search(operationExpression);
+    if (index < 0) continue;
+    const context = normalizedBody.slice(Math.max(0, index - 80), index + 240);
+    if (!/(?:not supported|unsupported|do not|don't|avoid|不支持|不要|避免)/u.test(context)) return true;
+  }
+  return false;
+}
+
 function contentHash(candidate: KnowledgeCandidate): string {
   return createHash("sha256").update(`${candidate.title}\0${candidate.summary}\0${candidate.body}`).digest("hex");
 }
@@ -127,30 +189,52 @@ function asStringArray(value: unknown, maxItems: number): string[] {
     .map((item) => compactKnowledgeText(item, 240)).filter(Boolean))].slice(0, maxItems);
 }
 
-function normalizeCandidate(value: unknown, projectKey: string): KnowledgeCandidate | undefined {
-  if (!value || typeof value !== "object") return undefined;
+type CandidateNormalization = { candidate: KnowledgeCandidate } | { reason: KnowledgeSkipReason };
+
+function normalizeCandidate(value: unknown, projectKey: string, validationText: string): CandidateNormalization {
+  if (!value || typeof value !== "object") return { reason: "invalid-schema" };
   const raw = value as Record<string, unknown>;
   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;
+    || typeof raw.body !== "string" || typeof raw.confidence !== "number") return { reason: "invalid-schema" };
+  if (raw.durability !== "stable") return { reason: "unstable" };
+  if (raw.confidence < KNOWLEDGE_RUNTIME_DEFAULTS.review.minimumConfidence) return { reason: "low-confidence" };
+  if (raw.targetId !== undefined && raw.targetId !== null
+    && (typeof raw.targetId !== "string" || !SAFE_ID_RE.test(raw.targetId))) return { reason: "unknown-target" };
   const explicitUserDirective = raw.explicitUserDirective === true;
   const scope: KnowledgeScope = raw.scope === "global" && explicitUserDirective ? "global" : `project:${projectKey}`;
   const body = compactKnowledgeText(raw.body, 20_000);
   const evidence = asStringArray(raw.evidence, 8);
-  if (!body || evidence.length === 0) return undefined;
+  if (!body || evidence.length === 0) return { reason: "missing-body-or-evidence" };
+  if (contradictsVerifiedFailures(body, validationText)) return { reason: "contradicts-verified-failure" };
   const requestedTrack: KnowledgeTrack = 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);
-  return {
-    key: compactKnowledgeText(raw.key, 160), title: compactKnowledgeText(raw.title, STORAGE.maxTitleChars),
+  const targetId = typeof raw.targetId === "string" && SAFE_ID_RE.test(raw.targetId) ? raw.targetId : undefined;
+  return { candidate: {
+    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, durability: "stable",
-  };
+  } };
+}
+
+function recordSkip(result: PersistKnowledgeResult, reason: KnowledgeSkipReason): void {
+  result.skipped++;
+  result.skippedReasons ??= {};
+  result.skippedReasons[reason] = (result.skippedReasons[reason] ?? 0) + 1;
+}
+
+function writeRejectedPending(directory: string, reason: KnowledgeSkipReason, value: unknown): void {
+  let serialized: string;
+  try { serialized = JSON.stringify(value); } catch { serialized = String(value); }
+  const candidate = sanitizeKnowledgeText(serialized).slice(0, 10_000);
+  const name = `${Date.now()}-rejected-${reason}-${randomUUID().slice(0, 8)}.json`;
+  atomicWrite(join(directory, "pending", name), `${JSON.stringify({ reason, candidate }, null, 2)}\n`);
 }
 
 function renderKnowledgeFile(candidate: KnowledgeCandidate): string {
@@ -274,14 +358,35 @@ export function commitKnowledgeReview(
     copyCurrentContent(current, temporary, home);
     const catalog: KnowledgeCatalog = structuredClone(current.catalog);
     const result: PersistKnowledgeResult = { saved: 0, updated: 0, pending: 0, skipped: 0 };
+    const rejected: Array<{ reason: KnowledgeSkipReason; value: unknown }> = [];
     for (const value of values.slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxCandidates)) {
-      const candidate = normalizeCandidate(value, task.projectKey);
-      if (!candidate) { result.skipped++; continue; }
+      const normalized = normalizeCandidate(value, task.projectKey, `${task.context ?? ""}\n${task.delta}`);
+      if (!("candidate" in normalized)) {
+        recordSkip(result, normalized.reason);
+        rejected.push({ reason: normalized.reason, value });
+        continue;
+      }
+      const candidate = normalized.candidate;
       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) {
+        recordSkip(result, "unknown-target");
+        rejected.push({ reason: "unknown-target", value });
+        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++;
@@ -304,14 +409,19 @@ export function commitKnowledgeReview(
       const relativeFile = `${track === "rule" ? "rules" : "topics"}/${id}.md`;
       atomicWrite(join(temporary, relativeFile), renderKnowledgeFile(candidate));
       const entry: KnowledgeCatalogEntry = {
-        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,
       };
       if (existingIndex >= 0) { catalog.items[existingIndex] = entry; result.updated++; }
       else { catalog.items.push(entry); result.saved++; }
     }
+    if (result.skipped > 0 && result.saved === 0 && result.updated === 0 && result.pending === 0) {
+      for (const item of rejected) writeRejectedPending(temporary, item.reason, item.value);
+      result.pending += rejected.length;
+    }
     catalog.updatedAt = new Date().toISOString();
     const manifest: KnowledgeManifest = {
       version: 3, generationId, createdAt: new Date().toISOString(), leaderToken, catalog,

package/.pi/lib/knowledge/types.ts

@@ -5,6 +5,7 @@ export type KnowledgeDurability = "stable";
 
 export interface KnowledgeCandidate {
   key: string;
+  targetId?: string;
   title: string;
   summary: string;
   keywords: string[];
@@ -74,8 +75,17 @@ export interface PersistKnowledgeResult {
   updated: number;
   pending: number;
   skipped: number;
+  skippedReasons?: Partial<Record<KnowledgeSkipReason, number>>;
 }
 
+export type KnowledgeSkipReason =
+  | "invalid-schema"
+  | "unstable"
+  | "low-confidence"
+  | "missing-body-or-evidence"
+  | "contradicts-verified-failure"
+  | "unknown-target";
+
 export interface KnowledgeReviewTask {
   requestId: string;
   reviewKey: string;
@@ -86,6 +96,7 @@ export interface KnowledgeReviewTask {
   projectKey: string;
   firstEntryId: string;
   lastEntryId: string;
+  context?: string;
   delta: string;
   deltaDigest: string;
   fileSize: number;

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

@@ -2,6 +2,7 @@ import type { KnowledgeReviewTask, PersistKnowledgeResult } from "./types.ts";
 
 export type KnowledgeWorkerInput =
   | { type: "configure"; modelAvailable: boolean; sessionsRoot: string }
+  | { type: "review_deferred"; leaderToken: string; requestId: string; reason: string }
   | { type: "review_result"; leaderToken: string; requestId: string; raw?: string; error?: string }
   | { type: "scan_now" }
   | { type: "stop" };

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

@@ -32,13 +32,17 @@ export const KNOWLEDGE_RUNTIME_DEFAULTS = Object.freeze({
     idleMs: 60_000,
     capabilityPollMs: 5_000,
     modelTimeoutMs: 180_000,
-    maxDeltaChars: 20_000,
-    maxCandidates: 5,
+    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/lib/working-directory.ts

@@ -189,6 +189,16 @@ export function getActiveWorkflowRoot(entries: readonly SessionEntry[]): string
 	return activeWorkflow(entries)?.root;
 }
 
+export function findLatestWorkflowRoot(entries: readonly SessionEntry[]): string | undefined {
+	for (const entry of [...entries].reverse()) {
+		if (entry.type !== "custom" || entry.customType !== "hwcode-workflow-state"
+			|| !entry.data || typeof entry.data !== "object") continue;
+		const root = (entry.data as Record<string, unknown>).root;
+		if (typeof root === "string" && root) return root;
+	}
+	return undefined;
+}
+
 export function shellQuote(value: string): string {
 	return `'${value.replaceAll("'", `'"'"'`)}'`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hadooppei/hwcode",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "A customizable terminal coding agent with local-model support and HWCode workflows.",
   "type": "module",
   "bin": {