@hadooppei/hwcode 1.0.11 → 1.0.13

package/.pi/dist/lib/working-directory.js

@@ -0,0 +1,170 @@
+import { realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+import { activeWorkflow } from "./workflows/state.js";
+export const WORKING_DIRECTORY_STATE_TYPE = "hwcode-working-directory";
+const workingDirectories = new Map();
+function isWorkingDirectoryState(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const data = value;
+    return data.version === 1
+        && typeof data.cwd === "string"
+        && (data.previousCwd === undefined || typeof data.previousCwd === "string");
+}
+export function findPersistedWorkingDirectory(entries) {
+    for (const entry of [...entries].reverse()) {
+        if (entry.type !== "custom" || entry.customType !== WORKING_DIRECTORY_STATE_TYPE)
+            continue;
+        if (isWorkingDirectoryState(entry.data))
+            return entry.data;
+    }
+    return undefined;
+}
+export function canonicalizeDirectory(path) {
+    const canonical = realpathSync(path);
+    if (!statSync(canonical).isDirectory())
+        throw new Error(`Not a directory: ${path}`);
+    return canonical;
+}
+function initialState(source) {
+    const persisted = findPersistedWorkingDirectory(source.getEntries());
+    if (persisted)
+        return { ...persisted, cwd: canonicalizeDirectory(persisted.cwd) };
+    return { version: 1, cwd: canonicalizeDirectory(source.getCwd()) };
+}
+export function getWorkingDirectoryState(source) {
+    return workingDirectories.get(source.getSessionId()) ?? initialState(source);
+}
+export function getWorkingDirectory(source) {
+    return getWorkingDirectoryState(source).cwd;
+}
+export function setWorkingDirectoryState(source, state) {
+    workingDirectories.set(source.getSessionId(), state);
+}
+export function resetWorkingDirectoryState(source) {
+    const state = initialState(source);
+    setWorkingDirectoryState(source, state);
+    return state;
+}
+export function clearWorkingDirectoryState(source) {
+    workingDirectories.delete(source.getSessionId());
+}
+function expandHome(path, home) {
+    if (path === "~" || path === "$HOME" || path === "${HOME}")
+        return home;
+    if (path.startsWith("~/"))
+        return resolve(home, path.slice(2));
+    if (path.startsWith("$HOME/"))
+        return resolve(home, path.slice(6));
+    if (path.startsWith("${HOME}/"))
+        return resolve(home, path.slice(8));
+    return path;
+}
+export function resolveDirectoryArgument(base, argument, previousCwd, home = homedir()) {
+    if (argument === "-") {
+        if (!previousCwd)
+            throw new Error("No previous working directory is available.");
+        return canonicalizeDirectory(previousCwd);
+    }
+    const expanded = expandHome(argument || home, home);
+    return canonicalizeDirectory(isAbsolute(expanded) ? expanded : resolve(base, expanded));
+}
+export function resolveWorkingPath(base, path, home = homedir()) {
+    const expanded = expandHome(path, home);
+    return isAbsolute(expanded) ? expanded : resolve(base, expanded);
+}
+function readShellWord(command, start) {
+    let value = "";
+    let quote;
+    let index = start;
+    for (; index < command.length; index += 1) {
+        const character = command[index];
+        if (quote) {
+            if (character === quote) {
+                quote = undefined;
+                continue;
+            }
+            if (character === "\\" && quote === '"' && index + 1 < command.length) {
+                index += 1;
+                value += command[index];
+                continue;
+            }
+            value += character;
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            continue;
+        }
+        if (character === "\\" && index + 1 < command.length) {
+            index += 1;
+            value += command[index];
+            continue;
+        }
+        if (/\s/u.test(character) || character === ";" || character === "&")
+            break;
+        if ("|<>`".includes(character) || character === "$" && command[index + 1] === "(")
+            return undefined;
+        value += character;
+    }
+    if (quote || value.length === 0)
+        return undefined;
+    return { value, end: index };
+}
+/** Parse a leading persistent `cd`, optionally followed by `&&` or `;`. */
+export function parseLeadingDirectoryChange(command) {
+    let index = 0;
+    while (/\s/u.test(command[index] ?? ""))
+        index += 1;
+    if (command.slice(index, index + 2) !== "cd")
+        return undefined;
+    const next = command[index + 2];
+    if (next && !/\s/u.test(next) && next !== ";" && command.slice(index + 2, index + 4) !== "&&") {
+        return undefined;
+    }
+    index += 2;
+    while (/\s/u.test(command[index] ?? ""))
+        index += 1;
+    if (command.slice(index, index + 2) === "--") {
+        index += 2;
+        while (/\s/u.test(command[index] ?? ""))
+            index += 1;
+    }
+    let argument = "";
+    if (index < command.length && command[index] !== ";" && command.slice(index, index + 2) !== "&&") {
+        const word = readShellWord(command, index);
+        if (!word)
+            return undefined;
+        argument = word.value;
+        index = word.end;
+    }
+    while (/\s/u.test(command[index] ?? ""))
+        index += 1;
+    if (index >= command.length)
+        return { argument, remainder: "" };
+    if (command.slice(index, index + 2) === "&&")
+        index += 2;
+    else if (command[index] === ";")
+        index += 1;
+    else
+        return undefined;
+    return { argument, remainder: command.slice(index).trimStart() };
+}
+export function getActiveWorkflowRoot(entries) {
+    return activeWorkflow(entries)?.root;
+}
+export function findLatestWorkflowRoot(entries) {
+    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.root;
+        if (typeof root === "string" && root)
+            return root;
+    }
+    return undefined;
+}
+export function shellQuote(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}

