patchwarden 1.5.0 → 1.6.1

package/dist/tools/dispatch/coreDispatch.js

@@ -0,0 +1,283 @@
+/**
+ * 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 "../goals/savePlan.js";
+import { getPlan } from "../goals/getPlan.js";
+import { createTask } from "../tasks/createTask.js";
+import { getTaskStatus } from "../tasks/getTaskStatus.js";
+import { getResult, getResultJson, getDiff, getTestLog, getTaskLogTail } from "../tasks/taskOutputs.js";
+import { listWorkspace } from "../workspace/listWorkspace.js";
+import { readWorkspaceFile } from "../workspace/readWorkspaceFile.js";
+import { listTasks } from "../tasks/listTasks.js";
+import { cancelTask } from "../tasks/cancelTask.js";
+import { killTask } from "../tasks/killTask.js";
+import { retryTask } from "../tasks/retryTask.js";
+import { getTaskStdoutTail } from "../tasks/getTaskStdoutTail.js";
+import { getTaskProgress } from "../tasks/getTaskProgress.js";
+import { listAgents } from "../workspace/listAgents.js";
+import { healthCheck } from "../diagnostics/healthCheck.js";
+import { getTaskSummary } from "../tasks/getTaskSummary.js";
+import { waitForTask } from "../tasks/waitForTask.js";
+import { runTaskLoop } from "../tasks/runTaskLoop.js";
+import { getTaskLineage } from "../tasks/taskLineage.js";
+import { exportTaskEvidencePack } from "../tasks/evidencePack.js";
+import { recommendAgentForTask } from "../workspace/recommendAgentForTask.js";
+import { auditTask } from "../diagnostics/auditTask.js";
+import { safeStatus } from "../diagnostics/safeStatus.js";
+import { safeAudit, safeDiffSummary, safeResult, safeTestSummary } from "../diagnostics/safeViews.js";
+import { diagnoseTask } from "../tasks/diagnoseTask.js";
+import { reconcileTasks } from "../tasks/reconcileTasks.js";
+import { checkReleaseGate } from "../release/checkReleaseGate.js";
+import { getProjectPolicyTool } from "../release/releaseMode.js";
+import { runTask } from "../../runner/runTask.js";
+import { getConfig } from "../../config.js";
+import { getToolCatalogSnapshot } from "../registry.js";
+import { toResult } from "./types.js";
+import { parseOptionalTaskTemplate, parseReleaseStage, parseTaskLogFile, } from "./validation.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: parseOptionalTaskTemplate(args?.template),
+            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 ?? ""), parseTaskLogFile(args?.file), {
+            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: parseReleaseStage(args?.target_stage),
+            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,12 @@
+/**
+ * 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.
+ *
+ * The registry injects the audited dispatcher used by invoke_discovered_tool,
+ * avoiding a registry -> diagnosticDispatch -> registry import cycle.
+ */
+import type { ToolHandlerMap } from "./types.js";
+export declare function buildDiagnosticHandlers(dispatchTool: (name: string, args: Record<string, unknown> | undefined) => Promise<unknown>): ToolHandlerMap;

package/dist/tools/dispatch/diagnosticDispatch.js

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ *
+ * The registry injects the audited dispatcher used by invoke_discovered_tool,
+ * avoiding a registry -> diagnosticDispatch -> registry import cycle.
+ */
+import { discoverTools } from "../discovery/discoverTools.js";
+import { explainTool } from "../discovery/explainTool.js";
+import { invokeDiscoveredTool } from "../discovery/invokeDiscoveredTool.js";
+import { getConfig } from "../../config.js";
+import { resolveToolProfile } from "../catalog/toolCatalog.js";
+import { getToolDefs } from "../definitions/toolDefs.js";
+import { toResult } from "./types.js";
+export function buildDiagnosticHandlers(dispatchTool) {
+    return {
+        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 riskCeilings = new Set([
+                "readonly",
+                "workspace_read_sensitive",
+                "workspace_write",
+                "command",
+                "release",
+                "credential_sensitive",
+            ]);
+            const requestedRiskCeiling = String(args?.riskCeiling ?? "");
+            const riskCeiling = riskCeilings.has(requestedRiskCeiling)
+                ? requestedRiskCeiling
+                : 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 dispatchTool(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,116 @@
+/**
+ * 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 "../direct/createDirectSession.js";
+import { searchWorkspace } from "../workspace/searchWorkspace.js";
+import { applyPatch } from "../workspace/applyPatch.js";
+import { runVerification } from "../tasks/runVerification.js";
+import { runDirectVerificationBundle } from "../direct/runDirectVerificationBundle.js";
+import { finalizeDirectSession } from "../direct/finalizeDirectSession.js";
+import { auditSession } from "../diagnostics/auditSession.js";
+import { syncFile } from "../workspace/syncFile.js";
+import { safeAuditDirectSession, safeDirectSummary, safeFinalizeDirectSession, } from "../diagnostics/safeViews.js";
+import { toResult } from "./types.js";
+import { parsePatchOperations } from "./validation.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: parsePatchOperations(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,92 @@
+/**
+ * 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 "../goals/goalSubgoalTask.js";
+import { mergeWorktreeTool } from "../workspace/mergeWorktree.js";
+import { discardWorktreeTool } from "../workspace/discardWorktree.js";
+import { toResult } from "./types.js";
+import { parseOptionalTaskTemplate } from "./validation.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: parseOptionalTaskTemplate(args?.template),
+            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;

package/dist/tools/dispatch/releaseDispatch.js

@@ -0,0 +1,46 @@
+/**
+ * Dispatch handlers for release-mode tools (v1.3.0+).
+ *
+ * Wraps releaseCheck, releasePrepare, releaseVerify, and releaseCleanup
+ * from releaseMode.ts.
+ */
+import { releaseCheck, releasePrepare, releaseVerify, releaseCleanup, } from "../release/releaseMode.js";
+import { toResult } from "./types.js";
+import { parseReleaseStage } from "./validation.js";
+export const releaseHandlers = {
+    release_check: async (args) => {
+        return toResult(await releaseCheck({
+            repo_path: String(args?.repo_path ?? ""),
+            target_stage: parseReleaseStage(args?.target_stage),
+            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,
+        }));
+    },
+};