patchwarden 1.1.0 → 1.5.1

package/dist/tools/createTask.d.ts

@@ -101,5 +101,5 @@ export interface CreateTaskOutput {
 }
 export declare function createTask(input: CreateTaskInput & {
     execution_mode: "assess_only";
-}): AssessOnlyOutput;
-export declare function createTask(input: CreateTaskInput): CreateTaskOutput;
+}): Promise<AssessOnlyOutput>;
+export declare function createTask(input: CreateTaskInput): Promise<CreateTaskOutput>;

package/dist/tools/createTask.js

@@ -18,7 +18,7 @@ import { PATCHWARDEN_VERSION } from "../version.js";
 import { getLastToolCatalogSnapshot, resolveToolProfile } from "./toolCatalog.js";
 import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
 import { routeAgent } from "../agents/agentRouter.js";
-export function createTask(input) {
+export async function createTask(input) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
     const plansDir = getPlansDir(config);
@@ -151,7 +151,7 @@ export function createTask(input) {
             planBlocked = true;
             planBlockReason = e instanceof PatchWardenError ? e.reason : "plan_content_blocked";
         }
-        const snapshot = captureRepoSnapshot(safeRepoPath);
+        const snapshot = await captureRepoSnapshot(safeRepoPath);
         const snapshotTruncated = snapshot.warnings.some((w) => w.includes("snapshot limited"));
         let riskResult;
         if (planBlocked) {
@@ -208,7 +208,7 @@ export function createTask(input) {
             preGeneratedAssessmentId = generateAssessmentId();
             preGeneratedAssessmentDir = createAssessmentDir(preGeneratedAssessmentId);
             const assessorAgentName = config.agentAssessmentAgentName || effectiveInput.agent;
-            agentAssessmentSummary = runAgentAssessment({
+            agentAssessmentSummary = await runAgentAssessment({
                 assessmentId: preGeneratedAssessmentId,
                 assessmentDir: preGeneratedAssessmentDir,
                 agentName: assessorAgentName,
@@ -330,7 +330,7 @@ export function createTask(input) {
     }
     // ── execute mode with assessment_id: validate freshness ──
     if (assessmentRecord) {
-        const snapshot = captureRepoSnapshot(safeRepoPath);
+        const snapshot = await captureRepoSnapshot(safeRepoPath);
         const validation = validateAssessmentFreshness(input.assessment_id, snapshot);
         if (!validation.valid) {
             throw new PatchWardenError(validation.failure_reason || "assessment_validation_failed", `Assessment "${input.assessment_id}" is no longer valid: ${validation.failure_reason}`, "Re-run create_task with execution_mode=assess_only to get a fresh assessment_id.", true, { assessment_id: input.assessment_id, failure_reason: validation.failure_reason });

package/dist/tools/dispatch/coreDispatch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Dispatch handlers for core task-management tools.
+ *
+ * Each handler directly calls the existing tool function — no logic is
+ * rewritten. Extracted from the original handleToolCallInternal switch.
+ */
+import type { ToolHandlerMap } from "./types.js";
+export declare const coreHandlers: ToolHandlerMap;
+export declare const runTaskHandler: ToolHandlerMap["run_task"];

package/dist/tools/dispatch/coreDispatch.js

@@ -0,0 +1,282 @@
+/**
+ * Dispatch handlers for core task-management tools.
+ *
+ * Each handler directly calls the existing tool function — no logic is
+ * rewritten. Extracted from the original handleToolCallInternal switch.
+ */
+import { savePlan } from "../savePlan.js";
+import { getPlan } from "../getPlan.js";
+import { createTask } from "../createTask.js";
+import { getTaskStatus } from "../getTaskStatus.js";
+import { getResult, getResultJson, getDiff, getTestLog, getTaskLogTail } from "../taskOutputs.js";
+import { listWorkspace } from "../listWorkspace.js";
+import { readWorkspaceFile } from "../readWorkspaceFile.js";
+import { listTasks } from "../listTasks.js";
+import { cancelTask } from "../cancelTask.js";
+import { killTask } from "../killTask.js";
+import { retryTask } from "../retryTask.js";
+import { getTaskStdoutTail } from "../getTaskStdoutTail.js";
+import { getTaskProgress } from "../getTaskProgress.js";
+import { listAgents } from "../listAgents.js";
+import { healthCheck } from "../healthCheck.js";
+import { getTaskSummary } from "../getTaskSummary.js";
+import { waitForTask } from "../waitForTask.js";
+import { runTaskLoop } from "../runTaskLoop.js";
+import { getTaskLineage } from "../taskLineage.js";
+import { exportTaskEvidencePack } from "../evidencePack.js";
+import { recommendAgentForTask } from "../recommendAgentForTask.js";
+import { auditTask } from "../auditTask.js";
+import { safeStatus } from "../safeStatus.js";
+import { safeAudit, safeDiffSummary, safeResult, safeTestSummary } from "../safeViews.js";
+import { diagnoseTask } from "../diagnoseTask.js";
+import { reconcileTasks } from "../reconcileTasks.js";
+import { checkReleaseGate } from "../checkReleaseGate.js";
+import { getProjectPolicyTool } from "../releaseMode.js";
+import { runTask } from "../../runner/runTask.js";
+import { getConfig } from "../../config.js";
+import { getToolCatalogSnapshot } from "../registry.js";
+import { toResult } from "./types.js";
+// ── Local helpers (moved verbatim from registry.ts) ───────────────
+function normalizeWaitSeconds(args) {
+    const legacy = args?.wait_seconds;
+    const preferred = args?.timeout_seconds;
+    if (legacy !== undefined && preferred !== undefined && Number(legacy) !== Number(preferred)) {
+        throw new Error("wait_seconds and timeout_seconds must match when both are supplied.");
+    }
+    const value = preferred ?? legacy;
+    return value === undefined ? undefined : Number(value);
+}
+function normalizeSummaryView(value) {
+    if (value === undefined)
+        return "standard";
+    if (value !== "compact" && value !== "standard") {
+        throw new Error('view must be "compact" or "standard".');
+    }
+    return value;
+}
+// ── Handler map ───────────────────────────────────────────────────
+export const coreHandlers = {
+    save_plan: async (args) => {
+        return toResult(savePlan({
+            title: String(args?.title ?? ""),
+            content: args?.content !== undefined ? String(args.content) : "",
+            plan_ref: args?.plan_ref ? String(args.plan_ref) : undefined,
+        }));
+    },
+    get_plan: async (args) => {
+        return toResult(getPlan({ plan_id: String(args?.plan_id ?? "") }));
+    },
+    create_task: async (args) => {
+        return toResult(await createTask({
+            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) : undefined,
+            goal: args?.goal ? String(args.goal) : undefined,
+            source_task_id: args?.source_task_id ? String(args.source_task_id) : undefined,
+            agent: String(args?.agent ?? ""),
+            repo_path: args?.repo_path ? String(args.repo_path) : undefined,
+            test_command: args?.test_command ? String(args.test_command) : undefined,
+            verify_commands: Array.isArray(args?.verify_commands)
+                ? args.verify_commands.map((command) => String(command))
+                : undefined,
+            timeout_seconds: args?.timeout_seconds !== undefined ? Number(args.timeout_seconds) : undefined,
+            execution_mode: args?.execution_mode === "assess_only" ? "assess_only" : "execute",
+            assessment_id: args?.assessment_id ? String(args.assessment_id) : undefined,
+        }));
+    },
+    run_task_loop: async (args) => {
+        return toResult(await runTaskLoop({
+            repo_path: String(args?.repo_path ?? ""),
+            goal: String(args?.goal ?? ""),
+            verify_commands: Array.isArray(args?.verify_commands)
+                ? args.verify_commands.map((command) => String(command))
+                : [],
+            agent: args?.agent ? String(args.agent) : undefined,
+            template: args?.template === "inspect_only" || args?.template === "release_check"
+                ? args.template
+                : "feature_small",
+            max_iterations: args?.max_iterations !== undefined ? Number(args.max_iterations) : undefined,
+            task_timeout_seconds: args?.task_timeout_seconds !== undefined ? Number(args.task_timeout_seconds) : undefined,
+            auto_fix_tests: args?.auto_fix_tests !== undefined ? Boolean(args.auto_fix_tests) : undefined,
+            auto_cleanup_artifacts: args?.auto_cleanup_artifacts !== undefined
+                ? Boolean(args.auto_cleanup_artifacts)
+                : undefined,
+            stop_on_high_risk: args?.stop_on_high_risk !== undefined ? Boolean(args.stop_on_high_risk) : undefined,
+            direct_verify: args?.direct_verify !== undefined ? Boolean(args.direct_verify) : undefined,
+            direct_verify_commands: Array.isArray(args?.direct_verify_commands)
+                ? args.direct_verify_commands.map((command) => String(command))
+                : undefined,
+            direct_verify_timeout_seconds: args?.direct_verify_timeout_seconds !== undefined
+                ? Number(args.direct_verify_timeout_seconds)
+                : undefined,
+            scope_files: Array.isArray(args?.scope_files)
+                ? args.scope_files.map((entry) => String(entry))
+                : undefined,
+            isolation_mode: args?.isolation_mode === "worktree" ? "worktree" : "current_repo",
+            worktree_base_branch: args?.worktree_base_branch
+                ? String(args.worktree_base_branch)
+                : undefined,
+            worktree_cleanup: args?.worktree_cleanup === "archive" || args?.worktree_cleanup === "delete_ignored_only"
+                ? args.worktree_cleanup
+                : "keep",
+        }));
+    },
+    recommend_agent_for_task: async (args) => {
+        return toResult(recommendAgentForTask({
+            repo_path: String(args?.repo_path ?? ""),
+            goal: String(args?.goal ?? ""),
+            scope_files: Array.isArray(args?.scope_files)
+                ? args.scope_files.map((entry) => String(entry))
+                : undefined,
+            template: args?.template ? String(args.template) : undefined,
+            risk_hint: args?.risk_hint ? String(args.risk_hint) : undefined,
+        }));
+    },
+    get_task_lineage: async (args) => {
+        return toResult(getTaskLineage(String(args?.lineage_id ?? ""), {
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    export_task_evidence_pack: async (args) => {
+        return toResult(exportTaskEvidencePack({
+            lineage_id: String(args?.lineage_id ?? ""),
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    get_project_policy: async (args) => {
+        return toResult(getProjectPolicyTool(String(args?.repo_path ?? "")));
+    },
+    get_task_status: async (args) => {
+        return toResult(getTaskStatus(String(args?.task_id ?? "")));
+    },
+    get_result: async (args) => {
+        return toResult(getResult(String(args?.task_id ?? "")));
+    },
+    get_result_json: async (args) => {
+        return toResult(getResultJson(String(args?.task_id ?? "")));
+    },
+    get_diff: async (args) => {
+        return toResult(getDiff(String(args?.task_id ?? "")));
+    },
+    get_test_log: async (args) => {
+        return toResult(getTestLog(String(args?.task_id ?? "")));
+    },
+    list_workspace: async (args) => {
+        return toResult(listWorkspace(args?.path ? String(args.path) : undefined));
+    },
+    read_workspace_file: async (args) => {
+        const sessionId = args?.session_id ? String(args.session_id) : undefined;
+        return toResult(readWorkspaceFile({
+            path: String(args?.path ?? ""),
+            session_id: sessionId,
+        }));
+    },
+    list_tasks: async (args) => {
+        return toResult(listTasks({
+            status: args?.status ? String(args.status) : undefined,
+            repo_path: args?.repo_path ? String(args.repo_path) : undefined,
+            active_only: args?.active_only !== undefined ? Boolean(args.active_only) : undefined,
+            limit: args?.limit ? Number(args.limit) : undefined,
+        }));
+    },
+    list_agents: async () => {
+        return toResult(listAgents());
+    },
+    health_check: async (args) => {
+        return toResult(healthCheck(getToolCatalogSnapshot(), {
+            detail: args?.detail === "self_diagnostic" ? "self_diagnostic" : "standard",
+        }));
+    },
+    cancel_task: async (args) => {
+        return toResult(cancelTask(String(args?.task_id ?? "")));
+    },
+    kill_task: async (args) => {
+        return toResult(killTask(String(args?.task_id ?? "")));
+    },
+    retry_task: async (args) => {
+        return toResult(await retryTask(String(args?.task_id ?? "")));
+    },
+    get_task_stdout_tail: async (args) => {
+        return toResult(getTaskStdoutTail(String(args?.task_id ?? ""), args?.lines ? Number(args.lines) : undefined));
+    },
+    get_task_log_tail: async (args) => {
+        return toResult(getTaskLogTail(String(args?.task_id ?? ""), args?.file || "stdout", {
+            lines: args?.lines ? Number(args.lines) : undefined,
+            redact: args?.redact !== undefined ? Boolean(args.redact) : undefined,
+        }));
+    },
+    get_task_progress: async (args) => {
+        return toResult(getTaskProgress(String(args?.task_id ?? "")));
+    },
+    wait_for_task: async (args) => {
+        const waitSeconds = normalizeWaitSeconds(args);
+        return toResult(await waitForTask(String(args?.task_id ?? ""), waitSeconds));
+    },
+    get_task_summary: async (args) => {
+        return toResult(getTaskSummary(String(args?.task_id ?? ""), {
+            view: normalizeSummaryView(args?.view),
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    audit_task: async (args) => {
+        return toResult(auditTask(String(args?.task_id ?? "")));
+    },
+    safe_status: async (args) => {
+        return toResult(safeStatus(String(args?.task_id ?? "")));
+    },
+    safe_result: async (args) => {
+        return toResult(safeResult(String(args?.task_id ?? ""), {
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    safe_audit: async (args) => {
+        return toResult(safeAudit(String(args?.task_id ?? ""), {
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    safe_test_summary: async (args) => {
+        return toResult(safeTestSummary(String(args?.task_id ?? "")));
+    },
+    safe_diff_summary: async (args) => {
+        return toResult(safeDiffSummary(String(args?.task_id ?? ""), {
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    diagnose_task: async (args) => {
+        return toResult(diagnoseTask({
+            task_id: String(args?.task_id ?? ""),
+            include_logs: args?.include_logs !== undefined ? Boolean(args.include_logs) : undefined,
+        }));
+    },
+    reconcile_tasks: async (args) => {
+        return toResult(reconcileTasks({
+            mode: args?.mode === "safe_fix" ? "safe_fix" : "report_only",
+            max_age_minutes: args?.max_age_minutes !== undefined ? Number(args.max_age_minutes) : undefined,
+            include_done_candidates: args?.include_done_candidates !== undefined
+                ? Boolean(args.include_done_candidates)
+                : undefined,
+        }));
+    },
+    check_release_gate: async (args) => {
+        return toResult(await checkReleaseGate({
+            repo_path: String(args?.repo_path ?? ""),
+            target_stage: String(args?.target_stage ?? "local_ready"),
+            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,
+        }));
+    },
+};
+// run_task is conditionally registered (only when enableRunTaskTool === true).
+// Exported separately so registry.ts can add it conditionally to the dispatch map.
+export const runTaskHandler = async (args) => {
+    const config = getConfig();
+    if (config.enableRunTaskTool !== true) {
+        throw new Error("run_task is disabled. Set enableRunTaskTool: true in config to enable. Prefer using the local watcher (npm run watch).");
+    }
+    const taskId = String(args?.task_id ?? "");
+    const result = await runTask(taskId);
+    return toResult(result);
+};

package/dist/tools/dispatch/diagnosticDispatch.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Dispatch handlers for diagnostic / discovery tools (v0.7.1+).
+ *
+ * discover_tools and explain_tool are read-only catalog queries.
+ * invoke_discovered_tool consumes a discovery token and dispatches to
+ * the target tool via handleToolCall.
+ *
+ * Note: This module imports getToolDefs and handleToolCall from
+ * registry.ts. The import is a live ESM binding resolved at runtime,
+ * so the circular dependency (registry → diagnosticDispatch → registry)
+ * is safe: neither binding is touched during module evaluation.
+ */
+import type { ToolHandlerMap } from "./types.js";
+export declare const diagnosticHandlers: ToolHandlerMap;

package/dist/tools/dispatch/diagnosticDispatch.js

@@ -0,0 +1,78 @@
+/**
+ * Dispatch handlers for diagnostic / discovery tools (v0.7.1+).
+ *
+ * discover_tools and explain_tool are read-only catalog queries.
+ * invoke_discovered_tool consumes a discovery token and dispatches to
+ * the target tool via handleToolCall.
+ *
+ * Note: This module imports getToolDefs and handleToolCall from
+ * registry.ts. The import is a live ESM binding resolved at runtime,
+ * so the circular dependency (registry → diagnosticDispatch → registry)
+ * is safe: neither binding is touched during module evaluation.
+ */
+import { discoverTools } from "../discoverTools.js";
+import { explainTool } from "../explainTool.js";
+import { invokeDiscoveredTool } from "../invokeDiscoveredTool.js";
+import { getConfig } from "../../config.js";
+import { resolveToolProfile } from "../toolCatalog.js";
+import { getToolDefs, handleToolCall } from "../registry.js";
+import { toResult } from "./types.js";
+export const diagnosticHandlers = {
+    discover_tools: async (args) => {
+        const profile = args?.profile === "full" ||
+            args?.profile === "chatgpt_core" ||
+            args?.profile === "chatgpt_direct" ||
+            args?.profile === "chatgpt_search"
+            ? args.profile
+            : undefined;
+        const mode = args?.mode === "delegate" ||
+            args?.mode === "direct" ||
+            args?.mode === "audit" ||
+            args?.mode === "release" ||
+            args?.mode === "diagnostic"
+            ? args.mode
+            : undefined;
+        const riskCeiling = [
+            "readonly",
+            "workspace_read_sensitive",
+            "workspace_write",
+            "command",
+            "release",
+            "credential_sensitive",
+        ].includes(String(args?.riskCeiling ?? ""))
+            ? String(args?.riskCeiling)
+            : undefined;
+        return toResult(discoverTools({
+            query: String(args?.query ?? ""),
+            profile,
+            mode,
+            maxResults: args?.maxResults !== undefined ? Number(args.maxResults) : undefined,
+            riskCeiling,
+            includeHighRisk: args?.includeHighRisk !== undefined ? Boolean(args.includeHighRisk) : undefined,
+        }, getToolDefs()));
+    },
+    explain_tool: async (args) => {
+        return toResult(explainTool({
+            name: String(args?.name ?? ""),
+            includeSchema: args?.includeSchema !== undefined ? Boolean(args.includeSchema) : undefined,
+        }, getToolDefs()));
+    },
+    invoke_discovered_tool: async (args) => {
+        const profile = resolveToolProfile(getConfig().toolProfile);
+        const result = await invokeDiscoveredTool({
+            toolName: String(args?.toolName ?? ""),
+            arguments: args?.arguments && typeof args.arguments === "object"
+                ? args.arguments
+                : {},
+            discoveryToken: String(args?.discoveryToken ?? ""),
+            assessmentId: args?.assessmentId ? String(args.assessmentId) : undefined,
+        }, {
+            tools: getToolDefs(),
+            profile,
+            dispatch: async (name, dispatchArgs) => {
+                return handleToolCall(name, dispatchArgs);
+            },
+        });
+        return toResult(result);
+    },
+};

package/dist/tools/dispatch/directDispatch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dispatch handlers for Direct session tools.
+ *
+ * Direct sessions allow ChatGPT to apply patches directly within a
+ * repo-scoped workspace. All handlers guard on enableDirectProfile.
+ */
+import type { ToolHandlerMap } from "./types.js";
+export declare const directHandlers: ToolHandlerMap;

package/dist/tools/dispatch/directDispatch.js

@@ -0,0 +1,115 @@
+/**
+ * Dispatch handlers for Direct session tools.
+ *
+ * Direct sessions allow ChatGPT to apply patches directly within a
+ * repo-scoped workspace. All handlers guard on enableDirectProfile.
+ */
+import { getConfig } from "../../config.js";
+import { PatchWardenError } from "../../errors.js";
+import { createDirectSession } from "../createDirectSession.js";
+import { searchWorkspace } from "../searchWorkspace.js";
+import { applyPatch } from "../applyPatch.js";
+import { runVerification } from "../runVerification.js";
+import { runDirectVerificationBundle } from "../runDirectVerificationBundle.js";
+import { finalizeDirectSession } from "../finalizeDirectSession.js";
+import { auditSession } from "../auditSession.js";
+import { syncFile } from "../syncFile.js";
+import { safeAuditDirectSession, safeDirectSummary, safeFinalizeDirectSession, } from "../safeViews.js";
+import { toResult } from "./types.js";
+/** Mirror of guardDirectProfileEnabled from the original registry.ts. */
+function guardDirectProfileEnabled() {
+    const config = getConfig();
+    if (!config.enableDirectProfile) {
+        throw new PatchWardenError("direct_profile_disabled", "Direct profile is disabled by local config.", "Set enableDirectProfile: true in patchwarden.config.json to use Direct session tools.", true, { operation: "direct_tool_call" });
+    }
+}
+export const directHandlers = {
+    create_direct_session: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(await createDirectSession({
+            repo_path: String(args?.repo_path ?? ""),
+            title: args?.title ? String(args.title) : undefined,
+        }));
+    },
+    search_workspace: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(searchWorkspace({
+            session_id: String(args?.session_id ?? ""),
+            query: String(args?.query ?? ""),
+            max_results: args?.max_results ? Number(args.max_results) : undefined,
+            case_sensitive: args?.case_sensitive !== undefined ? Boolean(args.case_sensitive) : undefined,
+            max_preview_chars: args?.max_preview_chars ? Number(args.max_preview_chars) : undefined,
+            include_globs: Array.isArray(args?.include_globs)
+                ? args.include_globs.map(String)
+                : undefined,
+        }));
+    },
+    apply_patch: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(applyPatch({
+            session_id: String(args?.session_id ?? ""),
+            path: String(args?.path ?? ""),
+            expected_sha256: String(args?.expected_sha256 ?? ""),
+            operations: Array.isArray(args?.operations) ? args.operations : [],
+        }));
+    },
+    run_verification: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(await runVerification({
+            session_id: String(args?.session_id ?? ""),
+            command: String(args?.command ?? ""),
+            timeout_seconds: args?.timeout_seconds ? Number(args.timeout_seconds) : undefined,
+        }));
+    },
+    run_direct_verification_bundle: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(await runDirectVerificationBundle({
+            session_id: String(args?.session_id ?? ""),
+            commands: Array.isArray(args?.commands)
+                ? args.commands.map((command) => String(command))
+                : [],
+            timeout_seconds: args?.timeout_seconds ? Number(args.timeout_seconds) : undefined,
+        }));
+    },
+    finalize_direct_session: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(await finalizeDirectSession({
+            session_id: String(args?.session_id ?? ""),
+        }));
+    },
+    audit_session: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(auditSession({
+            session_id: String(args?.session_id ?? ""),
+        }));
+    },
+    safe_direct_summary: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(safeDirectSummary(String(args?.session_id ?? ""), {
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    safe_finalize_direct_session: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(await safeFinalizeDirectSession(String(args?.session_id ?? ""), {
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    safe_audit_direct_session: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(safeAuditDirectSession(String(args?.session_id ?? ""), {
+            max_items: args?.max_items !== undefined ? Number(args.max_items) : undefined,
+        }));
+    },
+    sync_file: async (args) => {
+        guardDirectProfileEnabled();
+        return toResult(syncFile(String(args?.session_id ?? ""), String(args?.source_path ?? ""), String(args?.target_path ?? ""), {
+            expected_source_sha256: args?.expected_source_sha256
+                ? String(args.expected_source_sha256)
+                : undefined,
+            expected_target_sha256: args?.expected_target_sha256
+                ? String(args.expected_target_sha256)
+                : undefined,
+        }));
+    },
+};

package/dist/tools/dispatch/goalDispatch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dispatch handlers for Goal Session tools (v0.8.0+).
+ *
+ * Covers goal lifecycle, subgoal management, Spec Kit import,
+ * worktree merge/discard, and goal reporting.
+ */
+import type { ToolHandlerMap } from "./types.js";
+export declare const goalHandlers: ToolHandlerMap;

package/dist/tools/dispatch/goalDispatch.js

@@ -0,0 +1,91 @@
+/**
+ * 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 { toResult } from "./types.js";
+export const goalHandlers = {
+    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) : 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/dist/tools/dispatch/releaseDispatch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dispatch handlers for release-mode tools (v1.3.0+).
+ *
+ * Wraps releaseCheck, releasePrepare, releaseVerify, and releaseCleanup
+ * from releaseMode.ts.
+ */
+import type { ToolHandlerMap } from "./types.js";
+export declare const releaseHandlers: ToolHandlerMap;