patchwarden 0.6.0 → 0.6.1

package/dist/tools/safeStatus.js

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { getTasksDir, getConfig } from "../config.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { readTaskRuntime } from "../taskRuntime.js";
+import { readWatcherStatus } from "../watcherStatus.js";
+export function safeStatus(taskId, config) {
+    const cfg = config || getConfig();
+    const tasksDir = getTasksDir(cfg);
+    const taskDir = resolve(tasksDir, taskId);
+    const statusFile = join(taskDir, "status.json");
+    // Check existence BEFORE guardReadPath so that a non-existent task
+    // returns a structured not_found response instead of throwing.
+    if (!existsSync(statusFile)) {
+        return {
+            task_id: taskId,
+            status: "not_found",
+            phase: null,
+            created_at: null,
+            started_at: null,
+            updated_at: null,
+            finished_at: null,
+            last_heartbeat_at: null,
+            current_command: null,
+            verify_status: null,
+            artifact_status: null,
+            watcher_state: null,
+            error_code: null,
+            error_summary: null,
+        };
+    }
+    guardReadPath(statusFile, cfg.workspaceRoot, cfg.tasksDir);
+    guardSensitivePath(statusFile);
+    const raw = readFileSync(statusFile, "utf-8");
+    const status = JSON.parse(raw);
+    const runtime = readTaskRuntime(taskDir);
+    const phase = (runtime.phase || status.phase || "queued");
+    const watcher = readWatcherStatus(cfg);
+    // Extract short error summary — never the full error text
+    let errorCode = null;
+    let errorSummary = null;
+    if (status.error && typeof status.error === "string") {
+        const errorStr = status.error;
+        // Keep only the first 200 chars as summary
+        errorSummary = errorStr.length > 200 ? errorStr.slice(0, 200) + "..." : errorStr;
+        // Try to extract an error code from the status
+        if (typeof status.status === "string" && status.status.startsWith("failed")) {
+            errorCode = status.status;
+        }
+    }
+    else if (typeof status.status === "string" && status.status.startsWith("failed")) {
+        errorCode = status.status;
+        errorSummary = `Task ended with status: ${status.status}`;
+    }
+    return {
+        task_id: taskId,
+        status: status.status || "not_found",
+        phase,
+        created_at: typeof status.created_at === "string" ? status.created_at : null,
+        started_at: typeof status.started_at === "string" ? status.started_at : null,
+        updated_at: typeof status.updated_at === "string" ? status.updated_at : null,
+        finished_at: typeof status.finished_at === "string" ? status.finished_at : null,
+        last_heartbeat_at: runtime.last_heartbeat_at || (typeof status.last_heartbeat_at === "string" ? status.last_heartbeat_at : null),
+        current_command: runtime.current_command ?? (typeof status.current_command === "string" ? status.current_command : null) ?? null,
+        verify_status: typeof status.verify_status === "string" ? status.verify_status : null,
+        artifact_status: typeof status.artifact_status === "string" ? status.artifact_status : null,
+        watcher_state: watcher.status,
+        error_code: errorCode,
+        error_summary: errorSummary,
+    };
+}

package/dist/tools/syncFile.d.ts

@@ -0,0 +1,18 @@
+import { type PatchWardenConfig } from "../config.js";
+export interface SyncFileResult {
+    source_path: string;
+    target_path: string;
+    before_target_sha256: string | null;
+    after_target_sha256: string;
+    source_sha256: string;
+    copied_bytes: number;
+    changed: boolean;
+}
+/**
+ * Copy a file from source to target within the same session repo.
+ * Both source and target must be inside the session's repo_path.
+ */
+export declare function syncFile(sessionId: string, sourcePath: string, targetPath: string, options?: {
+    expected_source_sha256?: string;
+    expected_target_sha256?: string;
+}, config?: PatchWardenConfig): SyncFileResult;

package/dist/tools/syncFile.js

