patchwarden 1.1.0 → 1.5.0

package/scripts/checks/mcp-smoke.js

@@ -118,11 +118,14 @@ try {
     "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",
@@ -139,9 +142,16 @@ try {
     "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",
@@ -167,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 !== 54) {
+  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") {
@@ -417,7 +427,7 @@ try {
   await disabledClient.close();
   ok("chatgpt_direct disabled exposes only health_check with diagnostic");
 
-  // 2. chatgpt_direct enabled: 13 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 });
@@ -473,6 +483,7 @@ try {
     "health_check",
     "list_workspace",
     "read_workspace_file",
+    "run_direct_verification_bundle",
     "run_verification",
     "safe_audit_direct_session",
     "safe_direct_summary",
@@ -483,8 +494,8 @@ try {
   if (JSON.stringify(enabledNames) !== JSON.stringify(expectedDirect)) {
     throw new Error(`chatgpt_direct enabled tools mismatch: ${enabledNames.join(", ")}`);
   }
-  if (enabledTools._meta.tool_count !== 13) {
-    throw new Error(`chatgpt_direct enabled tool_count should be 13, 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
@@ -497,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 || "{}"
@@ -504,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 !== 13) {
-    throw new Error(`direct_tool_count should be 13, 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 13 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: 21,
+    tool_count: 26,
     tool_names: [],
     tool_manifest_sha256: "a".repeat(64),
   });

package/src/controlCenter.ts

@@ -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";
@@ -33,6 +33,10 @@ import { readWatcherStatus, type WatcherStatusSnapshot } from "./watcherStatus.j
 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 ─────────────────────────────────────────────────────────
@@ -250,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 {
@@ -1020,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
@@ -1655,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]+)/);
@@ -1952,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;
@@ -2010,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,

package/src/doctor.ts

@@ -248,7 +248,7 @@ try {
   const coreTools = selectToolsForProfile(fullTools, "chatgpt_core", config?.enableDirectProfile);
   const createSchema = coreTools.find((tool) => tool.name === "create_task")?.inputSchema as any;
   const waitSchema = coreTools.find((tool) => tool.name === "wait_for_task")?.inputSchema as any;
-  check("Full tool profile exposes 54 tools", fullTools.length === 54, `${fullTools.length} tools`);
+  check("Full tool profile exposes 64 tools", fullTools.length === 64, `${fullTools.length} tools`);
   check(
     `chatgpt_core profile exposes the exact ${CHATGPT_CORE_TOOL_NAMES.length}-tool manifest`,
     JSON.stringify(coreTools.map((tool) => tool.name)) === JSON.stringify(CHATGPT_CORE_TOOL_NAMES),