patchwarden 1.5.0 → 1.5.1

package/src/tools/dispatch/goalDispatch.ts

@@ -0,0 +1,127 @@
+/**
+ * Dispatch handlers for Goal Session tools (v0.8.0+).
+ *
+ * Covers goal lifecycle, subgoal management, Spec Kit import,
+ * worktree merge/discard, and goal reporting.
+ */
+
+import { createGoal, listGoals, readGoal, readGoalStatus } from "../../goal/goalStore.js";
+import { suggestNextSubgoal } from "../../goal/goalGraph.js";
+import { exportHandoff } from "../../goal/handoffExport.js";
+import { acceptSubgoal, rejectSubgoal, summarizeGoalProgress } from "../../goal/goalProgress.js";
+import { exportGoalReport } from "../../goal/goalReport.js";
+import { importSpecKitTasks, parseSpecKitJson } from "../../goal/specKitImport.js";
+import { createSubgoalTask } from "../goalSubgoalTask.js";
+import { mergeWorktreeTool } from "../mergeWorktree.js";
+import { discardWorktreeTool } from "../discardWorktree.js";
+import type { ToolHandlerMap } from "./types.js";
+import { toResult } from "./types.js";
+
+export const goalHandlers: ToolHandlerMap = {
+  create_goal: async (args) => {
+    return toResult(
+      createGoal(
+        String(args?.repo_path ?? ""),
+        String(args?.title ?? ""),
+        String(args?.goal_description ?? ""),
+      ),
+    );
+  },
+
+  list_goals: async () => {
+    return toResult({ goals: listGoals() });
+  },
+
+  read_goal: async (args) => {
+    return toResult(readGoal(String(args?.goal_id ?? "")));
+  },
+
+  create_subgoal_task: async (args) => {
+    return toResult(
+      await createSubgoalTask({
+        goal_id: String(args?.goal_id ?? ""),
+        subgoal_title: String(args?.subgoal_title ?? ""),
+        depends_on: Array.isArray(args?.depends_on) ? args.depends_on.map(String) : undefined,
+        plan_id: args?.plan_id ? String(args.plan_id) : undefined,
+        inline_plan: args?.inline_plan ? String(args.inline_plan) : undefined,
+        plan_title: args?.plan_title ? String(args.plan_title) : undefined,
+        template: args?.template ? (String(args.template) as any) : undefined,
+        goal: args?.goal ? String(args.goal) : undefined,
+        agent: args?.agent ? String(args.agent) : undefined,
+        repo_path: String(args?.repo_path ?? ""),
+        test_command: args?.test_command ? String(args.test_command) : undefined,
+        verify_commands: Array.isArray(args?.verify_commands)
+          ? args.verify_commands.map(String)
+          : undefined,
+        timeout_seconds: args?.timeout_seconds ? Number(args.timeout_seconds) : undefined,
+        scope: Array.isArray(args?.scope) ? args.scope.map(String) : undefined,
+        forbidden: Array.isArray(args?.forbidden) ? args.forbidden.map(String) : undefined,
+        verification: Array.isArray(args?.verification) ? args.verification.map(String) : undefined,
+        done_evidence: Array.isArray(args?.done_evidence) ? args.done_evidence.map(String) : undefined,
+        isolate_worktree:
+          args?.isolate_worktree === undefined ? undefined : Boolean(args.isolate_worktree),
+      }),
+    );
+  },
+
+  accept_subgoal: async (args) => {
+    return toResult(
+      acceptSubgoal(String(args?.goal_id ?? ""), String(args?.subgoal_id ?? "")),
+    );
+  },
+
+  reject_subgoal: async (args) => {
+    return toResult(
+      rejectSubgoal(
+        String(args?.goal_id ?? ""),
+        String(args?.subgoal_id ?? ""),
+        String(args?.reason ?? ""),
+      ),
+    );
+  },
+
+  suggest_next_subgoal: async (args) => {
+    const goalStatus = readGoalStatus(String(args?.goal_id ?? ""));
+    return toResult(suggestNextSubgoal(goalStatus));
+  },
+
+  summarize_goal_progress: async (args) => {
+    return toResult(summarizeGoalProgress(String(args?.goal_id ?? "")));
+  },
+
+  export_handoff: async (args) => {
+    const goalId = String(args?.goal_id ?? "");
+    const goalStatus = readGoalStatus(goalId);
+    return toResult(exportHandoff(goalId, goalStatus));
+  },
+
+  export_goal_report: async (args) => {
+    const goalId = String(args?.goal_id ?? "");
+    return toResult(exportGoalReport(goalId));
+  },
+
+  import_speckit_tasks: async (args) => {
+    const goalId = String(args?.goal_id ?? "");
+    const jsonText = String(args?.spec_kit_json ?? "");
+    const input = parseSpecKitJson(jsonText);
+    return toResult(importSpecKitTasks(goalId, input));
+  },
+
+  merge_worktree: async (args) => {
+    return toResult(
+      mergeWorktreeTool({
+        worktree_id: String(args?.worktree_id ?? ""),
+        repo_path: String(args?.repo_path ?? ""),
+      }),
+    );
+  },
+
+  discard_worktree: async (args) => {
+    return toResult(
+      discardWorktreeTool({
+        worktree_id: String(args?.worktree_id ?? ""),
+        repo_path: String(args?.repo_path ?? ""),
+      }),
+    );
+  },
+};