@@ -0,0 +1,65 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { PatchWardenError } from "../errors.js";
+import { getConfig } from "../config.js";
+import { guardDirectPath, guardDirectWritePath } from "../direct/directGuards.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { computeFileSha256 } from "../direct/directPatch.js";
+/**
+ * Copy a file from source to target within the same session repo.
+ * Both source and target must be inside the session's repo_path.
+ */
+export function syncFile(sessionId, sourcePath, targetPath, options, config) {
+    const cfg = config || getConfig();
+    const sessionsDir = resolve(cfg.workspaceRoot, cfg.directSessionsDir);
+    // Load session to get repo_path
+    const sessionFile = resolve(sessionsDir, sessionId, "session.json");
+    if (!existsSync(sessionFile)) {
+        throw new PatchWardenError("direct_session_not_found", `Direct session "${sessionId}" not found.`, "Create a direct session first using direct_start_session.", true, { session_id: sessionId });
+    }
+    const session = JSON.parse(readFileSync(sessionFile, "utf-8"));
+    const repoPath = resolve(session.repo_path);
+    const workspaceRoot = cfg.workspaceRoot;
+    // Guard source path — must be inside repo
+    const resolvedSource = guardDirectPath(sourcePath, repoPath, workspaceRoot);
+    guardSensitivePath(resolvedSource);
+    if (!existsSync(resolvedSource)) {
+        throw new PatchWardenError("source_file_not_found", `Source file does not exist: "${sourcePath}".`, "Ensure the source path is correct.", true, { source_path: sourcePath });
+    }
+    // Guard target path — must be inside repo, not in blocked dirs
+    const resolvedTarget = guardDirectWritePath(targetPath, repoPath, workspaceRoot);
+    guardSensitivePath(resolvedTarget);
+    // Verify source sha256 if provided
+    const sourceSha256 = computeFileSha256(resolvedSource);
+    if (options?.expected_source_sha256 && options.expected_source_sha256 !== sourceSha256) {
+        throw new PatchWardenError("source_hash_mismatch", `Source file hash mismatch. Expected "${options.expected_source_sha256}" but got "${sourceSha256}".`, "Re-read the source file to get the current sha256.", true, { expected_sha256: options.expected_source_sha256, actual_sha256: sourceSha256 });
+    }
+    // Get target sha256 before copy
+    let beforeTargetSha256 = null;
+    if (existsSync(resolvedTarget)) {
+        beforeTargetSha256 = computeFileSha256(resolvedTarget);
+        // Verify target sha256 if provided
+        if (options?.expected_target_sha256 && options.expected_target_sha256 !== beforeTargetSha256) {
+            throw new PatchWardenError("target_hash_mismatch", `Target file hash mismatch. Expected "${options.expected_target_sha256}" but got "${beforeTargetSha256}".`, "Re-read the target file to get the current sha256.", true, { expected_sha256: options.expected_target_sha256, actual_sha256: beforeTargetSha256 });
+        }
+    }
+    // Read source content
+    const sourceContent = readFileSync(resolvedSource);
+    const copiedBytes = sourceContent.length;
+    // Create target directory if needed
+    mkdirSync(dirname(resolvedTarget), { recursive: true });
+    // Write to target
+    writeFileSync(resolvedTarget, sourceContent, "utf-8");
+    // Compute after hash
+    const afterTargetSha256 = computeFileSha256(resolvedTarget);
+    const changed = beforeTargetSha256 !== afterTargetSha256;
+    return {
+        source_path: sourcePath,
+        target_path: targetPath,
+        before_target_sha256: beforeTargetSha256,
+        after_target_sha256: afterTargetSha256,
+        source_sha256: sourceSha256,
+        copied_bytes: copiedBytes,
+        changed,
+    };
+}

package/dist/tools/taskOutputs.d.ts

