@lsctech/polaris 0.1.0

package/dist/mcp/tools/dispatch-result.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const dispatch_result_js_1 = require("./dispatch-result.js");
+const originalCwd = process.cwd();
+function makeTempRepo() {
+    return (0, node_path_1.join)((0, node_os_1.tmpdir)(), `polaris-dispatch-result-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+}
+function writeState(repoRoot, artifactDir, state) {
+    const dir = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", artifactDir);
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "current-state.json"), JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+function readState(repoRoot, artifactDir) {
+    return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(repoRoot, ".taskchain_artifacts", artifactDir, "current-state.json"), "utf-8"));
+}
+(0, vitest_1.describe)("handlePolarisDispatchResult()", () => {
+    let repoRoot;
+    (0, vitest_1.beforeEach)(() => {
+        repoRoot = makeTempRepo();
+        (0, node_fs_1.mkdirSync)(repoRoot, { recursive: true });
+        process.chdir(repoRoot);
+    });
+    (0, vitest_1.afterEach)(() => {
+        process.chdir(originalCwd);
+        (0, node_fs_1.rmSync)(repoRoot, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("records a matching active_child result in state and telemetry", async () => {
+        writeState(repoRoot, "polaris-run", {
+            schema_version: "1.0",
+            run_id: "run-result",
+            cluster_id: "POL-105",
+            active_child: "POL-111",
+            open_children: ["POL-111", "POL-112"],
+            completed_children: ["POL-110"],
+            open_children_meta: {
+                "POL-111": { title: "Add MCP tools", status: "Backlog" },
+                "POL-112": { title: "Smoke test", status: "Backlog" },
+            },
+            context_budget: { children_completed: 5 },
+            status: "running",
+            step_cursor: "04-execute-child",
+        });
+        const result = await (0, dispatch_result_js_1.handlePolarisDispatchResult)({
+            child_id: "POL-111",
+            status: "completed",
+            commit: "abc1234",
+            validation: ["npm test -- src/mcp/tools/claim-child.test.ts src/mcp/tools/dispatch-result.test.ts"],
+        });
+        (0, vitest_1.expect)(result["ok"]).toBe(true);
+        const state = readState(repoRoot, "polaris-run");
+        (0, vitest_1.expect)(state["active_child"]).toBeNull();
+        (0, vitest_1.expect)(state["completed_children"]).toEqual(["POL-110", "POL-111"]);
+        (0, vitest_1.expect)(state["open_children"]).toEqual(["POL-112"]);
+        (0, vitest_1.expect)(state["next_open_child"]).toBe("POL-112");
+        (0, vitest_1.expect)(state["last_commit"]).toBe("abc1234");
+        (0, vitest_1.expect)(state["last_worker_result"]["child_id"]).toBe("POL-111");
+        const telemetry = (0, node_fs_1.readFileSync)((0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run", "runs", "run-result", "telemetry.jsonl"), "utf-8");
+        (0, vitest_1.expect)(telemetry).toContain("\"event\":\"mcp-dispatch-result\"");
+        (0, vitest_1.expect)(telemetry).toContain("\"commit\":\"abc1234\"");
+    });
+    (0, vitest_1.it)("returns error when run_id is missing from state", async () => {
+        writeState(repoRoot, "polaris-run", {
+            schema_version: "1.0",
+            cluster_id: "POL-105",
+            active_child: "POL-111",
+            open_children: ["POL-111"],
+            completed_children: [],
+            status: "running",
+            step_cursor: "04-execute-child",
+        });
+        const result = await (0, dispatch_result_js_1.handlePolarisDispatchResult)({
+            child_id: "POL-111",
+            status: "completed",
+            commit: "abc1234",
+            validation: "passed",
+        });
+        (0, vitest_1.expect)(result["ok"]).toBe(false);
+        (0, vitest_1.expect)(result["error"]).toBe("invalid_run_id");
+        (0, vitest_1.expect)(typeof result["message"]).toBe("string");
+        (0, vitest_1.expect)(result["message"]).toContain("run_id");
+    });
+    (0, vitest_1.it)("returns active_child_mismatch when the result does not match active_child", async () => {
+        writeState(repoRoot, "polaris-run", {
+            schema_version: "1.0",
+            run_id: "run-result",
+            cluster_id: "POL-105",
+            active_child: "POL-110",
+            open_children: ["POL-111"],
+            completed_children: [],
+            context_budget: { children_completed: 0 },
+            status: "running",
+            step_cursor: "04-execute-child",
+        });
+        const result = await (0, dispatch_result_js_1.handlePolarisDispatchResult)({
+            child_id: "POL-111",
+            status: "completed",
+            commit: "abc1234",
+            validation: "passed",
+        });
+        (0, vitest_1.expect)(result["ok"]).toBe(false);
+        (0, vitest_1.expect)(result["error"]).toBe("active_child_mismatch");
+        (0, vitest_1.expect)(result["expected"]).toBe("POL-110");
+        (0, vitest_1.expect)(readState(repoRoot, "polaris-run")["active_child"]).toBe("POL-110");
+    });
+});

package/dist/mcp/tools/index.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOLS = void 0;
+exports.dispatchTool = dispatchTool;
+const status_js_1 = require("./status.js");
+const current_state_js_1 = require("./current-state.js");
+const loop_dry_run_js_1 = require("./loop-dry-run.js");
+const loop_continue_js_1 = require("./loop-continue.js");
+const claim_child_js_1 = require("./claim-child.js");
+const dispatch_result_js_1 = require("./dispatch-result.js");
+const linear_js_1 = require("./linear.js");
+exports.TOOLS = [
+    ...linear_js_1.LINEAR_TOOLS, // Add Linear tools here
+    {
+        name: "polaris_status",
+        description: "Return the current Polaris loop run state. Calls `polaris status --json` and returns compact structured output.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "polaris_loop_status",
+        description: "Return the current Polaris loop status, scoped to the loop subsystem. Calls `polaris loop status --json`.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "polaris_current_state",
+        description: "Return the raw parsed current-state.json for a Polaris artifact directory, with sensitive keys redacted.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_dir: {
+                    type: "string",
+                    description: "Artifact directory name under .taskchain_artifacts/. Default: polaris-run",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "polaris_loop_continue_dry_run",
+        description: "Preview what loop continue would do — returns eligibility status and approval template without mutating any state. Dry-run only: no bootstrap packets, no worker dispatch, no execution leases.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_dir: {
+                    type: "string",
+                    description: "Artifact directory name under .taskchain_artifacts/. Default: polaris-run",
+                },
+                expected_step_cursor: {
+                    type: "string",
+                    description: "Expected current step cursor (e.g. '06-decide-continuation')",
+                },
+            },
+            required: ["expected_step_cursor"],
+        },
+    },
+    {
+        name: "polaris_loop_continue_confirmed",
+        description: "Submit a pre-approved continuation envelope to gate a loop continue action. Requires a valid ContinuationApprovalEnvelope from a prior dry-run call. Does not dispatch workers — returns approval status only.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_dir: {
+                    type: "string",
+                    description: "Artifact directory name under .taskchain_artifacts/. Default: polaris-run",
+                },
+                run_id: {
+                    type: "string",
+                    description: "Run ID from the approval envelope",
+                },
+                expected_step_cursor: {
+                    type: "string",
+                    description: "Expected step cursor from the approval envelope",
+                },
+                fingerprint: {
+                    type: "string",
+                    description: "State fingerprint from the approval envelope",
+                },
+                runtime_generation: {
+                    type: "number",
+                    description: "Runtime generation counter from the approval envelope",
+                },
+                issued_at: {
+                    type: "string",
+                    description: "ISO 8601 timestamp when the envelope was issued",
+                },
+                expires_at: {
+                    type: "string",
+                    description: "ISO 8601 timestamp when the envelope expires",
+                },
+                nonce: {
+                    type: "string",
+                    description: "Unique nonce from the approval envelope",
+                },
+                requested_action: {
+                    type: "string",
+                    description: 'Must be "loop_continue"',
+                },
+            },
+            required: [
+                "run_id",
+                "expected_step_cursor",
+                "fingerprint",
+                "runtime_generation",
+                "issued_at",
+                "expires_at",
+                "nonce",
+                "requested_action",
+            ],
+        },
+    },
+    {
+        name: "polaris_claim_child",
+        description: "Atomically claim an open Polaris child issue by writing active_child in current-state.json. Mutates run state and appends telemetry.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_dir: {
+                    type: "string",
+                    description: "Artifact directory name under .taskchain_artifacts/. Default: polaris-run",
+                },
+                child_id: {
+                    type: "string",
+                    description: "Open child issue ID to claim, e.g. POL-111",
+                },
+            },
+            required: ["child_id"],
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: "polaris_dispatch_result",
+        description: "Record a Polaris worker result for the matching active_child in current-state.json and append dispatch-result telemetry.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_dir: {
+                    type: "string",
+                    description: "Artifact directory name under .taskchain_artifacts/. Default: polaris-run",
+                },
+                child_id: {
+                    type: "string",
+                    description: "Active child issue ID whose result is being recorded",
+                },
+                status: {
+                    type: "string",
+                    description: "Worker status, such as completed, failed, or blocked",
+                },
+                commit: {
+                    type: "string",
+                    description: "Commit hash produced by the worker, when available",
+                },
+                validation: {
+                    description: "Validation summary or structured validation evidence from the worker",
+                },
+            },
+            required: ["child_id", "status"],
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    },
+];
+const REGISTERED = new Set(exports.TOOLS.map((t) => t.name));
+async function dispatchTool(name, args) {
+    if (!REGISTERED.has(name)) {
+        const result = {
+            ok: false,
+            error: "unknown_tool",
+            message: `Unknown tool: ${name}`,
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    let result;
+    switch (name) {
+        case "polaris_status":
+            result = await (0, status_js_1.handlePolarisStatus)();
+            break;
+        case "polaris_loop_status":
+            result = await (0, status_js_1.handlePolarisLoopStatus)();
+            break;
+        case "polaris_current_state":
+            result = await (0, current_state_js_1.handlePolarisCurrentState)(args);
+            break;
+        case "polaris_loop_continue_dry_run":
+            result = await (0, loop_dry_run_js_1.handleLoopContinueDryRun)(args);
+            break;
+        case "polaris_loop_continue_confirmed":
+            result = await (0, loop_continue_js_1.handleLoopContinueConfirmed)(args);
+            break;
+        case "polaris_claim_child":
+            result = await (0, claim_child_js_1.handlePolarisClaimChild)(args);
+            break;
+        case "polaris_dispatch_result":
+            result = await (0, dispatch_result_js_1.handlePolarisDispatchResult)(args);
+            break;
+        case "linear_list_issues":
+            result = await (0, linear_js_1.handleLinearListIssues)(args);
+            break;
+        case "linear_save_issue":
+            result = await (0, linear_js_1.handleLinearSaveIssue)(args);
+            break;
+        default:
+            result = { ok: false, error: "unknown_tool", message: `Unhandled tool: ${name}` };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}

package/dist/mcp/tools/index.test.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Unit tests for src/mcp/tools/index.ts
+ *
+ * Covers:
+ * - dispatchTool() returns unknown_tool error for unregistered tool name
+ * - TOOLS array contains the expected tools
+ * - dispatchTool() result has content array with a text item containing valid JSON
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Mock the handler modules before importing index.ts
+vitest_1.vi.mock("./status.js", () => ({
+    handlePolarisStatus: vitest_1.vi.fn().mockResolvedValue({ ok: true, status: "running" }),
+    handlePolarisLoopStatus: vitest_1.vi.fn().mockResolvedValue({ ok: true, status: "idle" }),
+}));
+vitest_1.vi.mock("./current-state.js", () => ({
+    handlePolarisCurrentState: vitest_1.vi.fn().mockResolvedValue({
+        ok: true,
+        artifact_dir: "polaris-run",
+        state: { run_id: "test-run" },
+    }),
+}));
+vitest_1.vi.mock("./loop-dry-run.js", () => ({
+    handleLoopContinueDryRun: vitest_1.vi.fn().mockResolvedValue({ ok: true, eligible: true }),
+}));
+vitest_1.vi.mock("./loop-continue.js", () => ({
+    handleLoopContinueConfirmed: vitest_1.vi.fn().mockResolvedValue({
+        ok: true,
+        next_child: "POL-85",
+        message: "Continuation approved. Worker dispatch is not yet implemented.",
+    }),
+}));
+vitest_1.vi.mock("./linear.js", () => ({
+    LINEAR_TOOLS: [
+        { name: "linear_list_issues", description: "List Linear issues", inputSchema: { type: "object", properties: {}, required: [] } },
+        { name: "linear_save_issue", description: "Save a Linear issue", inputSchema: { type: "object", properties: {}, required: [] } },
+    ],
+    handleLinearListIssues: vitest_1.vi.fn().mockResolvedValue({ ok: true, issues: [] }),
+    handleLinearSaveIssue: vitest_1.vi.fn().mockResolvedValue({ ok: true }),
+}));
+const index_js_1 = require("./index.js");
+const status_js_1 = require("./status.js");
+const current_state_js_1 = require("./current-state.js");
+const loop_continue_js_1 = require("./loop-continue.js");
+const mockHandlePolarisStatus = vitest_1.vi.mocked(status_js_1.handlePolarisStatus);
+const mockHandlePolarisLoopStatus = vitest_1.vi.mocked(status_js_1.handlePolarisLoopStatus);
+const mockHandlePolarisCurrentState = vitest_1.vi.mocked(current_state_js_1.handlePolarisCurrentState);
+const mockHandleLoopContinueConfirmed = vitest_1.vi.mocked(loop_continue_js_1.handleLoopContinueConfirmed);
+(0, vitest_1.describe)("TOOLS array", () => {
+    (0, vitest_1.it)("has exactly 9 tools", () => {
+        (0, vitest_1.expect)(index_js_1.TOOLS).toHaveLength(9);
+    });
+    (0, vitest_1.it)("contains polaris_status", () => {
+        const names = index_js_1.TOOLS.map((t) => t.name);
+        (0, vitest_1.expect)(names).toContain("polaris_status");
+    });
+    (0, vitest_1.it)("contains polaris_loop_status", () => {
+        const names = index_js_1.TOOLS.map((t) => t.name);
+        (0, vitest_1.expect)(names).toContain("polaris_loop_status");
+    });
+    (0, vitest_1.it)("contains polaris_current_state", () => {
+        const names = index_js_1.TOOLS.map((t) => t.name);
+        (0, vitest_1.expect)(names).toContain("polaris_current_state");
+    });
+    (0, vitest_1.it)("contains polaris_loop_continue_dry_run", () => {
+        const names = index_js_1.TOOLS.map((t) => t.name);
+        (0, vitest_1.expect)(names).toContain("polaris_loop_continue_dry_run");
+    });
+    (0, vitest_1.it)("contains polaris_loop_continue_confirmed", () => {
+        const names = index_js_1.TOOLS.map((t) => t.name);
+        (0, vitest_1.expect)(names).toContain("polaris_loop_continue_confirmed");
+    });
+    (0, vitest_1.it)("has the exact set of tools", () => {
+        const names = index_js_1.TOOLS.map((t) => t.name).sort();
+        (0, vitest_1.expect)(names).toEqual([
+            "linear_list_issues",
+            "linear_save_issue",
+            "polaris_claim_child",
+            "polaris_current_state",
+            "polaris_dispatch_result",
+            "polaris_loop_continue_confirmed",
+            "polaris_loop_continue_dry_run",
+            "polaris_loop_status",
+            "polaris_status",
+        ]);
+    });
+});
+(0, vitest_1.describe)("dispatchTool()", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.it)("returns an unknown_tool error for an unregistered tool name", async () => {
+        const response = await (0, index_js_1.dispatchTool)("nonexistent_tool", {});
+        (0, vitest_1.expect)(response.content).toHaveLength(1);
+        (0, vitest_1.expect)(response.content[0]?.type).toBe("text");
+        const parsed = JSON.parse(response.content[0].text);
+        (0, vitest_1.expect)(parsed["ok"]).toBe(false);
+        (0, vitest_1.expect)(parsed["error"]).toBe("unknown_tool");
+    });
+    (0, vitest_1.it)("result has a content array with at least one item", async () => {
+        const response = await (0, index_js_1.dispatchTool)("polaris_status", {});
+        (0, vitest_1.expect)(Array.isArray(response.content)).toBe(true);
+        (0, vitest_1.expect)(response.content.length).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("result content item has type 'text'", async () => {
+        const response = await (0, index_js_1.dispatchTool)("polaris_status", {});
+        (0, vitest_1.expect)(response.content[0]?.type).toBe("text");
+    });
+    (0, vitest_1.it)("result content text item contains valid JSON", async () => {
+        const response = await (0, index_js_1.dispatchTool)("polaris_status", {});
+        (0, vitest_1.expect)(() => JSON.parse(response.content[0].text)).not.toThrow();
+    });
+    (0, vitest_1.it)("dispatches polaris_status to handlePolarisStatus", async () => {
+        mockHandlePolarisStatus.mockResolvedValue({ ok: true, run_id: "pol-test" });
+        const response = await (0, index_js_1.dispatchTool)("polaris_status", {});
+        (0, vitest_1.expect)(mockHandlePolarisStatus).toHaveBeenCalledOnce();
+        const parsed = JSON.parse(response.content[0].text);
+        (0, vitest_1.expect)(parsed["ok"]).toBe(true);
+        (0, vitest_1.expect)(parsed["run_id"]).toBe("pol-test");
+    });
+    (0, vitest_1.it)("dispatches polaris_loop_status to handlePolarisLoopStatus", async () => {
+        mockHandlePolarisLoopStatus.mockResolvedValue({ ok: true, status: "loop-running" });
+        const response = await (0, index_js_1.dispatchTool)("polaris_loop_status", {});
+        (0, vitest_1.expect)(mockHandlePolarisLoopStatus).toHaveBeenCalledOnce();
+        const parsed = JSON.parse(response.content[0].text);
+        (0, vitest_1.expect)(parsed["ok"]).toBe(true);
+        (0, vitest_1.expect)(parsed["status"]).toBe("loop-running");
+    });
+    (0, vitest_1.it)("dispatches polaris_current_state to handlePolarisCurrentState", async () => {
+        mockHandlePolarisCurrentState.mockResolvedValue({
+            ok: true,
+            artifact_dir: "polaris-run",
+            state: { run_id: "state-test" },
+        });
+        const response = await (0, index_js_1.dispatchTool)("polaris_current_state", { artifact_dir: "polaris-run" });
+        (0, vitest_1.expect)(mockHandlePolarisCurrentState).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(mockHandlePolarisCurrentState).toHaveBeenCalledWith({ artifact_dir: "polaris-run" });
+        const parsed = JSON.parse(response.content[0].text);
+        (0, vitest_1.expect)(parsed["ok"]).toBe(true);
+        (0, vitest_1.expect)(parsed["artifact_dir"]).toBe("polaris-run");
+    });
+    (0, vitest_1.it)("dispatches polaris_loop_continue_confirmed to handleLoopContinueConfirmed", async () => {
+        mockHandleLoopContinueConfirmed.mockResolvedValue({
+            ok: true,
+            next_child: "POL-85",
+            message: "Continuation approved. Worker dispatch is not yet implemented.",
+        });
+        const envelopeArgs = {
+            artifact_dir: "bootstrap-run",
+            run_id: "run-123",
+            expected_step_cursor: "06-decide-continuation",
+            fingerprint: "abc123",
+            runtime_generation: 1,
+            issued_at: "2026-05-25T00:00:00.000Z",
+            expires_at: "2026-05-25T01:00:00.000Z",
+            nonce: "nonce-xyz",
+            requested_action: "loop_continue",
+        };
+        const response = await (0, index_js_1.dispatchTool)("polaris_loop_continue_confirmed", envelopeArgs);
+        (0, vitest_1.expect)(mockHandleLoopContinueConfirmed).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(mockHandleLoopContinueConfirmed).toHaveBeenCalledWith(envelopeArgs);
+        const parsed = JSON.parse(response.content[0].text);
+        (0, vitest_1.expect)(parsed["ok"]).toBe(true);
+        (0, vitest_1.expect)(parsed["next_child"]).toBe("POL-85");
+    });
+    (0, vitest_1.it)("unknown_tool error message includes the tool name", async () => {
+        const response = await (0, index_js_1.dispatchTool)("made_up_tool", {});
+        const parsed = JSON.parse(response.content[0].text);
+        (0, vitest_1.expect)(parsed["message"]).toContain("made_up_tool");
+    });
+});

package/dist/mcp/tools/linear.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINEAR_TOOLS = void 0;
+exports.handleLinearListIssues = handleLinearListIssues;
+exports.handleLinearSaveIssue = handleLinearSaveIssue;
+async function loadLinearTools() {
+    return import("@tool-server/linear");
+}
+// Handler for listing Linear issues
+async function handleLinearListIssues(args) {
+    try {
+        const { mcp_linear_list_issues } = await loadLinearTools();
+        const issues = await mcp_linear_list_issues({
+            team: args.team,
+            project: args.project,
+            assignee: args.assignee,
+            query: args.query,
+        });
+        return { ok: true, data: issues };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+// Handler for creating/updating Linear issues
+async function handleLinearSaveIssue(args) {
+    try {
+        const { mcp_linear_save_issue } = await loadLinearTools();
+        const issue = await mcp_linear_save_issue(args);
+        return { ok: true, data: issue };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+exports.LINEAR_TOOLS = [
+    {
+        name: "linear_list_issues",
+        description: "List issues in Linear, with optional filters.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                team: { type: "string", description: "Filter by team name or ID" },
+                project: { type: "string", description: "Filter by project name, ID, or slug" },
+                assignee: { type: "string", description: "Filter by assignee (user ID, name, email, or 'me')" },
+                query: { type: "string", description: "Search issue title or description" },
+            },
+        },
+    },
+    {
+        name: "linear_save_issue",
+        description: "Create or update a Linear issue.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Issue ID for updating an existing issue" },
+                title: { type: "string", description: "Issue title (required when creating)" },
+                team: { type: "string", description: "Team name or ID (required when creating)" },
+                description: { type: "string", description: "Issue description as Markdown" },
+                project: { type: "string", description: "Project name, ID, or slug" },
+                assignee: { type: "string", description: "User ID, name, email, or 'me'" },
+                status: { type: "string", description: "State type, name, or ID" },
+                priority: { type: "number", description: "0=None, 1=Urgent, 2=High, 3=Medium, 4=Low" },
+                labels: { type: "array", items: { type: "string" }, description: "Label names or IDs" },
+                parentId: { type: "string", description: "Parent issue ID" },
+                blockedBy: { type: "array", items: { type: "string" }, description: "Issue IDs blocking this" },
+                blocks: { type: "array", items: { type: "string" }, description: "Issue IDs this blocks" },
+                relatedTo: { type: "array", items: { type: "string" }, description: "Related issue IDs" },
+                dueDate: { type: "string", format: "date", description: "Due date (ISO format)" },
+            },
+            oneOf: [{ required: ["id"] }, { required: ["title", "team"] }],
+        },
+    },
+];