package/.pi/extensions/knowledge.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Worker } from "node:worker_threads";
 
@@ -8,13 +8,13 @@ import { Type } from "@earendil-works/pi-ai";
 import { defineTool, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import {
-  buildKnowledgeExtractionPrompt, KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT,
+  buildKnowledgeExtractionPrompt, type ExistingKnowledgeContext, KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT,
 } from "../lib/knowledge/extractor.ts";
 import { matchKnowledge } from "../lib/knowledge/matcher.ts";
 import { loadKnowledgeById, loadKnowledgeSnapshot, projectKnowledgeKey } from "../lib/knowledge/store.ts";
 import type { KnowledgeWorkerInput, KnowledgeWorkerOutput } from "../lib/knowledge/worker-protocol.ts";
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../lib/runtime/defaults.ts";
-import { getWorkingDirectory } from "../lib/working-directory.ts";
+import { findLatestWorkflowRoot, getWorkingDirectory } from "../lib/working-directory.ts";
 
 interface ActiveReview {
   requestId: string;
@@ -98,18 +98,58 @@ async function runReview(message: Extract<KnowledgeWorkerOutput, { type: "review
   try {
     const ctx = runtime.context;
     if (!ctx?.model || !ctx.modelRegistry.hasConfiguredAuth(ctx.model)) throw new Error("no-configured-model");
-    if (!ctx.isIdle() || ctx.hasPendingMessages()) throw new Error("model-executor-is-busy");
+    if (!ctx.isIdle() || ctx.hasPendingMessages()) {
+      post({
+        type: "review_deferred",
+        leaderToken: message.leaderToken,
+        requestId: message.requestId,
+        reason: "model-executor-is-busy",
+      });
+      return;
+    }
     const controller = new AbortController();
     runtime.activeReview = { requestId: message.requestId, leaderToken: message.leaderToken, controller };
     timeout = setTimeout(() => controller.abort(), KNOWLEDGE_RUNTIME_DEFAULTS.review.modelTimeoutMs);
     timeout.unref();
+    const snapshot = loadKnowledgeSnapshot(message.task.projectKey);
+    const applicableCatalog = {
+      ...snapshot.catalog,
+      items: snapshot.catalog.items.filter((entry) => (
+        entry.scope === "global" || entry.scope === `project:${message.task.projectKey}`
+      )),
+    };
+    const related: ExistingKnowledgeContext[] = matchKnowledge(
+      message.task.delta,
+      applicableCatalog,
+      KNOWLEDGE_RUNTIME_DEFAULTS.review.maxExistingContextItems,
+    ).map((entry, index) => {
+      const reference: ExistingKnowledgeContext = {
+        id: entry.id,
+        title: entry.title,
+        summary: entry.summary,
+        keywords: entry.keywords,
+        track: entry.track,
+      };
+      if (index >= KNOWLEDGE_RUNTIME_DEFAULTS.review.maxExistingBodyItems) return reference;
+      const content = loadKnowledgeById(entry.id, message.task.projectKey)?.content
+        .slice(0, KNOWLEDGE_RUNTIME_DEFAULTS.review.maxExistingBodyChars);
+      return content ? { ...reference, content } : reference;
+    });
     const response = await ctx.modelRegistry.complete(
       ctx.model,
       {
         systemPrompt: KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT,
         messages: [{
           role: "user",
-          content: [{ type: "text", text: buildKnowledgeExtractionPrompt(message.task.projectRoot, message.task.delta) }],
+          content: [{
+            type: "text",
+            text: buildKnowledgeExtractionPrompt(
+              message.task.projectRoot,
+              message.task.delta,
+              message.task.context,
+              related,
+            ),
+          }],
           timestamp: Date.now(),
         }],
       },
@@ -120,10 +160,12 @@ async function runReview(message: Extract<KnowledgeWorkerOutput, { type: "review
       .map((item) => item.text).join("\n");
     post({ type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId, raw });
   } catch (error) {
-    post({
-      type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId,
-      error: error instanceof Error ? error.message : String(error),
-    });
+    const reason = error instanceof Error ? error.message : String(error);
+    if (reason === "model-executor-is-busy") {
+      post({ type: "review_deferred", leaderToken: message.leaderToken, requestId: message.requestId, reason });
+    } else {
+      post({ type: "review_result", leaderToken: message.leaderToken, requestId: message.requestId, error: reason });
+    }
     try { updateCapability(); } catch { /* The worker lease will recover even if the extension context changed. */ }
   } finally {
     clearTimeout(timeout);
@@ -184,7 +226,13 @@ function configureForContext(ctx: ExtensionContext): void {
 }
 
 function currentProject(ctx: ExtensionContext): { root: string; key: string } {
-  const root = getWorkingDirectory(ctx.sessionManager);
+  const workingDirectory = resolve(getWorkingDirectory(ctx.sessionManager));
+  const workflowRootValue = findLatestWorkflowRoot(ctx.sessionManager.getEntries());
+  const workflowRoot = workflowRootValue ? resolve(workflowRootValue) : undefined;
+  const root = workflowRoot
+    && (workingDirectory === workflowRoot || workingDirectory.startsWith(`${workflowRoot}${sep}`))
+    ? workflowRoot
+    : workingDirectory;
   return { root, key: projectKnowledgeKey(root) };
 }
 

package/.pi/lib/knowledge/extractor.ts

@@ -2,6 +2,15 @@ import { createHash } from "node:crypto";
 
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.ts";
 
+export interface ExistingKnowledgeContext {
+  id: string;
+  title: string;
+  summary: string;
+  keywords: string[];
+  track: "rule" | "topic";
+  content?: string;
+}
+
 export const KNOWLEDGE_EXTRACTION_SYSTEM_PROMPT = `You are HWCode's background knowledge reviewer.
 Review only the supplied conversation delta. Return strict JSON and no markdown.
 Persist only knowledge that is likely to be useful in future sessions:
@@ -10,15 +19,31 @@ Persist only knowledge that is likely to be useful in future sessions:
 - 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.
 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.
-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".
+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".
-Each summary must be one complete sentence of at most 160 characters. Keep each body under 3000 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: {"candidates":[{"key":"stable semantic key","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"}]}
+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: string, delta: string): string {
-  return `Project root: ${projectRoot}\n\n<conversation_delta>\n${delta}\n</conversation_delta>`;
+export function buildKnowledgeExtractionPrompt(
+  projectRoot: string,
+  delta: string,
+  context = "",
+  existing: ExistingKnowledgeContext[] = [],
+): string {
+  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: string): unknown[] {

package/.pi/lib/knowledge/review-status.ts

@@ -23,6 +23,12 @@ export interface KnowledgeReviewStatus {
     attempt: number;
     startedAt: string;
   };
+  lastDeferred?: {
+    reviewKey: string;
+    sessionKey: string;
+    deferredAt: string;
+    reason: string;
+  };
   lastReview?: {
     reviewKey: string;
     sessionKey: string;

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

@@ -113,6 +113,23 @@ function finishReview(
   publishReviewStatus();
 }
 
+function deferReview(task: KnowledgeReviewTask, reason: string): void {
+  clearTimeout(activeDeadlineTimer);
+  activeDeadlineTimer = undefined;
+  const attempts = reviewAttempts.get(task.reviewKey) ?? 1;
+  if (attempts <= 1) reviewAttempts.delete(task.reviewKey);
+  else reviewAttempts.set(task.reviewKey, attempts - 1);
+  if (!reviewStatus) return;
+  reviewStatus.activeReview = undefined;
+  reviewStatus.lastDeferred = {
+    reviewKey: task.reviewKey,
+    sessionKey: task.sessionKey,
+    deferredAt: new Date().toISOString(),
+    reason: boundedError(reason),
+  };
+  publishReviewStatus();
+}
+
 function removeLeaderMetadata(token: string): void {
   try {
     const current = JSON.parse(readFileSync(paths.knowledgeLeader, "utf8")) as { leaderToken?: string };
@@ -332,6 +349,13 @@ function handleReviewResult(message: Extract<KnowledgeWorkerInput, { type: "revi
   }
 }
 
+function handleReviewDeferred(message: Extract<KnowledgeWorkerInput, { type: "review_deferred" }>): void {
+  const task = activeTask;
+  if (!task || message.requestId !== task.requestId || message.leaderToken !== leaderToken || !leaderServer) return;
+  deferReview(task, message.reason);
+  activeTask = undefined;
+}
+
 const scanTimer = setInterval(() => { void scanForReview(); }, KNOWLEDGE_RUNTIME_DEFAULTS.review.intervalMs);
 scanTimer.unref();
 
@@ -348,6 +372,7 @@ parentPort.on("message", (message: KnowledgeWorkerInput) => {
     } else scheduleElection(0);
     return;
   }
+  if (message.type === "review_deferred") { handleReviewDeferred(message); return; }
   if (message.type === "review_result") { handleReviewResult(message); return; }
   if (message.type === "scan_now") { void scanForReview(); return; }
   stopped = true;

package/.pi/lib/knowledge/session-scanner.ts

@@ -1,12 +1,13 @@
 import { createHash, randomUUID } from "node:crypto";
 import { readFileSync, readdirSync, statSync } from "node:fs";
-import { resolve } from "node:path";
+import { resolve, sep } from "node:path";
 
 import {
   buildContextEntries, parseSessionEntries, type SessionEntry, type SessionHeader,
 } from "@earendil-works/pi-coding-agent";
 
 import { KNOWLEDGE_RUNTIME_DEFAULTS } from "../runtime/defaults.ts";
+import { findLatestWorkflowRoot } from "../working-directory.ts";
 import { knowledgeDeltaDigest } from "./extractor.ts";
 import { sanitizeKnowledgeText } from "./sanitize.ts";
 import { projectKnowledgeKey } from "./store.ts";
@@ -19,6 +20,9 @@ interface ReviewPiece {
   text: string;
 }
 
+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: string, length = 64): string {
   return createHash("sha256").update(value).digest("hex").slice(0, length);
 }
@@ -35,20 +39,21 @@ function textContent(content: unknown): string {
 
 function reviewPiece(entry: SessionEntry, index: number): ReviewPiece | undefined {
   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)}`,
     };
   }
   if (entry.type !== "message" || !entry.message || typeof entry.message !== "object") return undefined;
   const message = entry.message as unknown as Record<string, unknown>;
   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)}` };
@@ -61,24 +66,63 @@ function buildDelta(entries: SessionEntry[]): string {
     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: SessionEntry[]): string {
+  const pieces = entries.map(reviewPiece).filter((piece): piece is ReviewPiece => 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: ReviewPiece[] = [];
+  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: SessionHeader, branch: SessionEntry[]): string {
+  const sessionRoot = resolve(header.cwd);
+  const workflowRootValue = findLatestWorkflowRoot(branch);
+  const workflowRoot = workflowRootValue ? resolve(workflowRootValue) : undefined;
+  let workingDirectory = sessionRoot;
   for (const entry of branch.slice().reverse()) {
     if (entry.type !== "custom" || entry.customType !== "hwcode-working-directory"
       || !entry.data || typeof entry.data !== "object") continue;
     const cwd = (entry.data as Record<string, unknown>).cwd;
-    if (typeof cwd === "string" && cwd) return resolve(cwd);
+    if (typeof cwd !== "string" || !cwd) continue;
+    workingDirectory = resolve(cwd);
+    break;
+  }
+  if (workflowRoot && (workingDirectory === workflowRoot || workingDirectory.startsWith(`${workflowRoot}${sep}`))) {
+    return workflowRoot;
   }
-  return resolve(header.cwd);
+  if (workingDirectory === sessionRoot || workingDirectory.startsWith(`${sessionRoot}${sep}`)) return sessionRoot;
+  return workingDirectory;
 }
 
 export function discoverSessionFiles(root: string): string[] {
@@ -120,6 +164,7 @@ export function readReviewTask(
   const pending = branch.slice(cursorIndex + 1);
   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}`);
@@ -130,7 +175,7 @@ export function readReviewTask(
   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,
   };
 }