jules-orchestrator-kit 0.51.0 → 0.52.1

package/README.md

@@ -59,7 +59,7 @@ npx jules-orchestrator-kit init
 ```bash
 # 2. Commit what init wrote — .agent/config.yml is on the gate's deny list by
 #    design, so leaving it uncommitted makes the first gate reject your tree
-git add .agent AGENTS.md .gitignore && git commit -m "chore: add agent config"
+git add .agent AGENTS.md SPEC.md CONSTRAINTS.md .gitignore && git commit -m "chore: add agent config"
 ```
 
 ```bash
@@ -143,7 +143,7 @@ To maximize PR merge rates, dispatch tasks according to deterministic boundaries
 * **Fail-Closed Security & Secret Redaction:** Evaluates explicit Deny rules before Allow rules against canonicalized, case-folded paths. Redacts high-entropy keys and base64-encoded credentials (such as Kubernetes `Secret` manifests).
 * **Complexity & Cost Router:** Zero-dependency heuristic classifier (`src/router.mjs`) routing mechanical tasks to lightweight models while reserving primary models for complex refactors, with a `node --check` syntax-verification gate that transparently escalates a FAST-tier result to the primary provider if it left broken JS on disk.
 * **Terminal UI & Diagnostic Matrix (`agentctl doctor`):** Interactive terminal dashboard, task sidecar manager, and automated transactional self-repair.
-* **Verified Test Suite:** Tested with **790 unit tests across 91 suites passing in < 10.0s**.
+* **Verified Test Suite:** Tested with **802 unit tests across 91 suites passing in < 10.0s**.
 
 <br/>
 
@@ -165,6 +165,9 @@ To maximize PR merge rates, dispatch tasks according to deterministic boundaries
 | `dispatch` | `agentctl dispatch [<prompt>] [-p <prompt>] [-f <file>] [-r <role>] [-t <tier>] [--author <name>] [--check-premise] [--auto-pr] [--repoless] [--dry-run]` | Dispatches autonomous task to the active provider with pre-flight idempotency checks, payload limits, and role prompt resolution. `--dry-run` stops short of the provider call and reports itself as a rehearsal rather than a dispatch. | `0` (Dispatched), `1` (Error) |
 | `plan approve` | `agentctl plan approve <sessionId> [--dry-run] [--json]` | Approves pending execution plan for an active Jules session (`:approvePlan`) with automatic 404/503 retry backoff. | `0` (Approved), `1` (Error) |
 | `session get` | `agentctl session get <sessionId> [--dry-run] [--json]` | Retrieves live session lifecycle state from provider REST API with token rotation. | `0` (Fetched), `1` (Error) |
+| `patch` | `agentctl patch <sessionId> [--apply] [--save <path>] [--json]` | Extracts raw git diff patch from a completed Jules session and tests or applies it locally with `git apply --check` safety. | `0` (Clean/Applied), `1` (Conflict/Error) |
+| `retry` | `agentctl retry <sessionId> [--role <role>] [--with-failure] [--json]` | Fetches error traces and activity logs from a failed session and synthesizes a targeted OODA retry dispatch. | `0` (Dispatched), `1` (Error) |
+| `prune` | `agentctl prune [--age 7d] [--state <state>] [--delete] [--yes] [--json]` | Queries and batch-archives or deletes stale/completed sessions via Jules v1alpha API to keep workspaces clean. | `0` (Cleaned) |
 | `pr harvest` | `agentctl pr harvest [--tier r0,r1] [--limit <n>] [--auto] [--allow-no-checks] [--dry-run]` | Discovers open agent PRs, evaluates CI checks & risk tiers, and auto-squashes green low-risk changes autonomously. A PR reporting **no** CI checks is skipped unless `--allow-no-checks` is passed, and an unavailable changed-file list blocks rather than classifying as low risk. | `0` (Triaged/Merged), `1` (Error) |
 | `doctor` | `agentctl doctor [--json]` | Diagnostic DAG check runner & automated transactional self-repair engine. | `0` (Healthy), `1` (Failures) |
 | `queue` | `agentctl queue [--dag] [--concurrency <n>] [--dry-run] [--json]` | Consumes and executes task envelopes in `.agent/jules-queue/` with Kahn's DAG dependency resolution. Non-task files (manifests, `README.md`) are skipped, and `--dry-run` previews without moving anything. | `0` (Complete) |

package/bin/agentctl.mjs

@@ -69,6 +69,9 @@ Commands:
   resume                Resume warm session with human response (--response "<text>")
   plan approve <id>     Approve pending plan for a Jules session (:approvePlan)
   session get <id>      Retrieve remote session status from provider API
+  patch <id>            Extract and test/apply git patch from a Jules session (--apply, --save)
+  retry <id>            Retry failed session with automated failure-trace injection (--role)
+  prune                 Batch-archive or delete stale sessions via Jules API (--age 7d, --yes)
   pr harvest            Triage, verify CI, and auto-merge low-risk agent PRs (--auto, --tier r0,r1)
   escalate              Dispatch or manage webhook escalation incidents (--flush, --status, --clear)
   flaky                 Manage Wilson-quarantined tests and dispatch healing swarm (status | heal | reset)
@@ -225,9 +228,16 @@ async function main() {
     process.exit(0);
   }
 
-  // Intercept --help / -h on any subcommand (e.g. `agentctl init --help`)
+  // Resolve --help / -h on subcommands (e.g. `agentctl init --help`, `agentctl mutate --help`)
   const subArgs = args.slice(1);
   if (subArgs.includes("--help") || subArgs.includes("-h")) {
+    const { getCommandDescriptor, formatCommandHelp } = await import("../src/ops/command-registry.mjs");
+    const subSub = subArgs[0] && !subArgs[0].startsWith("-") ? `${command} ${subArgs[0]}` : command;
+    const desc = getCommandDescriptor(subSub) || getCommandDescriptor(command);
+    if (desc) {
+      console.log(formatCommandHelp(desc));
+      process.exit(0);
+    }
     printHelp();
     process.exit(0);
   }
@@ -720,6 +730,147 @@ async function main() {
       break;
     }
 
+    case "patch": {
+      const { applySessionPatch, resolveRoot } = await import("../index.mjs");
+      const { values, positionals } = parseArgs({
+        args: args.slice(1),
+        options: {
+          session: { type: "string", short: "s" },
+          apply: { type: "boolean", short: "a" },
+          save: { type: "string" },
+          json: { type: "boolean", short: "j" },
+        },
+        allowPositionals: true,
+      });
+
+      const sessionId = values.session || positionals[0] || positionals[1];
+      if (!sessionId) {
+        console.error("❌ Error: Missing required session ID. Usage: agentctl patch <session_id> [--apply] [--save <path>]");
+        process.exit(1);
+      }
+
+      const root = resolveRoot();
+      const res = await applySessionPatch(sessionId, {
+        root,
+        apply: Boolean(values.apply),
+        save: values.save,
+      });
+
+      if (values.json) {
+        console.log(JSON.stringify(res, null, 2));
+      } else if (!res.ok) {
+        console.error(`\n❌ Failed to extract or apply patch for session ${sessionId}:`);
+        console.error(`   ${res.error || "Unknown error"}\n`);
+      } else {
+        console.log(`\n📦 Session Git Patch (${sessionId})`);
+        console.log(`------------------------------------------------------------------`);
+        console.log(`  Modified Files      : ${res.files && res.files.length > 0 ? res.files.join(", ") : "None"}`);
+        console.log(`  git apply --check   : ${res.checkPassed ? "✅ CLEAN PASS" : "❌ CONFLICT"}`);
+        console.log(`  Applied to Disk     : ${res.patchApplied ? "✅ APPLIED" : "DRY-RUN ONLY (--apply to write)"}`);
+        if (values.save) {
+          console.log(`  Saved to File       : ${values.save}`);
+        }
+        if (!values.apply && !values.save && res.patch) {
+          console.log(`\n--- Patch Content ---\n${res.patch}\n---------------------\n`);
+        }
+      }
+
+      process.exit(res.ok ? 0 : 1);
+      break;
+    }
+
+    case "retry": {
+      const { retrySession, resolveRoot } = await import("../index.mjs");
+      const { values, positionals } = parseArgs({
+        args: args.slice(1),
+        options: {
+          session: { type: "string", short: "s" },
+          role: { type: "string", short: "r" },
+          title: { type: "string", short: "t" },
+          "without-failure": { type: "boolean" },
+          "dry-run": { type: "boolean", short: "d" },
+          json: { type: "boolean", short: "j" },
+        },
+        allowPositionals: true,
+      });
+
+      const sessionId = values.session || positionals[0] || positionals[1];
+      if (!sessionId) {
+        console.error("❌ Error: Missing required session ID. Usage: agentctl retry <session_id> [--role <role>]");
+        process.exit(1);
+      }
+
+      const root = resolveRoot();
+      const res = await retrySession(sessionId, {
+        root,
+        role: values.role,
+        title: values.title,
+        withFailure: values["without-failure"] ? false : true,
+        dryRun: Boolean(values["dry-run"]),
+      });
+
+      if (values.json) {
+        console.log(JSON.stringify(res, null, 2));
+      } else {
+        console.log(`\n🔄 Session Retry Dispatched!`);
+        console.log(`------------------------------------------------------------------`);
+        console.log(`  Original Session    : ${res.originalSessionId}`);
+        console.log(`  New Session ID      : ${res.newSession?.id || "N/A"}`);
+        console.log(`  Failure Trace Added : ${res.failureReason ? "YES" : "NO"}`);
+        console.log(`------------------------------------------------------------------\n`);
+      }
+
+      process.exit(res.ok ? 0 : 1);
+      break;
+    }
+
+    case "prune": {
+      const { pruneSessions, resolveRoot } = await import("../index.mjs");
+      const { values } = parseArgs({
+        args: args.slice(1),
+        options: {
+          age: { type: "string", short: "a" },
+          state: { type: "string", short: "s" },
+          delete: { type: "boolean" },
+          "dry-run": { type: "boolean", short: "d" },
+          yes: { type: "boolean", short: "y" },
+          json: { type: "boolean", short: "j" },
+        },
+        allowPositionals: true,
+      });
+
+      const root = resolveRoot();
+      const dryRun = values["dry-run"] || (!values.yes && !values.delete);
+      const res = await pruneSessions({
+        root,
+        age: values.age || "7d",
+        state: values.state,
+        delete: Boolean(values.delete),
+        dryRun,
+      });
+
+      if (values.json) {
+        console.log(JSON.stringify(res, null, 2));
+      } else {
+        console.log(`\n🧹 Session Pruning Report (${dryRun ? "DRY RUN" : "EXECUTED"})`);
+        console.log(`------------------------------------------------------------------`);
+        console.log(`  Filter Age Cutoff   : ${values.age || "7d"}`);
+        console.log(`  Filter Target State : ${values.state || "ALL"}`);
+        console.log(`  Matched Sessions    : ${res.matchedCount}`);
+        console.log(`  Archived / Deleted  : ${res.archivedCount}`);
+        console.log(`------------------------------------------------------------------`);
+        for (const s of res.sessions) {
+          console.log(`  - [${s.action}] ${s.id} (State: ${s.state || "UNKNOWN"})`);
+        }
+        if (dryRun && res.matchedCount > 0) {
+          console.log(`\n💡 Re-run with --yes to archive matched sessions.\n`);
+        }
+      }
+
+      process.exit(0);
+      break;
+    }
+
     case "assert": {
       const { runAssertion, parseYaml } = await import("../index.mjs");
       const { values } = parseArgs({
@@ -1092,6 +1243,9 @@ async function main() {
         args: args.slice(1),
         options: {
           interactive: { type: "boolean", short: "i" },
+          "non-interactive": { type: "boolean" },
+          "no-interactive": { type: "boolean" },
+          yes: { type: "boolean", short: "y" },
           tier: { type: "string", short: "t" },
           json: { type: "boolean", short: "j" },
           "dry-run": { type: "boolean", short: "d" },
@@ -1100,9 +1254,11 @@ async function main() {
         allowPositionals: true,
       });
 
+      const isInteractive = values.interactive !== false && !values["non-interactive"] && !values["no-interactive"] && !values.yes;
+
       const { runInitWizard } = await import("../src/wizard-init.mjs");
       const res = await runInitWizard(root, {
-        interactive: values.interactive !== false,
+        interactive: isInteractive,
         // No `|| "pro"`: a hardcoded default here overrode both the tier picked
         // in the menu and the tier already recorded in .agent/config.yml on a
         // re-run. Undefined lets the wizard seed the menu from the existing
@@ -1123,7 +1279,11 @@ async function main() {
       } else {
         console.log(`✅ Onboarding complete! Manifest generated at ${res.configPath}`);
         console.log(`   Tier: ${res.plan.tier.toUpperCase()} (${res.plan.limits.concurrency} worker(s), ${res.plan.limits.daily_tasks} daily tasks)`);
-        console.log(`   Verification Test Command : "${res.plan.verify.test}"`);
+        if (res.plan.verify.test) {
+          console.log(`   Verification Test Command : "${res.plan.verify.test}"`);
+        } else {
+          console.log(`   Verification Test Command : None detected (run "agentctl bootstrap" to create a test oracle)`);
+        }
         console.log(`   Active Presets            : ${res.plan.presets.join(", ")}`);
         for (const item of scaffold.created) {
           console.log(`   Scaffolded                : ${item}`);
@@ -1137,8 +1297,10 @@ async function main() {
         // uncommitted meant the very first `agentctl gate` rejected the working
         // tree for files init had just written, which reads as the tool
         // catching the user cheating on step three.
-        console.log(`\n   Commit the manifest so the gate does not read it as an agent edit:`);
-        console.log(`     git add .agent AGENTS.md .gitignore && git commit -m "chore: add agent config"`);
+        const rootContracts = ["SPEC.md", "CONSTRAINTS.md", "DESIGN.md"].filter((f) => existsSync(join(root, f)));
+        const filesToAdd = [".agent", "AGENTS.md", ...rootContracts, ".gitignore"].filter((f) => existsSync(join(root, f)));
+        console.log(`\n   Commit the manifest and contracts so the gate does not read them as agent edits:`);
+        console.log(`     git add ${filesToAdd.join(" ")} && git commit -m "chore: add agent config"`);
 
         const { resolveNextStep, renderNextStep } = await import("../src/ops/next-step.mjs");
         const next = resolveNextStep(root);
@@ -1166,12 +1328,19 @@ async function main() {
             "auto-pr": { type: "boolean" },
             "require-plan-approval": { type: "boolean" },
             repoless: { type: "boolean" },
+            interactive: { type: "boolean", short: "i" },
+            "non-interactive": { type: "boolean" },
+            "no-interactive": { type: "boolean" },
+            yes: { type: "boolean", short: "y" },
             json: { type: "boolean", short: "j" },
             "dry-run": { type: "boolean", short: "d" },
           },
           allowPositionals: true,
         });
 
+        const isNonInteractive = Boolean(values["non-interactive"] || values["no-interactive"] || values.yes);
+        const isInteractive = values.interactive === true ? true : (isNonInteractive ? false : undefined);
+
         const { runTaskCreateWizard } = await import("../src/wizard-task.mjs");
         const res = await runTaskCreateWizard(root, {
           title: values.title,
@@ -1184,6 +1353,7 @@ async function main() {
           autoPr: values["auto-pr"],
           requirePlanApproval: values["require-plan-approval"],
           repoless: values.repoless,
+          interactive: isInteractive,
         });
 
         if (values.json) {
@@ -1331,7 +1501,7 @@ async function main() {
       const todos = scanCodebaseForTodos(root);
       console.log(`\n🔍 Scanned ${todos.length} TODO/FIXME annotation(s).`);
       for (const t of todos.slice(0, 10)) {
-        console.log(`   - ${t.file}:${t.line} [${t.type}] ${t.text}`);
+        console.log(`   - ${t.file}:${t.line} [${t.type || t.tag || "TODO"}] ${t.text}`);
       }
       if (todos.length > 10) {
         console.log(`   ... and ${todos.length - 10} more.`);

package/index.mjs

@@ -229,3 +229,13 @@ export {
   getHandoverDir,
   HandoverError,
 } from "./src/ops/handover.mjs";
+
+// Jules Power-User Session Operations & Lifecycle Engine
+export {
+  extractSessionPatch,
+  applySessionPatch,
+  retrySession,
+  pruneSessions,
+  parseAgeDuration,
+} from "./src/session-ops.mjs";
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.51.0",
+  "version": "0.52.1",
   "description": "Zero-dependency safety gatekeeper, test oracle generator, and multi-agent coordination protocol for Google Jules (jules) autonomous agents.",
   "repository": {
     "type": "git",

package/scripts/jules-scan-todos.mjs

@@ -24,9 +24,9 @@ export function scanCodebaseForTodos(dir = process.cwd()) {
           const lines = content.split("\n");
           lines.forEach((line, idx) => {
             if (line.includes("TODO:")) {
-              todos.push({ file: full, line: idx + 1, text: line.trim(), tag: "TODO", priority: "MEDIUM" });
+              todos.push({ file: full, line: idx + 1, text: line.trim(), tag: "TODO", type: "TODO", priority: "MEDIUM" });
             } else if (line.includes("FIXME:")) {
-              todos.push({ file: full, line: idx + 1, text: line.trim(), tag: "FIXME", priority: "HIGH" });
+              todos.push({ file: full, line: idx + 1, text: line.trim(), tag: "FIXME", type: "FIXME", priority: "HIGH" });
             }
           });
         }

package/src/mcp.mjs

@@ -8,6 +8,13 @@ import { reapOrphanedIntents, reapStaleMutexDirs } from "./journal.mjs";
 import { readTelemetry } from "./telemetry.mjs";
 import { ProgressBus } from "./mcp-progress.mjs";
 import { KIT_VERSION } from "./version.mjs";
+import { createProvider } from "./provider.mjs";
+import {
+  extractSessionPatch,
+  applySessionPatch,
+  retrySession,
+  pruneSessions,
+} from "./session-ops.mjs";
 
 export const MCP_SERVER_INFO = {
   name: "jules-orchestrator-kit",
@@ -196,6 +203,113 @@ export const MCP_TOOLS = [
       required: ["trigger", "solution"],
     },
   },
+  {
+    name: "jules_list_sessions",
+    description: "List remote Jules coding sessions with optional pagination and state filtering.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pageSize: { type: "number", description: "Maximum number of sessions to return (default 50)" },
+        pageToken: { type: "string", description: "Page token for cursor pagination" },
+      },
+    },
+  },
+  {
+    name: "jules_list_activities",
+    description: "List execution activities, logs, and error outputs for a specific Jules session.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Jules session ID" },
+        pageSize: { type: "number", description: "Maximum number of activities to return" },
+        pageToken: { type: "string", description: "Page token for pagination" },
+      },
+      required: ["sessionId"],
+    },
+  },
+  {
+    name: "jules_get_session_output",
+    description: "Extract the git diff patch, pull request metadata, and changed files from a Jules session.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Jules session ID" },
+      },
+      required: ["sessionId"],
+    },
+  },
+  {
+    name: "jules_archive_session",
+    description: "Archive a Jules coding session to clean up the dashboard.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Jules session ID to archive" },
+      },
+      required: ["sessionId"],
+    },
+  },
+  {
+    name: "jules_delete_session",
+    description: "Permanently delete a Jules coding session.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Jules session ID to delete" },
+      },
+      required: ["sessionId"],
+    },
+  },
+  {
+    name: "jules_retry_session",
+    description: "Retry a failed Jules session by extracting failure diagnostics and dispatching a new OODA repair session.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Original failed Jules session ID" },
+        role: { type: "string", description: "Optional specialist role override" },
+        withFailure: { type: "boolean", description: "Include previous failure diagnostic in retry prompt (default true)" },
+      },
+      required: ["sessionId"],
+    },
+  },
+  {
+    name: "jules_apply_patch",
+    description: "Extract and apply a Jules session's git patch to the local workspace with git apply safety verification.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Jules session ID to extract patch from" },
+        apply: { type: "boolean", description: "If true, applies the patch; if false, runs git apply --check dry-run" },
+        save: { type: "string", description: "Optional file path to save raw patch diff to" },
+      },
+      required: ["sessionId"],
+    },
+  },
+  {
+    name: "jules_list_sources",
+    description: "List connected GitHub repository sources available to the Jules account.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pageSize: { type: "number", description: "Maximum number of sources to return" },
+        pageToken: { type: "string", description: "Page token for pagination" },
+      },
+    },
+  },
+  {
+    name: "jules_prune_sessions",
+    description: "Batch-archive or prune old/completed Jules sessions matching age and state filters.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        age: { type: "string", description: "Age cutoff string (e.g. '7d', '24h', '30m')" },
+        state: { type: "string", description: "Target session state to filter (e.g. 'FAILED', 'COMPLETED')" },
+        dryRun: { type: "boolean", description: "If true, previews sessions without modifying (default true)" },
+        delete: { type: "boolean", description: "If true, permanently deletes instead of archiving" },
+      },
+    },
+  },
 ];
 
 export async function handleMcpRequest(request, opts = {}) {
@@ -431,6 +545,169 @@ export async function handleMcpRequest(request, opts = {}) {
         };
       }
 
+      if (toolName === "jules_list_sessions") {
+        const provider = createProvider(config.provider || "jules", config);
+        const res = await provider.listSessions({ root, pageSize: args.pageSize, pageToken: args.pageToken });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, ...res }, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_list_activities") {
+        if (!args.sessionId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Missing required parameter 'sessionId'" },
+          };
+        }
+        const provider = createProvider(config.provider || "jules", config);
+        const res = await provider.listActivities(args.sessionId, { root, pageSize: args.pageSize, pageToken: args.pageToken });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, ...res }, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_get_session_output") {
+        if (!args.sessionId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Missing required parameter 'sessionId'" },
+          };
+        }
+        const res = await extractSessionPatch(args.sessionId, { root, config });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_archive_session") {
+        if (!args.sessionId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Missing required parameter 'sessionId'" },
+          };
+        }
+        const provider = createProvider(config.provider || "jules", config);
+        const res = await provider.archiveSession(args.sessionId, { root });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, ...res }, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_delete_session") {
+        if (!args.sessionId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Missing required parameter 'sessionId'" },
+          };
+        }
+        const provider = createProvider(config.provider || "jules", config);
+        const res = await provider.deleteSession(args.sessionId, { root });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, ...res }, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_retry_session") {
+        if (!args.sessionId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Missing required parameter 'sessionId'" },
+          };
+        }
+        const res = await retrySession(args.sessionId, {
+          root,
+          config,
+          role: args.role,
+          withFailure: args.withFailure !== false,
+        });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_apply_patch") {
+        if (!args.sessionId) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Missing required parameter 'sessionId'" },
+          };
+        }
+        const res = await applySessionPatch(args.sessionId, {
+          root,
+          config,
+          apply: Boolean(args.apply),
+          save: args.save,
+        });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_list_sources") {
+        const provider = createProvider(config.provider || "jules", config);
+        const res = await provider.listSources({ root, pageSize: args.pageSize, pageToken: args.pageToken });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, ...res }, null, 2) }],
+          },
+        };
+      }
+
+      if (toolName === "jules_prune_sessions") {
+        const res = await pruneSessions({
+          root,
+          config,
+          age: args.age || "7d",
+          state: args.state,
+          delete: Boolean(args.delete),
+          dryRun: args.dryRun !== false,
+        });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+          },
+        };
+      }
+
       return {
         jsonrpc: "2.0",
         id,