patchwarden 0.6.4 → 1.5.0

package/scripts/checks/mcp-smoke.js

@@ -103,17 +103,29 @@ try {
   const tools = await client.listTools();
   const names = tools.tools.map((tool) => tool.name).sort();
   const expected = [
+    "accept_subgoal",
     "apply_patch",
     "audit_session",
     "audit_task",
     "cancel_task",
+    "check_release_gate",
     "create_direct_session",
+    "create_goal",
+    "create_subgoal_task",
     "create_task",
+    "diagnose_task",
+    "discard_worktree",
+    "discover_tools",
+    "explain_tool",
+    "export_handoff",
+    "export_task_evidence_pack",
     "finalize_direct_session",
     "get_diff",
     "get_plan",
+    "get_project_policy",
     "get_result",
     "get_result_json",
+    "get_task_lineage",
     "get_task_log_tail",
     "get_task_progress",
     "get_task_status",
@@ -121,16 +133,38 @@ try {
     "get_task_summary",
     "get_test_log",
     "health_check",
+    "invoke_discovered_tool",
     "kill_task",
     "list_agents",
+    "list_goals",
     "list_tasks",
     "list_workspace",
+    "merge_worktree",
+    "read_goal",
     "read_workspace_file",
+    "recommend_agent_for_task",
+    "reconcile_tasks",
+    "reject_subgoal",
+    "release_check",
+    "release_cleanup",
+    "release_prepare",
+    "release_verify",
     "retry_task",
+    "run_direct_verification_bundle",
+    "run_task_loop",
     "run_verification",
+    "safe_audit",
+    "safe_audit_direct_session",
+    "safe_diff_summary",
+    "safe_direct_summary",
+    "safe_finalize_direct_session",
+    "safe_result",
     "safe_status",
+    "safe_test_summary",
     "save_plan",
     "search_workspace",
+    "suggest_next_subgoal",
+    "summarize_goal_progress",
     "sync_file",
     "wait_for_task",
   ];
@@ -143,7 +177,7 @@ try {
   if (!tools._meta || typeof tools._meta.tool_manifest_sha256 !== "string" || tools._meta.tool_manifest_sha256.length !== 64) {
     throw new Error(`tools/list _meta missing manifest hash: ${JSON.stringify(tools._meta || null)}`);
   }
-  if (tools._meta.tool_profile !== "full" || tools._meta.tool_count !== 30) {
+  if (tools._meta.tool_profile !== "full" || tools._meta.tool_count !== 64) {
     throw new Error(`tools/list _meta profile/count mismatch: ${JSON.stringify(tools._meta)}`);
   }
   if (typeof tools._meta.schema_epoch !== "string" || typeof tools._meta.server_version !== "string") {
@@ -296,8 +330,8 @@ try {
 
   const statusPath = join(task.path, "status.json");
   const statusAfter = JSON.parse(readFileSync(statusPath, "utf-8"));
-  if (statusAfter.status !== "done") {
-    throw new Error(`runner status should be done, got ${statusAfter.status}`);
+  if (statusAfter.status !== "done" && statusAfter.status !== "done_by_agent") {
+    throw new Error(`runner status should be done or done_by_agent, got ${statusAfter.status}`);
   }
   for (const fileName of ["result.md", "result.json", "diff.patch", "git.diff", "file-stats.json", "test.log", "verify.json", "verify.log"]) {
     if (!existsSync(join(task.path, fileName))) {
@@ -393,7 +427,7 @@ try {
   await disabledClient.close();
   ok("chatgpt_direct disabled exposes only health_check with diagnostic");
 
-  // 2. chatgpt_direct enabled: 10 tools + minimal create_direct_session
+  // 2. chatgpt_direct enabled: 14 tools + minimal create_direct_session
   const enabledConfigPath = join(tempRoot, "direct-enabled.json");
   const directRepo = join(workspaceRoot, "direct-fixture");
   mkdirSync(join(directRepo, "src"), { recursive: true });
@@ -449,15 +483,19 @@ try {
     "health_check",
     "list_workspace",
     "read_workspace_file",
+    "run_direct_verification_bundle",
     "run_verification",
+    "safe_audit_direct_session",
+    "safe_direct_summary",
+    "safe_finalize_direct_session",
     "search_workspace",
     "sync_file",
   ];
   if (JSON.stringify(enabledNames) !== JSON.stringify(expectedDirect)) {
     throw new Error(`chatgpt_direct enabled tools mismatch: ${enabledNames.join(", ")}`);
   }
-  if (enabledTools._meta.tool_count !== 10) {
-    throw new Error(`chatgpt_direct enabled tool_count should be 10, got ${enabledTools._meta.tool_count}`);
+  if (enabledTools._meta.tool_count !== 14) {
+    throw new Error(`chatgpt_direct enabled tool_count should be 14, got ${enabledTools._meta.tool_count}`);
   }
 
   // Minimal create_direct_session
@@ -470,6 +508,19 @@ try {
   if (!sessionResult.session_id || !sessionResult.session_id.startsWith("direct_")) {
     throw new Error(`create_direct_session failed: ${JSON.stringify(sessionResult)}`);
   }
+  const bundleResult = JSON.parse(
+    (await enabledClient.callTool({
+      name: "run_direct_verification_bundle",
+      arguments: { session_id: sessionResult.session_id, commands: ["npm test"], timeout_seconds: 30 },
+    })).content?.[0]?.text || "{}"
+  );
+  if (bundleResult.status !== "passed" || bundleResult.command_count !== 1 || bundleResult.passed_commands !== 1) {
+    throw new Error(`run_direct_verification_bundle failed: ${JSON.stringify(bundleResult)}`);
+  }
+  const bundleText = JSON.stringify(bundleResult).toLowerCase();
+  if (bundleText.includes("stdout_tail") || bundleText.includes("stderr_tail") || bundleText.includes("verification.log")) {
+    throw new Error("run_direct_verification_bundle leaked log tail fields");
+  }
 
   const enabledHealth = JSON.parse(
     (await enabledClient.callTool({ name: "health_check", arguments: {} })).content?.[0]?.text || "{}"
@@ -477,12 +528,12 @@ try {
   if (enabledHealth.direct_profile_enabled !== true) {
     throw new Error(`direct_profile_enabled should be true, got ${enabledHealth.direct_profile_enabled}`);
   }
-  if (enabledHealth.direct_tool_count !== 10) {
-    throw new Error(`direct_tool_count should be 10, got ${enabledHealth.direct_tool_count}`);
+  if (enabledHealth.direct_tool_count !== 14) {
+    throw new Error(`direct_tool_count should be 14, got ${enabledHealth.direct_tool_count}`);
   }
 
   await enabledClient.close();
-  ok("chatgpt_direct enabled exposes 10 tools and create_direct_session works");
+  ok("chatgpt_direct enabled exposes 14 tools and create_direct_session works");
 } catch (error) {
   fail("MCP smoke test", error);
 } finally {

package/scripts/checks/watcher-supervisor-smoke.js

@@ -105,7 +105,7 @@ function createFixture(name) {
     server_version: "0.6.0",
     schema_epoch: "2026-06-22-v6",
     tool_profile: "chatgpt_core",
-    tool_count: 16,
+    tool_count: 26,
     tool_names: [],
     tool_manifest_sha256: "a".repeat(64),
   });
@@ -167,7 +167,7 @@ function fixtureEnv(fixture, mode, lifetimeMs) {
     ...process.env,
     APPDATA: fixture.appData,
     LOCALAPPDATA: fixture.localAppData,
-    CONTROL_PLANE_API_KEY: "watcher-supervisor-smoke-secret",
+    CONTROL_PLANE_API_KEY: "test-key",
     WATCHER_FIXTURE_MODE: mode,
     TUNNEL_FIXTURE_LIFETIME_MS: String(lifetimeMs),
   };

package/src/agents/agentRouter.ts

@@ -0,0 +1,149 @@
+import { PatchWardenError } from "../errors.js";
+
+// ── Types ─────────────────────────────────────────────────────────
+
+export interface AgentRouteInput {
+  goal?: string;
+  scope?: string[];
+  inline_plan?: string;
+  template?: string;
+  configuredAgents: string[];
+}
+
+export interface AgentRouteResult {
+  recommended_agent: string;
+  reason: string;
+  fallback: boolean;
+}
+
+// ── Routing rules (roadmap 9.3) ───────────────────────────────────
+
+export const AGENT_ROUTING_RULES = {
+  /** 大规模代码修改 → opencode */
+  largeScope: {
+    agent: "opencode",
+    threshold: 10, // scope.length > threshold
+  },
+  /** 单文件修改 → patchwarden-direct */
+  singleFile: {
+    agent: "patchwarden-direct",
+  },
+  /** 验收审计 → patchwarden-audit */
+  audit: {
+    agent: "patchwarden-audit",
+    keywords: ["审计", "audit", "验收", "verify"],
+  },
+  /** 复杂推理和重构 → codex */
+  refactor: {
+    agent: "codex",
+    keywords: ["重构", "refactor", "跨模块", "redesign"],
+  },
+  /** 文档整理 → claude（fallback 到 opencode） */
+  documentation: {
+    agent: "claude",
+    fallbackAgent: "opencode",
+    keywords: ["文档", "readme", "changelog", "doc"],
+  },
+} as const;
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+function containsAny(text: string, keywords: readonly string[]): boolean {
+  return keywords.some((keyword) => text.includes(keyword));
+}
+
+function resolveRoute(
+  preferred: string,
+  reason: string,
+  configuredAgents: string[]
+): AgentRouteResult {
+  if (configuredAgents.includes(preferred)) {
+    return { recommended_agent: preferred, reason, fallback: false };
+  }
+  const fallback = configuredAgents[0];
+  return {
+    recommended_agent: fallback,
+    reason: `fallback: ${preferred} not configured, using ${fallback}`,
+    fallback: true,
+  };
+}
+
+// ── Route agent ───────────────────────────────────────────────────
+
+export function routeAgent(input: AgentRouteInput): AgentRouteResult {
+  if (!input.configuredAgents || input.configuredAgents.length === 0) {
+    throw new PatchWardenError(
+      "no_agent_configured",
+      "No agent is configured for routing.",
+      "Configure at least one agent in patchwarden.config.json under the agents field."
+    );
+  }
+
+  const scopeCount = input.scope?.length ?? 0;
+  const text = `${input.goal || ""} ${input.inline_plan || ""}`.toLowerCase();
+
+  // Rule 1: 大规模代码修改 → opencode (scope files > 10)
+  if (scopeCount > AGENT_ROUTING_RULES.largeScope.threshold) {
+    return resolveRoute(
+      AGENT_ROUTING_RULES.largeScope.agent,
+      `large scope (${scopeCount} files)`,
+      input.configuredAgents
+    );
+  }
+
+  // Rule 2: 单文件修改 → patchwarden-direct (scope files === 1)
+  if (scopeCount === 1) {
+    return resolveRoute(
+      AGENT_ROUTING_RULES.singleFile.agent,
+      "single file scope",
+      input.configuredAgents
+    );
+  }
+
+  // Rule 3: 验收审计 → patchwarden-audit
+  if (containsAny(text, AGENT_ROUTING_RULES.audit.keywords)) {
+    return resolveRoute(
+      AGENT_ROUTING_RULES.audit.agent,
+      "audit keywords",
+      input.configuredAgents
+    );
+  }
+
+  // Rule 4: 复杂推理和重构 → codex
+  if (containsAny(text, AGENT_ROUTING_RULES.refactor.keywords)) {
+    return resolveRoute(
+      AGENT_ROUTING_RULES.refactor.agent,
+      "refactor keywords",
+      input.configuredAgents
+    );
+  }
+
+  // Rule 5: 文档整理 → claude（fallback 到 opencode）
+  if (containsAny(text, AGENT_ROUTING_RULES.documentation.keywords)) {
+    const preferred = AGENT_ROUTING_RULES.documentation.agent;
+    const fallbackAgent = AGENT_ROUTING_RULES.documentation.fallbackAgent;
+    if (input.configuredAgents.includes(preferred)) {
+      return { recommended_agent: preferred, reason: "documentation keywords", fallback: false };
+    }
+    if (input.configuredAgents.includes(fallbackAgent)) {
+      return {
+        recommended_agent: fallbackAgent,
+        reason: `fallback: ${preferred} not configured, using ${fallbackAgent}`,
+        fallback: true,
+      };
+    }
+    const firstAgent = input.configuredAgents[0];
+    return {
+      recommended_agent: firstAgent,
+      reason: `fallback: ${preferred} not configured, using ${firstAgent}`,
+      fallback: true,
+    };
+  }
+
+  // Rule 6: 无匹配 → fallback 到 configuredAgents[0]
+  return {
+    recommended_agent: input.configuredAgents[0],
+    reason: `no specific routing rule matched, using default agent ${input.configuredAgents[0]}`,
+    fallback: true,
+  };
+}

package/src/config.ts

@@ -21,7 +21,7 @@ export interface PatchWardenConfig {
   defaultTaskTimeoutSeconds: number;
   maxTaskTimeoutSeconds: number;
   watcherStaleSeconds: number;
-  toolProfile?: "full" | "chatgpt_core" | "chatgpt_direct";
+  toolProfile?: "full" | "chatgpt_core" | "chatgpt_direct" | "chatgpt_search";
   repoAliases?: Record<string, string>;
   enableAgentAssessment?: boolean;
   agentAssessmentTimeoutSeconds?: number;
@@ -224,8 +224,14 @@ function normalizeConfig(config: PatchWardenConfig): PatchWardenConfig {
   if (!Number.isInteger(config.watcherStaleSeconds) || config.watcherStaleSeconds < 5 || config.watcherStaleSeconds > 3600) {
     throw new Error("watcherStaleSeconds must be an integer from 5 to 3600");
   }
-  if (config.toolProfile !== undefined && config.toolProfile !== "full" && config.toolProfile !== "chatgpt_core" && config.toolProfile !== "chatgpt_direct") {
-    throw new Error('toolProfile must be "full", "chatgpt_core", or "chatgpt_direct"');
+  if (
+    config.toolProfile !== undefined &&
+    config.toolProfile !== "full" &&
+    config.toolProfile !== "chatgpt_core" &&
+    config.toolProfile !== "chatgpt_direct" &&
+    config.toolProfile !== "chatgpt_search"
+  ) {
+    throw new Error('toolProfile must be "full", "chatgpt_core", "chatgpt_direct", or "chatgpt_search"');
   }
   if (config.enableAgentAssessment !== undefined && typeof config.enableAgentAssessment !== "boolean") {
     throw new Error("enableAgentAssessment must be a boolean");

package/src/controlCenter.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * PatchWarden Control Center — local HTTP dashboard service.
  *
@@ -13,7 +13,7 @@
  */
 
 import { createServer, get as httpGet, type IncomingMessage, type ServerResponse } from "node:http";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
@@ -27,11 +27,16 @@ import {
   type PatchWardenConfig,
 } from "./config.js";
 import { listTasks, type TaskEntry } from "./tools/listTasks.js";
+import type { AcceptanceStatus } from "./tools/createTask.js";
 import { listAgents, type AgentAvailability } from "./tools/listAgents.js";
 import { readWatcherStatus, type WatcherStatusSnapshot } from "./watcherStatus.js";
 import { redactSensitiveContent } from "./security/contentRedaction.js";
 import { guardWorkspacePath } from "./security/pathGuard.js";
 import { auditTask } from "./tools/auditTask.js";
+import { getProjectPolicySummary } from "./policy/projectPolicy.js";
+import { safeDirectSummary } from "./tools/safeViews.js";
+import { toSafeTaskLineage, type TaskLineageRecord } from "./tools/taskLineage.js";
+import { listEvidencePacks, readEvidencePack } from "./tools/evidencePack.js";
 import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "./version.js";
 
 // ── Paths ─────────────────────────────────────────────────────────
@@ -249,6 +254,25 @@ function readJsonFileSafe<T = unknown>(filePath: string): T | null {
   }
 }
 
+function isPathInside(root: string, target: string): boolean {
+  const rel = relative(root, target);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function readJsonFileSafeUnder<T = unknown>(root: string, relPath: string): T | null {
+  const base = resolve(root);
+  const target = resolve(base, relPath);
+  if (!isPathInside(base, target) || !existsSync(target)) return null;
+  try {
+    const realBase = realpathSync(base);
+    const realTarget = realpathSync(target);
+    if (!isPathInside(realBase, realTarget)) return null;
+    return readJsonFileSafe<T>(realTarget);
+  } catch {
+    return null;
+  }
+}
+
 function readTextFileSafe(filePath: string): string | null {
   if (!existsSync(filePath)) return null;
   try {
@@ -464,6 +488,7 @@ interface StaleClassification {
 
 const TERMINAL_TASK_STATUSES = new Set([
   "done",
+  "done_by_agent",
   "failed",
   "failed_verification",
   "failed_scope_violation",
@@ -1018,6 +1043,108 @@ function handleStaleTasks(res: ServerResponse): void {
   }
 }
 
+function handleLineages(res: ServerResponse): void {
+  try {
+    const root = join(config.workspaceRoot, ".patchwarden", "lineages");
+    if (!existsSync(root)) {
+      sendJson(res, 200, { lineages: [], total: 0, reason: null });
+      return;
+    }
+    const lineages = readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => readJsonFileSafeUnder<TaskLineageRecord>(root, join(entry.name, "lineage.json")))
+      .filter((entry): entry is TaskLineageRecord => entry !== null)
+      .map((entry) => toSafeTaskLineage(entry, 6))
+      .sort((a, b) => b.updated_at.localeCompare(a.updated_at))
+      .slice(0, 50);
+    sendJson(res, 200, { lineages, total: lineages.length, reason: null });
+  } catch (err) {
+    sendJson(res, 200, { lineages: [], total: 0, reason: errorMessage(err) });
+  }
+}
+
+function handleLineageDetail(res: ServerResponse, lineageId: string): void {
+  try {
+    if (!/^[A-Za-z0-9_-]+$/.test(lineageId)) {
+      sendJson(res, 400, { error: "Invalid lineage id" });
+      return;
+    }
+    const data = readJsonFileSafeUnder<TaskLineageRecord>(
+      join(config.workspaceRoot, ".patchwarden", "lineages"),
+      join(lineageId, "lineage.json")
+    );
+    if (!data) {
+      sendJson(res, 404, { error: "Lineage not found" });
+      return;
+    }
+    sendJson(res, 200, toSafeTaskLineage(data, 20));
+  } catch (err) {
+    sendJson(res, 200, { lineage_id: lineageId, error: errorMessage(err) });
+  }
+}
+
+function handleProjectPolicy(res: ServerResponse, repoPath: string): void {
+  try {
+    sendJson(res, 200, getProjectPolicySummary(repoPath || "."));
+  } catch (err) {
+    sendJson(res, 200, {
+      repo_path: repoPath || ".",
+      valid: false,
+      issues: [{ code: "policy_unavailable", severity: "error", field: "repo_path", message: errorMessage(err) }],
+    });
+  }
+}
+
+function handleReleaseStatus(res: ServerResponse, repoPath: string): void {
+  try {
+    const policy = getProjectPolicySummary(repoPath || ".");
+    sendJson(res, 200, {
+      repo_path: repoPath || ".",
+      resolved_repo_path: policy.resolved_repo_path,
+      policy_valid: policy.valid,
+      policy_issue_count: policy.issues.length,
+      policy_issues: policy.issues.slice(0, 10),
+      release_readiness: policy.release_readiness,
+      next_action: policy.valid && policy.release_readiness.version_consistent !== false
+        ? "Run release_check or release_prepare from the full MCP profile when ready."
+        : "Fix project-policy or version consistency issues before release preparation.",
+      remote_write_performed: false,
+    });
+  } catch (err) {
+    sendJson(res, 200, {
+      repo_path: repoPath || ".",
+      policy_valid: false,
+      error: errorMessage(err),
+      remote_write_performed: false,
+    });
+  }
+}
+
+function handleEvidencePacks(res: ServerResponse): void {
+  try {
+    sendJson(res, 200, listEvidencePacks({ max_items: 50 }));
+  } catch (err) {
+    sendJson(res, 200, { evidence_packs: [], total: 0, reason: errorMessage(err) });
+  }
+}
+
+function handleEvidencePackDetail(res: ServerResponse, lineageId: string): void {
+  try {
+    if (!/^[A-Za-z0-9_-]+$/.test(lineageId)) {
+      sendJson(res, 400, { error: "Invalid lineage id" });
+      return;
+    }
+    const pack = readEvidencePack(lineageId);
+    if (!pack) {
+      sendJson(res, 404, { error: "Evidence pack not found" });
+      return;
+    }
+    sendJson(res, 200, pack);
+  } catch (err) {
+    sendJson(res, 200, { lineage_id: lineageId, error: errorMessage(err), bounded: true });
+  }
+}
+
 /**
  * Reconcile a stale task. Does NOT delete the task. Reads the task files,
  * decides whether it is safe to mark the task as stale/archived, writes a
@@ -1049,13 +1176,19 @@ function handleReconcile(res: ServerResponse, taskId: string): void {
     const runtimeData = readJsonFileSafe<Record<string, unknown>>(runtimePath) ?? {};
 
     const watcher = readWatcherStatusSafe();
+    const VALID_ACCEPTANCE = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+    const taskStatus = String(statusData.status || "pending");
+    const taskAcceptanceStatus = taskStatus === "done_by_agent"
+      ? (typeof statusData.acceptance_status === "string" && VALID_ACCEPTANCE.includes(statusData.acceptance_status) ? (statusData.acceptance_status as AcceptanceStatus) : "pending" as AcceptanceStatus)
+      : null;
     const taskEntry: TaskEntry = {
       task_id: taskId,
       plan_id: String(statusData.plan_id || ""),
       title: "",
       agent: String(statusData.agent || ""),
-      status: String(statusData.status || "pending") as TaskEntry["status"],
+      status: taskStatus as TaskEntry["status"],
       phase: String(runtimeData.phase || statusData.phase || "queued") as TaskEntry["phase"],
+      acceptance_status: taskAcceptanceStatus,
       created_at: String(statusData.created_at || ""),
       updated_at: String(statusData.updated_at || ""),
       workspace_root: String(statusData.workspace_root || config.workspaceRoot),
@@ -1199,13 +1332,19 @@ function handleTaskDetail(res: ServerResponse, taskId: string): void {
     let stale: StaleClassification | null = null;
     if (statusData) {
       const watcher = readWatcherStatusSafe();
+      const VALID_ACCEPTANCE2 = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+      const taskStatus2 = String(statusData.status || "pending");
+      const taskAcceptanceStatus2 = taskStatus2 === "done_by_agent"
+        ? (typeof statusData.acceptance_status === "string" && VALID_ACCEPTANCE2.includes(statusData.acceptance_status) ? (statusData.acceptance_status as AcceptanceStatus) : "pending" as AcceptanceStatus)
+        : null;
       const entry: TaskEntry = {
         task_id: taskId,
         plan_id: String(statusData.plan_id || ""),
         title: "",
         agent: String(statusData.agent || ""),
-        status: String(statusData.status || "pending") as TaskEntry["status"],
+        status: taskStatus2 as TaskEntry["status"],
         phase: String(runtimeData?.phase || statusData.phase || "queued") as TaskEntry["phase"],
+        acceptance_status: taskAcceptanceStatus2,
         created_at: String(statusData.created_at || ""),
         updated_at: String(statusData.updated_at || ""),
         workspace_root: String(statusData.workspace_root || config.workspaceRoot),
@@ -1641,6 +1780,29 @@ function handleDirectSessionDetail(res: ServerResponse, sessionId: string): void
   }
 }
 
+function handleDirectSessionSafeSummary(res: ServerResponse, sessionId: string): void {
+  try {
+    if (
+      sessionId === "." ||
+      sessionId === ".." ||
+      sessionId.includes("/") ||
+      sessionId.includes("\\") ||
+      sessionId.includes("\0")
+    ) {
+      sendJson(res, 400, { error: "Invalid session id" });
+      return;
+    }
+    sendJson(res, 200, safeDirectSummary(sessionId, { max_items: 12 }));
+  } catch (err) {
+    sendJson(res, 200, {
+      session_id: sessionId,
+      error: errorMessage(err),
+      large_logs_omitted: true,
+      diff_omitted: true,
+    });
+  }
+}
+
 function parseReviewVerdict(content: string): string | null {
   // independent-review.md format: "**Verdict**: PASS" (case-insensitive)
   const m = content.match(/\*\*Verdict\*\*\s*:\s*([A-Za-z]+)/);
@@ -1938,6 +2100,44 @@ async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise
     handleStaleTasks(res);
     return;
   }
+  if (method === "GET" && pathname === "/api/lineages") {
+    handleLineages(res);
+    return;
+  }
+  const lineageMatch = pathname.match(/^\/api\/lineages\/([^/]+)$/);
+  if (method === "GET" && lineageMatch) {
+    let lineageId: string;
+    try {
+      lineageId = decodeURIComponent(lineageMatch[1]);
+    } catch {
+      lineageId = lineageMatch[1];
+    }
+    handleLineageDetail(res, lineageId);
+    return;
+  }
+  if (method === "GET" && pathname === "/api/project-policy") {
+    handleProjectPolicy(res, parsedUrl.searchParams.get("repo_path") || ".");
+    return;
+  }
+  if (method === "GET" && pathname === "/api/release/status") {
+    handleReleaseStatus(res, parsedUrl.searchParams.get("repo_path") || ".");
+    return;
+  }
+  if (method === "GET" && pathname === "/api/evidence-packs") {
+    handleEvidencePacks(res);
+    return;
+  }
+  const evidencePackMatch = pathname.match(/^\/api\/evidence-packs\/([^/]+)$/);
+  if (method === "GET" && evidencePackMatch) {
+    let lineageId: string;
+    try {
+      lineageId = decodeURIComponent(evidencePackMatch[1]);
+    } catch {
+      lineageId = evidencePackMatch[1];
+    }
+    handleEvidencePackDetail(res, lineageId);
+    return;
+  }
   const taskMatch = pathname.match(/^\/api\/tasks\/([^/]+)$/);
   if (method === "GET" && taskMatch) {
     let taskId: string;
@@ -1996,6 +2196,17 @@ async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise
     handleDirectSessions(res);
     return;
   }
+  const directSessionSummaryMatch = pathname.match(/^\/api\/direct-sessions\/([^/]+)\/summary$/);
+  if (method === "GET" && directSessionSummaryMatch) {
+    let sessionId: string;
+    try {
+      sessionId = decodeURIComponent(directSessionSummaryMatch[1]);
+    } catch {
+      sessionId = directSessionSummaryMatch[1];
+    }
+    handleDirectSessionSafeSummary(res, sessionId);
+    return;
+  }
   const directSessionMatch = pathname.match(/^\/api\/direct-sessions\/([^/]+)$/);
   if (method === "GET" && directSessionMatch) {
     let sessionId: string;

package/src/direct/directSessionStore.ts

@@ -40,6 +40,8 @@ export interface DirectSessionVerificationRun {
   exit_code: number | null;
   passed: boolean;
   timed_out: boolean;
+  redacted?: boolean;
+  redaction_categories?: string[];
   stdout_tail: string;
   stderr_tail: string;
   started_at: string;

package/src/direct/directVerification.ts

@@ -69,6 +69,13 @@ export async function runDirectVerification(
     exit_code: result.exitCode,
     passed,
     timed_out: result.timedOut,
+    redacted: stdoutRedacted.redacted || stderrRedacted.redacted,
+    redaction_categories: [
+      ...new Set([
+        ...stdoutRedacted.redaction_categories,
+        ...stderrRedacted.redaction_categories,
+      ]),
+    ],
     stdout_tail: stdoutTail,
     stderr_tail: stderrTail,
     started_at: startedAt,