opencara 0.105.4 → 0.107.0

package/dist/bin.js

@@ -82,12 +82,19 @@ var AcpHistoryTurnSchema = z3.object({
   role: z3.enum(["user", "assistant"]),
   text: z3.string()
 });
+var AcpPermissionModeSchema = z3.enum([
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions"
+]);
 var AcpSpecSchema = z3.object({
   systemPromptMd: z3.string(),
   userPromptMd: z3.string(),
   history: z3.array(AcpHistoryTurnSchema).default([]),
   pageContextJson: z3.string().optional(),
-  priorSessionId: z3.string().optional()
+  priorSessionId: z3.string().optional(),
+  permissionMode: AcpPermissionModeSchema.optional()
 });
 var AgentSpecSchema = z3.object({
   kind: z3.string(),
@@ -198,6 +205,11 @@ var HelloAckSchema = z4.object({
   agentHostId: z4.string(),
   deviceName: z4.string()
 });
+var CancelJobSchema = z4.object({
+  type: z4.literal("cancel"),
+  runId: z4.string(),
+  reason: z4.enum(["user_stopped", "wave_cancelled"])
+});
 var PingSchema = z4.object({ type: z4.literal("ping") });
 var PongSchema = z4.object({ type: z4.literal("pong") });
 var AgentCallEnvelope = {
@@ -225,10 +237,56 @@ var TemplateNodeConfigSetCallSchema = z4.object({
   nodeId: z4.string().min(1),
   config: z4.record(z4.string(), z4.unknown())
 });
+var KanbanWaveDispatchCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("kanban.wave.dispatch"),
+  flowSlug: z4.string().min(1),
+  issueNumbers: z4.array(z4.number().int()).min(1).max(10)
+});
+var IssueSubissueCreateCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("issue.subissue.create"),
+  parentIssueNumber: z4.number().int(),
+  title: z4.string().min(1),
+  bodyMd: z4.string(),
+  labels: z4.array(z4.string()).optional()
+});
+var IssueCreateCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("issue.create"),
+  title: z4.string().min(1),
+  bodyMd: z4.string(),
+  labels: z4.array(z4.string()).optional()
+});
+var IssueStateSetCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("issue.state.set"),
+  issueNumber: z4.number().int(),
+  state: z4.enum(["open", "closed"]),
+  stateReason: z4.enum(["completed", "not_planned", "reopened"]).nullable().optional()
+});
+var IssueCommentCreateCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("issue.comment.create"),
+  issueNumber: z4.number().int(),
+  bodyMd: z4.string().min(1)
+});
+var IssueLabelsSetCallSchema = z4.object({
+  ...AgentCallEnvelope,
+  kind: z4.literal("issue.labels.set"),
+  issueNumber: z4.number().int(),
+  labels: z4.array(z4.string())
+});
 var AgentCallSchema = z4.discriminatedUnion("kind", [
   IssueBodySetCallSchema,
   FlowNodeConfigSetCallSchema,
-  TemplateNodeConfigSetCallSchema
+  TemplateNodeConfigSetCallSchema,
+  KanbanWaveDispatchCallSchema,
+  IssueSubissueCreateCallSchema,
+  IssueCreateCallSchema,
+  IssueStateSetCallSchema,
+  IssueCommentCreateCallSchema,
+  IssueLabelsSetCallSchema
 ]);
 var AgentCallRequestEnvelope = {
   type: z4.literal("agent-call-request"),
@@ -255,10 +313,56 @@ var TemplateNodeConfigSetCallRequestSchema = z4.object({
   nodeId: z4.string().min(1),
   config: z4.record(z4.string(), z4.unknown())
 });
+var KanbanWaveDispatchCallRequestSchema = z4.object({
+  ...AgentCallRequestEnvelope,
+  kind: z4.literal("kanban.wave.dispatch"),
+  flowSlug: z4.string().min(1),
+  issueNumbers: z4.array(z4.number().int()).min(1).max(10)
+});
+var IssueSubissueCreateCallRequestSchema = z4.object({
+  ...AgentCallRequestEnvelope,
+  kind: z4.literal("issue.subissue.create"),
+  parentIssueNumber: z4.number().int(),
+  title: z4.string().min(1),
+  bodyMd: z4.string(),
+  labels: z4.array(z4.string()).optional()
+});
+var IssueCreateCallRequestSchema = z4.object({
+  ...AgentCallRequestEnvelope,
+  kind: z4.literal("issue.create"),
+  title: z4.string().min(1),
+  bodyMd: z4.string(),
+  labels: z4.array(z4.string()).optional()
+});
+var IssueStateSetCallRequestSchema = z4.object({
+  ...AgentCallRequestEnvelope,
+  kind: z4.literal("issue.state.set"),
+  issueNumber: z4.number().int(),
+  state: z4.enum(["open", "closed"]),
+  stateReason: z4.enum(["completed", "not_planned", "reopened"]).nullable().optional()
+});
+var IssueCommentCreateCallRequestSchema = z4.object({
+  ...AgentCallRequestEnvelope,
+  kind: z4.literal("issue.comment.create"),
+  issueNumber: z4.number().int(),
+  bodyMd: z4.string().min(1)
+});
+var IssueLabelsSetCallRequestSchema = z4.object({
+  ...AgentCallRequestEnvelope,
+  kind: z4.literal("issue.labels.set"),
+  issueNumber: z4.number().int(),
+  labels: z4.array(z4.string())
+});
 var AgentCallRequestSchema = z4.discriminatedUnion("kind", [
   IssueBodySetCallRequestSchema,
   FlowNodeConfigSetCallRequestSchema,
-  TemplateNodeConfigSetCallRequestSchema
+  TemplateNodeConfigSetCallRequestSchema,
+  KanbanWaveDispatchCallRequestSchema,
+  IssueSubissueCreateCallRequestSchema,
+  IssueCreateCallRequestSchema,
+  IssueStateSetCallRequestSchema,
+  IssueCommentCreateCallRequestSchema,
+  IssueLabelsSetCallRequestSchema
 ]);
 var AgentCallResultSchema = z4.object({
   type: z4.literal("agent-call-result"),
@@ -273,7 +377,8 @@ var ServerToDeviceMessageSchema = z4.discriminatedUnion("type", [
   JobAssignmentSchema,
   HelloAckSchema,
   PingSchema,
-  AgentCallResultSchema
+  AgentCallResultSchema,
+  CancelJobSchema
 ]);
 var DeviceToServerMessageSchema = z4.union([
   HelloMessageSchema,
@@ -1073,9 +1178,35 @@ function runAcpJob(opts) {
   const translator = createUpdateTranslator(handlers.onLog);
   client.onSessionUpdate((p) => translator.handle(p.update));
   client.onStderr((chunk) => handlers.onLog("stderr", chunk));
+  let activeSessionId = null;
+  let cancelRequested = false;
+  let forceCloseScheduled = false;
+  const scheduleForceClose = () => {
+    if (forceCloseScheduled) return;
+    forceCloseScheduled = true;
+    setTimeout(() => {
+      client.close(0).catch(() => void 0);
+    }, 2e3);
+  };
   const controller = {
     onAgentCallResult(msg) {
       bridge.onResult(msg);
+    },
+    cancel() {
+      if (cancelRequested) return;
+      cancelRequested = true;
+      if (activeSessionId) {
+        try {
+          client.cancel(activeSessionId);
+        } catch (err) {
+          handlers.onLog(
+            "stderr",
+            `[opencara] cancel notify failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        }
+      }
+      scheduleForceClose();
     }
   };
   const promise = (async () => {
@@ -1102,8 +1233,21 @@ function runAcpJob(opts) {
         const session = await client.newSession({ cwd, mcpServers });
         sessionId = session.sessionId;
       }
+      activeSessionId = sessionId;
+      if (cancelRequested) {
+        try {
+          client.cancel(sessionId);
+        } catch {
+        }
+        result = { exitCode: 1, stopReason: "cancelled", sessionId };
+        return result;
+      }
       const prompt = buildPromptContent(acpSpec);
-      const promptResult = await client.prompt({ sessionId, prompt });
+      const promptResult = await client.prompt({
+        sessionId,
+        prompt,
+        ...acpSpec.permissionMode ? { permissionMode: acpSpec.permissionMode } : {}
+      });
       result = {
         exitCode: promptResult.stopReason === "end_turn" ? 0 : 1,
         stopReason: promptResult.stopReason,
@@ -1232,7 +1376,7 @@ function resolveLocalAcpAdapter(command, args) {
 }
 
 // src/commands/run.ts
-var PKG_VERSION = "0.105.4";
+var PKG_VERSION = "0.107.0";
 var LOG_FLUSH_MS = 800;
 var MAX_CHUNK_SIZE = 4 * 1024;
 async function run(opts = {}) {
@@ -1283,6 +1427,16 @@ function handleServerMessage(msg, client, _cfg) {
     acpControllers.get(msg.runId)?.onAgentCallResult(msg);
     return;
   }
+  if (msg.type === "cancel") {
+    const ctrl = acpControllers.get(msg.runId);
+    if (ctrl) {
+      console.log(
+        `[opencara] job ${msg.runId.slice(-8)} cancel requested (${msg.reason})`
+      );
+      ctrl.cancel();
+    }
+    return;
+  }
 }
 async function executeJob(job, client) {
   const runId = job.run.id;
@@ -1505,13 +1659,15 @@ import {
   existsSync as existsSync4,
   realpathSync,
   writeFileSync as writeFileSync2,
-  renameSync
+  renameSync,
+  symlinkSync
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2, sep } from "node:path";
 var OPENCARA_ROOT = join2(homedir2(), ".opencara");
 var WORK_ROOT = join2(OPENCARA_ROOT, "work");
 var SESSION_ROOT = join2(OPENCARA_ROOT, "sessions");
+var CACHE_ROOT = join2(OPENCARA_ROOT, "cache");
 async function internal(argv) {
   const sub = argv[0];
   const rest = argv.slice(1);
@@ -1554,17 +1710,56 @@ function worktreeCreate(args) {
   if (!key) fail(`invalid --key '${rawKey}'`);
   const sessionDir = join2(SESSION_ROOT, key);
   const checkoutDir = join2(WORK_ROOT, key, "checkout");
+  const useCache = hasFlag(args, "--cache-repo");
+  const useLfs = hasFlag(args, "--lfs");
+  if (useLfs && !useCache) {
+    fail("--lfs requires --cache-repo");
+  }
+  if (useLfs && !hasGitLfs()) {
+    fail(
+      "--lfs is set but git-lfs is not installed on this host \u2014 install it (e.g. `apt install git-lfs && git lfs install`) or disable LFS on the agent.worktree.cacheRepo config"
+    );
+  }
+  const cacheDir = useCache ? join2(CACHE_ROOT, safeKey(repo)) : null;
+  const gitEnv = useCache && !useLfs ? { ...process.env, GIT_LFS_SKIP_SMUDGE: "1" } : void 0;
   const HELPER_SNIPPET = '!f() { echo username=x-access-token; echo "password=$GH_TOKEN"; }; f';
   const cleanUrl = `https://github.com/${repo}.git`;
   mkdirSync2(sessionDir, { recursive: true });
+  if (cacheDir) {
+    if (existsSync4(join2(cacheDir, ".git"))) {
+      git(cacheDir, ["fetch", "--all", "--prune"], gitEnv);
+    } else {
+      mkdirSync2(cacheDir, { recursive: true });
+      try {
+        git(
+          cacheDir,
+          ["-c", `credential.helper=${HELPER_SNIPPET}`, "clone", cleanUrl, "."],
+          gitEnv
+        );
+        git(cacheDir, ["config", "credential.helper", HELPER_SNIPPET]);
+      } catch (err) {
+        try {
+          if (!existsSync4(join2(cacheDir, ".git", "HEAD"))) {
+            rmSync(cacheDir, { recursive: true, force: true });
+          }
+        } catch {
+        }
+        throw err;
+      }
+    }
+    if (useLfs) {
+      git(cacheDir, ["lfs", "fetch", "--all"], gitEnv);
+      mkdirSync2(join2(cacheDir, ".git", "lfs", "objects"), { recursive: true });
+    }
+  }
   if (existsSync4(join2(checkoutDir, ".git"))) {
-    git(checkoutDir, ["fetch", "origin"]);
+    git(checkoutDir, ["fetch", "origin"], gitEnv);
     if (refExists(checkoutDir, `refs/remotes/origin/${branch}`)) {
-      git(checkoutDir, ["checkout", "-B", branch, `origin/${branch}`]);
+      git(checkoutDir, ["checkout", "-B", branch, `origin/${branch}`], gitEnv);
     } else if (refExists(checkoutDir, `refs/heads/${branch}`)) {
-      git(checkoutDir, ["checkout", branch]);
+      git(checkoutDir, ["checkout", branch], gitEnv);
     } else if (fromBranch) {
-      git(checkoutDir, ["checkout", "-B", branch, `origin/${fromBranch}`]);
+      git(checkoutDir, ["checkout", "-B", branch, `origin/${fromBranch}`], gitEnv);
     } else {
       fail(
         `worktree create: '${branch}' missing locally and on origin/, no --from-branch to fall back to`
@@ -1573,18 +1768,29 @@ function worktreeCreate(args) {
   } else {
     mkdirSync2(checkoutDir, { recursive: true });
     const cloneArgs = ["-c", `credential.helper=${HELPER_SNIPPET}`, "clone"];
+    if (cacheDir) {
+      cloneArgs.push("--no-checkout", "--reference", cacheDir);
+    }
     if (fromBranch) {
       cloneArgs.push("--branch", fromBranch);
     }
     cloneArgs.push(cleanUrl, ".");
     try {
-      git(checkoutDir, cloneArgs);
+      git(checkoutDir, cloneArgs, gitEnv);
+      if (cacheDir && useLfs) {
+        const checkoutLfsDir = join2(checkoutDir, ".git", "lfs");
+        mkdirSync2(checkoutLfsDir, { recursive: true });
+        symlinkSync(
+          join2(cacheDir, ".git", "lfs", "objects"),
+          join2(checkoutLfsDir, "objects")
+        );
+      }
       if (fromBranch && branch === fromBranch) {
-        git(checkoutDir, ["checkout", branch]);
+        git(checkoutDir, ["checkout", branch], gitEnv);
       } else {
-        git(checkoutDir, ["checkout", "-b", branch]);
+        git(checkoutDir, ["checkout", "-b", branch], gitEnv);
       }
-      git(checkoutDir, ["config", "credential.helper", HELPER_SNIPPET]);
+      git(checkoutDir, ["config", "credential.helper", HELPER_SNIPPET], gitEnv);
     } catch (err) {
       try {
         rmSync(checkoutDir, { recursive: true, force: true });
@@ -1668,8 +1874,12 @@ function worktreeRemove(args) {
     rmSync(resolved, { recursive: true, force: true });
   }
 }
-function git(cwd, args) {
-  execFileSync("git", args, { cwd, stdio: ["ignore", "ignore", "inherit"] });
+function git(cwd, args, env) {
+  execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "ignore", "inherit"],
+    env: env ?? process.env
+  });
 }
 function refExists(cwd, ref) {
   try {
@@ -1682,11 +1892,24 @@ function refExists(cwd, ref) {
     return false;
   }
 }
+function hasGitLfs() {
+  try {
+    execFileSync("git", ["lfs", "version"], {
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function pickFlag(argv, name) {
   const i = argv.indexOf(name);
   if (i === -1) return void 0;
   return argv[i + 1];
 }
+function hasFlag(argv, name) {
+  return argv.indexOf(name) !== -1;
+}
 function fail(msg) {
   console.error(msg);
   process.exit(1);

package/dist/claude-acp.js

@@ -62,8 +62,9 @@ function notify(method, params) {
   send({ jsonrpc: "2.0", method, params });
 }
 var sessions = /* @__PURE__ */ new Map();
-async function runClaudeTurn(sessionId, state, promptText) {
+async function runClaudeTurn(sessionId, state, promptText, permissionMode) {
   return new Promise((resolve, reject) => {
+    const idFlag = state.resume ? "--resume" : "--session-id";
     const args = [
       "-p",
       "--output-format",
@@ -73,17 +74,20 @@ async function runClaudeTurn(sessionId, state, promptText) {
       // sense only when stdin can be partial too.
       "--include-partial-messages",
       "--verbose",
-      "--session-id",
-      sessionId,
-      // Headless: no human in the loop to approve tool use. Matches the
-      // legacy `claudeAdapter` posture in agents/kinds.ts.
-      "--dangerously-skip-permissions"
+      idFlag,
+      sessionId
     ];
+    if (permissionMode && permissionMode !== "default") {
+      args.push("--permission-mode", permissionMode);
+    } else {
+      args.push("--dangerously-skip-permissions");
+    }
     const child = spawn("claude", args, {
       cwd: state.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
     });
+    state.activeChild = child;
     child.stdin.on("error", () => {
     });
     child.stdin.end(promptText);
@@ -115,9 +119,14 @@ async function runClaudeTurn(sessionId, state, promptText) {
         reject(err);
       }
     });
-    child.on("close", (code) => {
+    child.on("close", (code, signal) => {
+      state.activeChild = null;
       if (!resolved) {
         resolved = true;
+        if (signal === "SIGTERM" || signal === "SIGINT") {
+          resolve({ stopReason: "cancelled" });
+          return;
+        }
         if (code !== 0) {
           stderr.write(`[claude-acp] claude exited code=${code} without result event
 `);
@@ -205,14 +214,14 @@ function handleInitialize(_params) {
 }
 function handleNewSession(params) {
   const sessionId = randomUUID();
-  sessions.set(sessionId, { cwd: params.cwd ?? process.cwd() });
+  sessions.set(sessionId, { cwd: params.cwd ?? process.cwd(), resume: false });
   return { sessionId };
 }
 function handleLoadSession(params) {
   if (typeof params.sessionId !== "string" || params.sessionId.length === 0) {
     throw new Error("session/load: sessionId required");
   }
-  sessions.set(params.sessionId, { cwd: params.cwd ?? process.cwd() });
+  sessions.set(params.sessionId, { cwd: params.cwd ?? process.cwd(), resume: true });
   return {};
 }
 async function handlePrompt(params) {
@@ -224,9 +233,29 @@ async function handlePrompt(params) {
   if (promptText.length === 0) {
     throw new Error("session/prompt: no text content blocks");
   }
-  const result = await runClaudeTurn(params.sessionId, state, promptText);
+  const result = await runClaudeTurn(
+    params.sessionId,
+    state,
+    promptText,
+    params.permissionMode
+  );
+  state.resume = true;
   return { stopReason: result.stopReason };
 }
+function handleCancel(params) {
+  const state = sessions.get(params.sessionId);
+  if (!state) return;
+  const child = state.activeChild;
+  if (!child) return;
+  try {
+    child.kill("SIGTERM");
+  } catch (err) {
+    stderr.write(
+      `[claude-acp] session/cancel kill failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
 var isMainModule = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("claude-acp.ts") === true || process.argv[1]?.endsWith("claude-acp.js") === true;
 if (isMainModule) {
   const decoder = new FrameDecoder();
@@ -244,7 +273,16 @@ if (isMainModule) {
   });
 }
 async function dispatch(msg) {
-  if (!("id" in msg) || msg.id == null) return;
+  if (!("id" in msg) || msg.id == null) {
+    const notification = msg;
+    if (notification.method === "session/cancel") {
+      const params = notification.params;
+      if (params && typeof params.sessionId === "string") {
+        handleCancel(params);
+      }
+    }
+    return;
+  }
   if ("result" in msg || "error" in msg) return;
   const req = msg;
   try {

package/dist/opencara-mcp.js

@@ -123,12 +123,19 @@ var AcpHistoryTurnSchema = z2.object({
   role: z2.enum(["user", "assistant"]),
   text: z2.string()
 });
+var AcpPermissionModeSchema = z2.enum([
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions"
+]);
 var AcpSpecSchema = z2.object({
   systemPromptMd: z2.string(),
   userPromptMd: z2.string(),
   history: z2.array(AcpHistoryTurnSchema).default([]),
   pageContextJson: z2.string().optional(),
-  priorSessionId: z2.string().optional()
+  priorSessionId: z2.string().optional(),
+  permissionMode: AcpPermissionModeSchema.optional()
 });
 var AgentSpecSchema = z2.object({
   kind: z2.string(),
@@ -239,6 +246,11 @@ var HelloAckSchema = z3.object({
   agentHostId: z3.string(),
   deviceName: z3.string()
 });
+var CancelJobSchema = z3.object({
+  type: z3.literal("cancel"),
+  runId: z3.string(),
+  reason: z3.enum(["user_stopped", "wave_cancelled"])
+});
 var PingSchema = z3.object({ type: z3.literal("ping") });
 var PongSchema = z3.object({ type: z3.literal("pong") });
 var AgentCallEnvelope = {
@@ -266,10 +278,56 @@ var TemplateNodeConfigSetCallSchema = z3.object({
   nodeId: z3.string().min(1),
   config: z3.record(z3.string(), z3.unknown())
 });
+var KanbanWaveDispatchCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("kanban.wave.dispatch"),
+  flowSlug: z3.string().min(1),
+  issueNumbers: z3.array(z3.number().int()).min(1).max(10)
+});
+var IssueSubissueCreateCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("issue.subissue.create"),
+  parentIssueNumber: z3.number().int(),
+  title: z3.string().min(1),
+  bodyMd: z3.string(),
+  labels: z3.array(z3.string()).optional()
+});
+var IssueCreateCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("issue.create"),
+  title: z3.string().min(1),
+  bodyMd: z3.string(),
+  labels: z3.array(z3.string()).optional()
+});
+var IssueStateSetCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("issue.state.set"),
+  issueNumber: z3.number().int(),
+  state: z3.enum(["open", "closed"]),
+  stateReason: z3.enum(["completed", "not_planned", "reopened"]).nullable().optional()
+});
+var IssueCommentCreateCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("issue.comment.create"),
+  issueNumber: z3.number().int(),
+  bodyMd: z3.string().min(1)
+});
+var IssueLabelsSetCallSchema = z3.object({
+  ...AgentCallEnvelope,
+  kind: z3.literal("issue.labels.set"),
+  issueNumber: z3.number().int(),
+  labels: z3.array(z3.string())
+});
 var AgentCallSchema = z3.discriminatedUnion("kind", [
   IssueBodySetCallSchema,
   FlowNodeConfigSetCallSchema,
-  TemplateNodeConfigSetCallSchema
+  TemplateNodeConfigSetCallSchema,
+  KanbanWaveDispatchCallSchema,
+  IssueSubissueCreateCallSchema,
+  IssueCreateCallSchema,
+  IssueStateSetCallSchema,
+  IssueCommentCreateCallSchema,
+  IssueLabelsSetCallSchema
 ]);
 var AgentCallRequestEnvelope = {
   type: z3.literal("agent-call-request"),
@@ -296,10 +354,56 @@ var TemplateNodeConfigSetCallRequestSchema = z3.object({
   nodeId: z3.string().min(1),
   config: z3.record(z3.string(), z3.unknown())
 });
+var KanbanWaveDispatchCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("kanban.wave.dispatch"),
+  flowSlug: z3.string().min(1),
+  issueNumbers: z3.array(z3.number().int()).min(1).max(10)
+});
+var IssueSubissueCreateCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("issue.subissue.create"),
+  parentIssueNumber: z3.number().int(),
+  title: z3.string().min(1),
+  bodyMd: z3.string(),
+  labels: z3.array(z3.string()).optional()
+});
+var IssueCreateCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("issue.create"),
+  title: z3.string().min(1),
+  bodyMd: z3.string(),
+  labels: z3.array(z3.string()).optional()
+});
+var IssueStateSetCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("issue.state.set"),
+  issueNumber: z3.number().int(),
+  state: z3.enum(["open", "closed"]),
+  stateReason: z3.enum(["completed", "not_planned", "reopened"]).nullable().optional()
+});
+var IssueCommentCreateCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("issue.comment.create"),
+  issueNumber: z3.number().int(),
+  bodyMd: z3.string().min(1)
+});
+var IssueLabelsSetCallRequestSchema = z3.object({
+  ...AgentCallRequestEnvelope,
+  kind: z3.literal("issue.labels.set"),
+  issueNumber: z3.number().int(),
+  labels: z3.array(z3.string())
+});
 var AgentCallRequestSchema = z3.discriminatedUnion("kind", [
   IssueBodySetCallRequestSchema,
   FlowNodeConfigSetCallRequestSchema,
-  TemplateNodeConfigSetCallRequestSchema
+  TemplateNodeConfigSetCallRequestSchema,
+  KanbanWaveDispatchCallRequestSchema,
+  IssueSubissueCreateCallRequestSchema,
+  IssueCreateCallRequestSchema,
+  IssueStateSetCallRequestSchema,
+  IssueCommentCreateCallRequestSchema,
+  IssueLabelsSetCallRequestSchema
 ]);
 var AgentCallResultSchema = z3.object({
   type: z3.literal("agent-call-result"),
@@ -314,7 +418,8 @@ var ServerToDeviceMessageSchema = z3.discriminatedUnion("type", [
   JobAssignmentSchema,
   HelloAckSchema,
   PingSchema,
-  AgentCallResultSchema
+  AgentCallResultSchema,
+  CancelJobSchema
 ]);
 var DeviceToServerMessageSchema = z3.union([
   HelloMessageSchema,
@@ -383,6 +488,42 @@ var templateNodeConfigSetShape = TemplateNodeConfigSetCallSchema.omit({
   callId: true,
   kind: true
 }).shape;
+var kanbanWaveDispatchShape = KanbanWaveDispatchCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var issueSubissueCreateShape = IssueSubissueCreateCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var issueCreateShape = IssueCreateCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var issueStateSetShape = IssueStateSetCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var issueCommentCreateShape = IssueCommentCreateCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
+var issueLabelsSetShape = IssueLabelsSetCallSchema.omit({
+  type: true,
+  runId: true,
+  callId: true,
+  kind: true
+}).shape;
 var TOOLS = [
   {
     name: "opencara_issue_body_set",
@@ -404,6 +545,48 @@ var TOOLS = [
     title: "Update a flow-template draft node's config",
     description: "Replace the config blob of a node in the user's draft of the named flow template. Per-user scope, not per-project. Reject with reason if the template draft isn't owned by the run's user.",
     inputShape: templateNodeConfigSetShape
+  },
+  {
+    name: "opencara_kanban_wave_dispatch",
+    kind: "kanban.wave.dispatch",
+    title: "Dispatch a batch of issues to a flow",
+    description: "Dispatch up to 10 issues in parallel to the named project flow. Requires project scope. Reject if the flow does not exist, is disabled, or any of the issue numbers are not in the project. Returns the wave id.",
+    inputShape: kanbanWaveDispatchShape
+  },
+  {
+    name: "opencara_issue_subissue_create",
+    kind: "issue.subissue.create",
+    title: "Create a GitHub sub-issue under a parent",
+    description: "Create a new GitHub issue and link it as a child of the given parent issue via the GraphQL addSubIssue mutation. Requires project scope. Reject if the parent issue is not in the project.",
+    inputShape: issueSubissueCreateShape
+  },
+  {
+    name: "opencara_issue_create",
+    kind: "issue.create",
+    title: "Create a top-level GitHub issue",
+    description: "Create a new GitHub issue in the run's project with no parent link. Requires project scope. Returns the new issueNumber and nodeId.",
+    inputShape: issueCreateShape
+  },
+  {
+    name: "opencara_issue_state_set",
+    kind: "issue.state.set",
+    title: "Open or close an existing issue",
+    description: "Set an issue's state to open or closed. Optional stateReason: completed | not_planned | reopened. Requires project scope. Reject if the issue is not in the project.",
+    inputShape: issueStateSetShape
+  },
+  {
+    name: "opencara_issue_comment_create",
+    kind: "issue.comment.create",
+    title: "Post a comment on an issue",
+    description: "Post a Markdown comment on the named issue. Comments are not mirrored locally; the comment lives on GitHub. Requires project scope. Reject if the issue is not in the project.",
+    inputShape: issueCommentCreateShape
+  },
+  {
+    name: "opencara_issue_labels_set",
+    kind: "issue.labels.set",
+    title: "Replace the label set on an issue",
+    description: "Set the issue's labels to exactly the listed names (REST setLabels semantics). Any label not in the list is removed; empty array clears all labels. Requires project scope.",
+    inputShape: issueLabelsSetShape
   }
 ];
 function registerOpencaraTools(server, router) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencara",
-  "version": "0.105.4",
+  "version": "0.107.0",
   "description": "OpenCara agent-host CLI: register a machine as an agent host and run dispatched agents.",
   "license": "MIT",
   "repository": {