package/src/tools/dispatch/releaseDispatch.ts

@@ -0,0 +1,65 @@
+/**
+ * Dispatch handlers for release-mode tools (v1.3.0+).
+ *
+ * Wraps releaseCheck, releasePrepare, releaseVerify, and releaseCleanup
+ * from releaseMode.ts.
+ */
+
+import {
+  releaseCheck,
+  releasePrepare,
+  releaseVerify,
+  releaseCleanup,
+} from "../releaseMode.js";
+import type { ToolHandlerMap } from "./types.js";
+import { toResult } from "./types.js";
+
+export const releaseHandlers: ToolHandlerMap = {
+  release_check: async (args) => {
+    return toResult(
+      await releaseCheck({
+        repo_path: String(args?.repo_path ?? ""),
+        target_stage: String(args?.target_stage ?? "local_ready") as any,
+        package_name: args?.package_name ? String(args.package_name) : undefined,
+        version: args?.version ? String(args.version) : undefined,
+        github_repo: args?.github_repo ? String(args.github_repo) : undefined,
+        branch: args?.branch ? String(args.branch) : undefined,
+      }),
+    );
+  },
+
+  release_prepare: async (args) => {
+    return toResult(
+      releasePrepare({
+        repo_path: String(args?.repo_path ?? ""),
+        required_commands: Array.isArray(args?.required_commands)
+          ? args.required_commands.map(String)
+          : undefined,
+        timeout_seconds:
+          args?.timeout_seconds !== undefined ? Number(args.timeout_seconds) : undefined,
+      }),
+    );
+  },
+
+  release_verify: async (args) => {
+    return toResult(
+      await releaseVerify({
+        repo_path: String(args?.repo_path ?? ""),
+        package_name: args?.package_name ? String(args.package_name) : undefined,
+        version: args?.version ? String(args.version) : undefined,
+        github_repo: args?.github_repo ? String(args.github_repo) : undefined,
+        branch: args?.branch ? String(args.branch) : undefined,
+      }),
+    );
+  },
+
+  release_cleanup: async (args) => {
+    return toResult(
+      releaseCleanup({
+        repo_path: String(args?.repo_path ?? ""),
+        dry_run: args?.dry_run !== undefined ? Boolean(args.dry_run) : undefined,
+        patterns: Array.isArray(args?.patterns) ? args.patterns.map(String) : undefined,
+      }),
+    );
+  },
+};

package/src/tools/dispatch/types.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared types and helpers for the dispatch map.
+ *
+ * Each domain dispatch file exports a `ToolHandlerMap` whose handlers
+ * directly call the existing tool functions — no logic is rewritten.
+ */
+
+export type ToolHandler = (
+  args: Record<string, unknown> | undefined,
+) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+export type ToolHandlerMap = Record<string, ToolHandler>;
+
+/**
+ * Wrap a plain data value into the MCP CallToolResult content envelope.
+ * Mirrors the original `toResult` helper from registry.ts.
+ */
+export function toResult(data: unknown): {
+  content: Array<{ type: string; text: string }>;
+} {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+  };
+}