@@ -14,7 +14,7 @@ export declare function getTaskLogTail(taskId: string, file: "stdout" | "stderr"
     lines?: number;
     redact?: boolean;
 }): {
-    file: "stdout" | "stderr" | "test" | "verify";
+    file: "test" | "stdout" | "stderr" | "verify";
     lines: number;
     total_bytes: number;
     task_id: string;
@@ -37,7 +37,7 @@ export declare function getTaskLogTail(taskId: string, file: "stdout" | "stderr"
     truncated?: undefined;
 } | {
     task_id: string;
-    file: "stdout" | "stderr" | "test" | "verify";
+    file: "test" | "stdout" | "stderr" | "verify";
     filename: string;
     content: string;
     available: boolean;

package/dist/tools/toolCatalog.d.ts

@@ -12,8 +12,8 @@ export interface ToolCatalogSnapshot {
     tool_names: string[];
     tool_manifest_sha256: string;
 }
-export declare const CHATGPT_CORE_TOOL_NAMES: readonly ["health_check", "list_agents", "list_workspace", "read_workspace_file", "save_plan", "create_task", "wait_for_task", "get_task_summary", "get_diff", "get_result", "get_result_json", "get_test_log", "get_task_status", "list_tasks", "cancel_task", "audit_task"];
-export declare const CHATGPT_DIRECT_TOOL_NAMES: readonly ["health_check", "list_workspace", "create_direct_session", "search_workspace", "read_workspace_file", "apply_patch", "run_verification", "finalize_direct_session", "audit_session"];
+export declare const CHATGPT_CORE_TOOL_NAMES: readonly ["health_check", "list_agents", "list_workspace", "read_workspace_file", "save_plan", "create_task", "wait_for_task", "get_task_summary", "get_diff", "get_result", "get_result_json", "get_test_log", "get_task_status", "list_tasks", "cancel_task", "audit_task", "safe_status"];
+export declare const CHATGPT_DIRECT_TOOL_NAMES: readonly ["health_check", "list_workspace", "create_direct_session", "search_workspace", "read_workspace_file", "apply_patch", "run_verification", "finalize_direct_session", "audit_session", "sync_file"];
 export declare function resolveToolProfile(configProfile?: string): ToolProfile;
 export declare function selectToolsForProfile<T extends CatalogTool>(tools: T[], profile: ToolProfile, enableDirectProfile?: boolean): T[];
 export declare function buildToolCatalogSnapshot(tools: CatalogTool[], profile: ToolProfile): ToolCatalogSnapshot;

package/dist/tools/toolCatalog.js

@@ -17,6 +17,7 @@ export const CHATGPT_CORE_TOOL_NAMES = [
     "list_tasks",
     "cancel_task",
     "audit_task",
+    "safe_status",
 ];
 export const CHATGPT_DIRECT_TOOL_NAMES = [
     "health_check",
@@ -28,6 +29,7 @@ export const CHATGPT_DIRECT_TOOL_NAMES = [
     "run_verification",
     "finalize_direct_session",
     "audit_session",
+    "sync_file",
 ];
 let lastSnapshot = null;
 export function resolveToolProfile(configProfile) {

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PATCHWARDEN_VERSION = "0.6.0";
-export declare const TOOL_SCHEMA_EPOCH = "2026-06-22-v6";
+export declare const PATCHWARDEN_VERSION = "0.6.1";
+export declare const TOOL_SCHEMA_EPOCH = "2026-06-24-v7";

package/dist/version.js

@@ -1,2 +1,2 @@
-export const PATCHWARDEN_VERSION = "0.6.0";
-export const TOOL_SCHEMA_EPOCH = "2026-06-22-v6";
+export const PATCHWARDEN_VERSION = "0.6.1";
+export const TOOL_SCHEMA_EPOCH = "2026-06-24-v7";

package/dist/watcherStatus.d.ts

@@ -11,6 +11,7 @@ export interface WatcherStatusSnapshot {
     instance_id: string | null;
     launcher_pid: number | null;
     reason: string | null;
+    activity: string | null;
 }
 export declare function getWatcherHeartbeatPath(config?: PatchWardenConfig): string;
 export declare function readWatcherStatus(config?: PatchWardenConfig, nowMs?: number): WatcherStatusSnapshot;

package/dist/watcherStatus.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getConfig, getTasksDir } from "./config.js";
 export function getWatcherHeartbeatPath(config = getConfig()) {
@@ -8,6 +8,22 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
     const staleAfterSeconds = config.watcherStaleSeconds;
     const heartbeatPath = getWatcherHeartbeatPath(config);
     if (!existsSync(heartbeatPath)) {
+        // Even if watcher heartbeat is missing, check if a task is actively running
+        const taskFallback = checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds);
+        if (taskFallback) {
+            return {
+                status: "healthy",
+                available: true,
+                stale_after_seconds: staleAfterSeconds,
+                last_heartbeat_at: taskFallback.heartbeat_at,
+                heartbeat_age_seconds: taskFallback.age_seconds,
+                heartbeat_pid: null,
+                instance_id: null,
+                launcher_pid: null,
+                reason: null,
+                activity: taskFallback.activity,
+            };
+        }
         return {
             status: "missing",
             available: false,
@@ -18,6 +34,7 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
             instance_id: null,
             launcher_pid: null,
             reason: "Watcher heartbeat has not been observed. Start or restart the PatchWarden watcher.",
+            activity: null,
         };
     }
     try {
@@ -29,16 +46,47 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
         const ageMs = Math.max(0, nowMs - heartbeatMs);
         const ageSeconds = Math.round(ageMs / 1000);
         const healthy = ageMs < staleAfterSeconds * 1000;
+        if (healthy) {
+            return {
+                status: "healthy",
+                available: true,
+                stale_after_seconds: staleAfterSeconds,
+                last_heartbeat_at: String(data.last_heartbeat_at),
+                heartbeat_age_seconds: ageSeconds,
+                heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
+                instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
+                launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
+                reason: null,
+                activity: null,
+            };
+        }
+        // Watcher heartbeat is stale — check if a task is actively running
+        const taskFallback = checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds);
+        if (taskFallback) {
+            return {
+                status: "healthy",
+                available: true,
+                stale_after_seconds: staleAfterSeconds,
+                last_heartbeat_at: taskFallback.heartbeat_at,
+                heartbeat_age_seconds: taskFallback.age_seconds,
+                heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
+                instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
+                launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
+                reason: null,
+                activity: taskFallback.activity,
+            };
+        }
         return {
-            status: healthy ? "healthy" : "stale",
-            available: healthy,
+            status: "stale",
+            available: false,
             stale_after_seconds: staleAfterSeconds,
             last_heartbeat_at: String(data.last_heartbeat_at),
             heartbeat_age_seconds: ageSeconds,
             heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
             instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
             launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
-            reason: healthy ? null : "Watcher heartbeat is stale. Restart the PatchWarden watcher.",
+            reason: "Watcher heartbeat is stale. Restart the PatchWarden watcher.",
+            activity: null,
         };
     }
     catch {
@@ -52,9 +100,53 @@ export function readWatcherStatus(config = getConfig(), nowMs = Date.now()) {
             instance_id: null,
             launcher_pid: null,
             reason: "Watcher heartbeat file is unreadable.",
+            activity: null,
         };
     }
 }
+function checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds) {
+    const tasksDir = getTasksDir(config);
+    if (!existsSync(tasksDir))
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(tasksDir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const taskDir = join(tasksDir, entry.name);
+        const statusFile = join(taskDir, "status.json");
+        const runtimeFile = join(taskDir, "runtime.json");
+        if (!existsSync(statusFile) || !existsSync(runtimeFile))
+            continue;
+        try {
+            const status = JSON.parse(readFileSync(statusFile, "utf-8"));
+            if (status.status !== "running")
+                continue;
+            const runtime = JSON.parse(readFileSync(runtimeFile, "utf-8"));
+            const heartbeatAt = String(runtime.last_heartbeat_at || "");
+            const heartbeatMs = Date.parse(heartbeatAt);
+            if (!Number.isFinite(heartbeatMs))
+                continue;
+            const ageMs = Math.max(0, nowMs - heartbeatMs);
+            if (ageMs < staleAfterSeconds * 1000) {
+                return {
+                    heartbeat_at: heartbeatAt,
+                    age_seconds: Math.round(ageMs / 1000),
+                    activity: `watcher busy executing task ${entry.name}`,
+                };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
 export function derivePendingReason(task, watcher) {
     if (task.status === "pending") {
         if (watcher.status === "stale")

package/docs/performance-notes.md

@@ -0,0 +1,55 @@
+# PatchWarden Performance Notes
+
+## Current State (v0.6.1)
+
+### Identified Optimization Opportunities
+
+The following performance optimizations have been identified for future implementation. They are documented here rather than implemented in v0.6.1 to avoid introducing risk to the core task execution path.
+
+### 1. Async Git Operations in changeCapture.ts
+
+**Current**: `runGit()` uses `spawnSync()` which blocks the event loop during git operations.
+
+**Proposed**: Replace with `execFile()` (async) and use `Promise.all()` for independent git queries in `captureRepoSnapshot()`.
+
+**Risk**: Medium — changes the core change capture path. Requires careful testing of all snapshot/diff/scope scenarios.
+
+**Expected Benefit**: ~200-500ms improvement per task for repos with many files, as multiple git queries can run concurrently.
+
+### 2. Streaming File Hash
+
+**Current**: `computeFileSha256()` reads the entire file into memory with `readFileSync()`.
+
+**Proposed**: Use `createReadStream()` + `crypto.createHash()` for streaming hash computation.
+
+**Risk**: Low — isolated to hash computation, no semantic change.
+
+**Expected Benefit**: Reduces peak memory usage for large files (e.g., release artifacts > 5MB).
+
+### 3. Workspace Snapshot Caching
+
+**Current**: `walkWorkspace()` traverses the entire workspace directory tree on every snapshot.
+
+**Proposed**: Cache the directory listing and invalidate on file modification events.
+
+**Risk**: High — requires file system watchers and cache invalidation logic. Could introduce stale data bugs.
+
+**Expected Benefit**: ~100-1000ms improvement for large workspaces with many repos.
+
+### 4. Parallel Task Status Reads
+
+**Current**: `listTasks()` reads each task's `status.json` sequentially.
+
+**Proposed**: Use `Promise.all()` to read multiple task status files concurrently.
+
+**Risk**: Low — read-only operation, no semantic change.
+
+**Expected Benefit**: ~50-200ms improvement when listing 10+ tasks.
+
+## Decision for v0.6.1
+
+All four optimizations are deferred to a future release. The current synchronous implementation is correct and well-tested. Changing the core paths would require extensive regression testing that is beyond the scope of this stability release.
+
+## Monitoring
+
+The structured logging module (`src/logging.ts`) added in v0.6.1 provides the infrastructure to measure tool call durations (`duration_ms` in audit logs). Once deployed, real-world timing data can be collected to prioritize which optimization to implement first.

package/docs/release-v0.6.1.md

@@ -0,0 +1,75 @@
+# PatchWarden v0.6.1 Release Notes
+
+**Release Date**: 2026-06-25
+
+## Overview
+
+PatchWarden v0.6.1 is a stability and observability release. It addresses watcher heartbeat false positives, adds Chinese path reliability, introduces two new tools (`safe_status` and `sync_file`), and adds comprehensive security guard unit tests.
+
+## New Features
+
+### safe_status Tool
+
+A minimal task lifecycle status tool that returns task state without exposing diff, log content, or file contents. Useful when upper-layer security policies block content-bearing tools.
+
+```json
+{
+  "task_id": "task-001",
+  "status": "running",
+  "phase": "executing_agent",
+  "last_heartbeat_at": "2026-06-24T10:00:12Z",
+  "current_command": "codex exec",
+  "watcher_state": "healthy"
+}
+```
+
+### sync_file Tool
+
+Copy a file from source to target within a Direct session repo. Both paths must be inside the session's `repo_path`. Supports optional sha256 verification for both source and target.
+
+### Android Build Doctor
+
+When a managed project contains an `android_app` directory, the health check now includes Android build environment diagnostics: Java version, JAVA_HOME, ANDROID_HOME, SDK platform, build-tools, Gradle wrapper, and APK output path.
+
+## Bug Fixes
+
+- **Watcher stale false positive**: Long-running tasks no longer cause the watcher to be incorrectly reported as stale. The watcher status now falls back to checking running task heartbeats.
+- **Chinese path encoding**: All file I/O operations verified to use UTF-8 encoding. Health check now reports `path_encoding` status.
+- **Tracked external dirty detection**: `captureRepoSnapshot` now correctly identifies tracked-but-modified external files via `dirty_paths` field parsed from `git status --porcelain`. The regex now includes `R` (rename) status, fixing dead code that previously never executed for renamed files.
+- **Release zip path separators**: The packaging script (`pack-clean.js`) now creates zip archives with POSIX `/` path separators instead of Windows backslashes. Linux `unzip` no longer reports `warning: appears to use backslashes as path separators`.
+
+## Security
+
+- 136 unit tests covering all security guards (path guard, sensitive guard, command guard, direct guards)
+- Tests use Node's built-in `node:test` — zero new dependencies
+
+## Observability
+
+- Structured JSON logging to stderr (never stdout, to avoid polluting MCP JSON-RPC)
+- Tool call audit logs with duration tracking
+- Global `unhandledRejection` and `uncaughtException` handlers
+
+## Tool Profile Changes
+
+| Profile | v0.6.0 | v0.6.1 |
+|---------|--------|--------|
+| full | 28 | 30 |
+| chatgpt_core | 16 | 17 |
+| chatgpt_direct | 9 | 10 |
+
+## Migration
+
+No breaking changes. All new fields are optional. New tools are additive and do not affect existing tools.
+
+## Verification
+
+- TypeScript compilation: PASS
+- Unit tests: 136 pass, 0 fail, 1 skipped (Windows symlink)
+- Smoke tests: 139 pass, 0 fail
+- Lifecycle tests: 22 pass, 0 fail (includes tracked external file rename regression test)
+- Doctor CI: PASS (81 OK, 0 WARN, 0 FAIL on the release check host)
+- Tool manifest check: PASS
+- Package manifest check: PASS (260 files)
+- Brand check: PASS (128 tracked files)
+- MCP HTTP tests: 13 pass, 0 fail
+- Release zip: POSIX path separators verified (261 entries, no backslashes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchwarden",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "A secure local MCP bridge: clients save plans, local agents execute tasks, and results are returned through workspace-scoped files.",
   "type": "module",
   "main": "dist/index.js",
@@ -34,7 +34,8 @@
     "watch": "node dist/runner/watch.js",
     "doctor": "node dist/doctor.js",
     "doctor:ci": "node dist/doctor.js --allow-default-config",
-    "test": "node dist/smoke-test.js && node scripts/lifecycle-smoke.js && node scripts/doctor-smoke.js && node scripts/tunnel-supervisor-smoke.js && node scripts/watcher-supervisor-smoke.js && node scripts/control-smoke.js && node scripts/mcp-manifest-check.js && node scripts/brand-check.js",
+    "test:unit": "node scripts/unit-tests.js",
+    "test": "node dist/smoke-test.js && node scripts/unit-tests.js && node scripts/lifecycle-smoke.js && node scripts/doctor-smoke.js && node scripts/tunnel-supervisor-smoke.js && node scripts/watcher-supervisor-smoke.js && node scripts/control-smoke.js && node scripts/mcp-manifest-check.js && node scripts/brand-check.js",
     "test:lifecycle": "npm run build && node scripts/lifecycle-smoke.js",
     "test:doctor": "npm run build && node scripts/doctor-smoke.js",
     "test:tunnel-supervisor": "npm run build && node scripts/tunnel-supervisor-smoke.js",

package/scripts/http-mcp-smoke.js

@@ -139,7 +139,7 @@ try {
     serverStderr += chunk.toString();
   });
 
-  await sleep(1000);
+  await sleep(3000);
   if (serverProcess.exitCode !== null) {
     throw new Error(`HTTP server exited early: ${serverStderr}`);
   }
@@ -274,7 +274,15 @@ try {
     stdio: ["ignore", "ignore", "pipe"],
   });
   serverProcess.stderr.on("data", (chunk) => { serverStderr += chunk.toString(); });
-  await sleep(1000);
+  await sleep(3000);
+  // Wait for server to be ready
+  for (let i = 0; i < 10; i++) {
+    try {
+      const r = await fetch(`${mcpUrl}/healthz`);
+      if (r.status === 200) break;
+    } catch {}
+    await sleep(500);
+  }
 
   await test("token: no token returns 401", async () => {
     try {