package/src/tools/evidencePack.ts

@@ -1,8 +1,9 @@
+import { execSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { getConfig } from "../config.js";
 import { guardReadPath, guardWorkspacePath } from "../security/pathGuard.js";
-import { redactSensitiveValue } from "../security/contentRedaction.js";
+import { countRedactionsByCategory, redactSensitiveValue } from "../security/contentRedaction.js";
 import { getProjectPolicySummary } from "../policy/projectPolicy.js";
 import { getTaskLineage, type SafeTaskLineage } from "./taskLineage.js";
 import { getLastToolCatalogSnapshot } from "./toolCatalog.js";
@@ -17,6 +18,12 @@ export interface SafeEvidencePack {
   files: {
     json: string;
     markdown: string;
+    risk: string;
+    verify: string;
+    diffstat: string;
+    lineage: string;
+    attestation: string;
+    redactions: string;
   };
   lineage: SafeTaskLineage;
   policy: {
@@ -48,15 +55,63 @@ export function exportTaskEvidencePack(input: { lineage_id: string; max_items?:
   const policySummary = readPolicySummary(lineage.repo_path);
   const catalog = safeCatalog();
   const generatedAt = new Date().toISOString();
+
+  const filePaths = {
+    json: join(packDir, "evidence.json"),
+    markdown: join(packDir, "EVIDENCE.md"),
+    risk: join(packDir, "risk.json"),
+    verify: join(packDir, "verify.json"),
+    diffstat: join(packDir, "diffstat.json"),
+    lineage: join(packDir, "lineage.json"),
+    attestation: join(packDir, "attestation.json"),
+    redactions: join(packDir, "redactions.json"),
+  };
+
+  // Build v2 structured artifact contents (raw, before redaction).
+  const riskContent = buildRiskContent(lineage);
+  const verifyContent = buildVerifyContent(lineage);
+  const diffstatContent = buildDiffstatContent(lineage, config);
+  const lineageSummary = buildLineageSummary(lineage);
+  const attestationContent = buildAttestation(catalog, generatedAt);
+
+  // Count redactions across all v2 raw contents for the audit trail.
+  const v2RawPayloads = [
+    riskContent,
+    verifyContent,
+    diffstatContent,
+    lineageSummary,
+    attestationContent,
+  ].map((value) => JSON.stringify(value));
+  const aggregated = new Map<string, { category: string; reason: string; count: number }>();
+  for (const raw of v2RawPayloads) {
+    for (const entry of countRedactionsByCategory(raw)) {
+      const existing = aggregated.get(entry.category);
+      if (existing) existing.count += entry.count;
+      else aggregated.set(entry.category, { category: entry.category, reason: entry.reason, count: entry.count });
+    }
+  }
+  const redactionsList = [...aggregated.values()];
+  const redactionsContent = {
+    redactions: redactionsList,
+    total_redacted: redactionsList.reduce((sum, entry) => sum + entry.count, 0),
+    bounded: true,
+    note: "Only categories and counts are recorded; original secret values are never persisted.",
+  };
+
+  // Redact and write each v2 file.
+  writeFileSync(filePaths.risk, JSON.stringify(redactSensitiveValue(riskContent).value, null, 2) + "\n", "utf-8");
+  writeFileSync(filePaths.verify, JSON.stringify(redactSensitiveValue(verifyContent).value, null, 2) + "\n", "utf-8");
+  writeFileSync(filePaths.diffstat, JSON.stringify(redactSensitiveValue(diffstatContent).value, null, 2) + "\n", "utf-8");
+  writeFileSync(filePaths.lineage, JSON.stringify(redactSensitiveValue(lineageSummary).value, null, 2) + "\n", "utf-8");
+  writeFileSync(filePaths.attestation, JSON.stringify(redactSensitiveValue(attestationContent).value, null, 2) + "\n", "utf-8");
+  writeFileSync(filePaths.redactions, JSON.stringify(redactSensitiveValue(redactionsContent).value, null, 2) + "\n", "utf-8");
+
   const safePack = redactSensitiveValue({
     evidence_pack_id: `evidence_${lineageId}`,
     lineage_id: lineageId,
     generated_at: generatedAt,
     path: packDir,
-    files: {
-      json: join(packDir, "evidence.json"),
-      markdown: join(packDir, "EVIDENCE.md"),
-    },
+    files: filePaths,
     lineage,
     policy: {
       valid: policySummary.valid,
@@ -64,7 +119,16 @@ export function exportTaskEvidencePack(input: { lineage_id: string; max_items?:
       release_readiness: policySummary.release_readiness,
     },
     catalog,
-    omitted: ["stdout", "stderr", "diff", "verification command logs", "full artifact markdown", "sensitive file contents"],
+    omitted: [
+      "stdout",
+      "stderr",
+      "diff",
+      "verification command logs",
+      "full artifact markdown",
+      "sensitive file contents",
+      "raw secret values (redactions.json stores only categories and counts)",
+      "full diff content (diffstat.json stores only file-level line counts)",
+    ],
     next_action: buildNextAction(lineage),
     bounded: true,
   }).value as SafeEvidencePack;
@@ -168,6 +232,217 @@ function buildNextAction(lineage: SafeTaskLineage): string {
   return lineage.next_action || "Review lineage before exporting release evidence.";
 }
 
+type RiskSeverity = "high" | "medium" | "low";
+
+interface RiskItem {
+  source: string;
+  task_id?: string;
+  severity: RiskSeverity;
+  category: string;
+  detail: string;
+}
+
+function buildRiskContent(lineage: SafeTaskLineage): { risks: RiskItem[]; count: number; by_severity: Record<RiskSeverity, number> } {
+  const risks: RiskItem[] = [];
+  for (const round of lineage.rounds) {
+    for (const check of round.fail_checks) {
+      risks.push({ source: "round", task_id: round.task_id, severity: "high", category: "fail_check", detail: check });
+    }
+    for (const check of round.warn_checks) {
+      risks.push({ source: "round", task_id: round.task_id, severity: "medium", category: "warn_check", detail: check });
+    }
+  }
+  for (const warning of lineage.warnings) {
+    risks.push({ source: "lineage", severity: "low", category: "warning", detail: warning });
+  }
+  const by_severity: Record<RiskSeverity, number> = {
+    high: risks.filter((risk) => risk.severity === "high").length,
+    medium: risks.filter((risk) => risk.severity === "medium").length,
+    low: risks.filter((risk) => risk.severity === "low").length,
+  };
+  return { risks, count: risks.length, by_severity };
+}
+
+interface VerifyRecord {
+  source: string;
+  task_id?: string;
+  role?: string;
+  session_id?: string;
+  verification_status: string;
+  audit_verdict: string;
+  passed: boolean;
+  command_count?: number;
+  passed_commands?: number;
+  failed_commands?: number;
+}
+
+function buildVerifyContent(lineage: SafeTaskLineage): {
+  records: VerifyRecord[];
+  count: number;
+  summary: { total: number; passed: number; failed: number };
+  latest_status: string;
+  overall_passed: boolean;
+} {
+  const records: VerifyRecord[] = [];
+  for (const round of lineage.rounds) {
+    records.push({
+      source: "round",
+      task_id: round.task_id,
+      role: round.role,
+      verification_status: round.verification_status,
+      audit_verdict: round.audit_verdict,
+      passed: round.verification_status === "passed",
+    });
+  }
+  for (const session of lineage.tasks.direct_sessions) {
+    records.push({
+      source: "direct_session",
+      session_id: session.session_id,
+      verification_status: session.status || "unknown",
+      audit_verdict: session.audit_decision || "not_run",
+      passed: session.status === "passed",
+      command_count: session.command_count,
+      passed_commands: session.passed_commands,
+      failed_commands: session.failed_commands,
+    });
+  }
+  const passed = records.filter((record) => record.passed).length;
+  return {
+    records,
+    count: records.length,
+    summary: { total: records.length, passed, failed: records.length - passed },
+    latest_status: lineage.verification.latest_status,
+    overall_passed: lineage.verification.passed,
+  };
+}
+
+interface DiffstatFile {
+  path: string;
+  status: string;
+  additions: number;
+  deletions: number;
+  task_id: string;
+}
+
+function buildDiffstatContent(
+  lineage: SafeTaskLineage,
+  config: ReturnType<typeof getConfig>
+): { files: DiffstatFile[]; count: number; totals: { additions: number; deletions: number } } {
+  const taskIds = [
+    lineage.tasks.main,
+    ...lineage.tasks.fix,
+    ...lineage.tasks.cleanup,
+  ].filter((id): id is string => Boolean(id));
+
+  const files: DiffstatFile[] = [];
+  let totalAdditions = 0;
+  let totalDeletions = 0;
+
+  for (const taskId of taskIds) {
+    if (!/^[A-Za-z0-9_-]+$/.test(taskId)) continue;
+    const statsPath = resolve(config.workspaceRoot, config.tasksDir, taskId, "file-stats.json");
+    try {
+      guardWorkspacePath(statsPath, config.workspaceRoot);
+      if (!existsSync(statsPath)) continue;
+      const raw = readFileSync(statsPath, "utf-8").replace(/^\uFEFF/, "");
+      const stats = JSON.parse(raw) as { files?: Array<{ path?: unknown; status?: unknown; additions?: unknown; deletions?: unknown }> };
+      if (!Array.isArray(stats.files)) continue;
+      for (const file of stats.files) {
+        const additions = Number(file.additions) || 0;
+        const deletions = Number(file.deletions) || 0;
+        files.push({
+          path: String(file.path || ""),
+          status: String(file.status || "unknown"),
+          additions,
+          deletions,
+          task_id: taskId,
+        });
+        totalAdditions += additions;
+        totalDeletions += deletions;
+      }
+    } catch {
+      // Skip unreadable or malformed file-stats.json entries.
+    }
+  }
+
+  return {
+    files,
+    count: files.length,
+    totals: { additions: totalAdditions, deletions: totalDeletions },
+  };
+}
+
+function buildLineageSummary(lineage: SafeTaskLineage): {
+  lineage_id: string;
+  goal: string;
+  final_status: string;
+  stop_reason: string;
+  iterations_count: number;
+  task_counts: { main: number; fix: number; cleanup: number; direct_sessions: number };
+  verification: { latest_status: string; passed: boolean };
+  worktree: { isolation_mode: string; status: string };
+  agent_routing: { selected_agent: string } | null;
+  warnings_count: number;
+  errors_count: number;
+  truncated: boolean;
+} {
+  return {
+    lineage_id: lineage.lineage_id,
+    goal: lineage.goal,
+    final_status: lineage.final_status,
+    stop_reason: lineage.stop_reason,
+    iterations_count: lineage.rounds.length,
+    task_counts: {
+      main: lineage.tasks.main ? 1 : 0,
+      fix: lineage.tasks.fix.length,
+      cleanup: lineage.tasks.cleanup.length,
+      direct_sessions: lineage.tasks.direct_sessions.length,
+    },
+    verification: lineage.verification,
+    worktree: {
+      isolation_mode: lineage.worktree.isolation_mode,
+      status: lineage.worktree.status,
+    },
+    agent_routing: lineage.agent_routing ? { selected_agent: lineage.agent_routing.selected_agent } : null,
+    warnings_count: lineage.warnings.length,
+    errors_count: lineage.errors.length,
+    truncated: lineage.truncated,
+  };
+}
+
+function readGitCommitShort(): string {
+  try {
+    return execSync("git rev-parse --short HEAD", { encoding: "utf-8", timeout: 5000 }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+function buildAttestation(
+  catalog: SafeEvidencePack["catalog"],
+  generatedAt: string
+): {
+  patchwarden_version: string;
+  package_version: string;
+  commit: string;
+  node_version: string;
+  os: { platform: string; arch: string };
+  tool_profile: string | null;
+  schema_epoch: string;
+  generated_at: string;
+} {
+  return {
+    patchwarden_version: PATCHWARDEN_VERSION,
+    package_version: PATCHWARDEN_VERSION,
+    commit: readGitCommitShort(),
+    node_version: process.version,
+    os: { platform: process.platform, arch: process.arch },
+    tool_profile: catalog.tool_profile,
+    schema_epoch: catalog.schema_epoch,
+    generated_at: generatedAt,
+  };
+}
+
 function buildEvidenceMarkdown(pack: SafeEvidencePack): string {
   const direct = pack.lineage.tasks.direct_sessions
     .map((entry) => `- ${entry.session_id}: status=${entry.status || "unknown"}, audit=${entry.audit_decision || "unknown"}`)
@@ -196,6 +471,16 @@ function buildEvidenceMarkdown(pack: SafeEvidencePack): string {
     `- Policy valid: ${pack.policy.valid}`,
     `- Policy issue count: ${pack.policy.issue_count}`,
     "",
+    "## Evidence Pack v2 Files",
+    "- `evidence.json` — full bounded evidence pack (machine-readable).",
+    "- `EVIDENCE.md` — human-readable evidence summary.",
+    "- `risk.json` — aggregated risk items with severity (high/medium/low).",
+    "- `verify.json` — structured verification records per round and direct session.",
+    "- `diffstat.json` — file-level additions/deletions without full diff content.",
+    "- `lineage.json` — bounded lineage summary (goal, status, task counts).",
+    "- `attestation.json` — version, commit, Node/OS, tool profile, schema epoch.",
+    "- `redactions.json` — redaction categories and counts (no original secret values).",
+    "",
     "## Omitted",
     ...pack.omitted.map((item) => `- ${item}`),
     "",

package/src/tools/finalizeDirectSession.ts

@@ -37,9 +37,9 @@ export interface FinalizeDirectSessionOutput {
 
 // ── Main function ──────────────────────────────────────────────────
 
-export function finalizeDirectSession(
+export async function finalizeDirectSession(
   input: FinalizeDirectSessionInput
-): FinalizeDirectSessionOutput {
+): Promise<FinalizeDirectSessionOutput> {
   const { session_id } = input;
 
   // 1. Read session and guard active (not expired, not finalized)
@@ -47,10 +47,10 @@ export function finalizeDirectSession(
   guardDirectSessionActive(session);
 
   // 2. Capture after snapshot
-  const afterSnapshot = captureRepoSnapshot(session.resolved_repo_path);
+  const afterSnapshot = await captureRepoSnapshot(session.resolved_repo_path);
 
   // 3. Build change artifacts from before/after snapshots
-  const changeArtifacts = buildChangeArtifacts(
+  const changeArtifacts = await buildChangeArtifacts(
     session.resolved_repo_path,
     session.workspace_snapshot_before,
     afterSnapshot

package/src/tools/goalSubgoalTask.ts

@@ -64,7 +64,7 @@ export interface CreateSubgoalTaskOutput {
  * @throws PatchWardenError("invalid_dependency") 当 depends_on 引用不存在的 subgoal
  * @throws PatchWardenError("invalid_execution_mode") 当 execution_mode 为 "assess_only"
  */
-export function createSubgoalTask(input: CreateSubgoalTaskInput): CreateSubgoalTaskOutput {
+export async function createSubgoalTask(input: CreateSubgoalTaskInput): Promise<CreateSubgoalTaskOutput> {
   // assess_only 不产生 task，无法关联到 subgoal
   if (input.execution_mode === "assess_only") {
     throw new PatchWardenError(
@@ -113,7 +113,7 @@ export function createSubgoalTask(input: CreateSubgoalTaskInput): CreateSubgoalT
   // 3. 调用 createTask 创建关联任务（强制 execute 模式，确保返回 CreateTaskOutput）
   let taskId: string;
   try {
-    const taskResult = createTask({
+    const taskResult = await createTask({
       plan_id: input.plan_id,
       inline_plan: input.inline_plan,
       plan_title: input.plan_title,

package/src/tools/healthCheck.ts

@@ -195,14 +195,14 @@ function directoryStatus(path: string, allowCreatable: boolean, createRoot?: str
       try {
         accessSync(parent, constants.R_OK | constants.W_OK);
         return { available: true, path, readable: false, writable: true, reason: "Directory will be created on first use." };
-      } catch {}
+      } catch {} // probe failure handled by return value
     }
     return { available: false, path, readable: false, writable: false, reason: "Directory does not exist." };
   }
   let readable = false;
   let writable = false;
-  try { accessSync(path, constants.R_OK); readable = true; } catch {}
-  try { accessSync(path, constants.W_OK); writable = true; } catch {}
+  try { accessSync(path, constants.R_OK); readable = true; } catch {} // probe failure handled by return value
+  try { accessSync(path, constants.W_OK); writable = true; } catch {} // probe failure handled by return value
   return {
     available: readable && writable,
     path,