@appchy/jarvis 0.1.36 → 0.1.37

package/dev/bin.js

@@ -28752,7 +28752,8 @@ ${content}`;
       const entry = activeRuns.get(req.runId);
       if (entry?.sdk?.setPermissionMode) {
         try {
-          await entry.sdk.setPermissionMode(req.mode);
+          const translated = toClaudeCode({ mode: req.mode });
+          await entry.sdk.setPermissionMode(translated);
         } catch (err) {
           logger.sys.warn("[claude-code] setPermissionMode failed", {
             runId: req.runId,
@@ -29661,7 +29662,7 @@ function buildChat(req) {
   };
 }
 var SESSION_CACHE_NAMESPACE = "sessions";
-var SESSION_CACHE_VERSION = 10;
+var SESSION_CACHE_VERSION = 11;
 async function readSessionCacheEntry(req) {
   const { value } = await readCacheEntry({
     namespace: SESSION_CACHE_NAMESPACE,
@@ -29781,6 +29782,36 @@ async function recordExternalId(_ctx, req) {
   });
   await writeSessionCacheEntry({ sessionId: req.chatId, entry: next });
 }
+async function recordTurnSettings(_ctx, req) {
+  const { entry: existing } = await readSessionCacheEntry({ sessionId: req.chatId });
+  const nextSkill = req.skill ?? void 0;
+  const nextEnabled = req.enabledTools?.length ? req.enabledTools : void 0;
+  if (existing?.lastSkill === nextSkill && arraysEqual(existing?.lastEnabledTools, nextEnabled)) {
+    return;
+  }
+  const base = existing ?? createSessionCacheEntry({
+    filePath: "",
+    rollup: createEmptyRollup(),
+    pendingToolUses: {},
+    progress: { bytes: 0, line: 0, mtimeMs: 0 },
+    controller: "jarvis"
+  });
+  const next = {
+    ...base,
+    ...nextSkill ? { lastSkill: nextSkill } : { lastSkill: void 0 },
+    ...nextEnabled ? { lastEnabledTools: nextEnabled } : { lastEnabledTools: void 0 }
+  };
+  await writeSessionCacheEntry({ sessionId: req.chatId, entry: next });
+}
+function arraysEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return !a && !b;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
 var TRANSCRIPT_CACHE_NAMESPACE = "transcripts";
 var TRANSCRIPT_CACHE_VERSION = 10;
 async function readTranscriptCacheEntry(req) {
@@ -30723,8 +30754,10 @@ function getTaskProvider() {
 
 // src/resume.ts
 function buildResumePayload(req) {
-  const { output, inputId, controller, toolUseId } = req;
+  const { output, inputId, controller, toolUseId, carryOver } = req;
   const mode = output.action === "allow" && output.mode ? output.mode : void 0;
+  const skill2 = carryOver?.skill;
+  const enabledTools = carryOver?.enabledTools?.length ? carryOver.enabledTools : void 0;
   const allowed = output.action === "allow";
   const rejectionContent = output.feedback && output.feedback.trim().length > 0 ? output.feedback : "User denied this tool call.";
   if (controller !== "claudeCode" && toolUseId) {
@@ -30734,24 +30767,36 @@ function buildResumePayload(req) {
         toolUseId,
         content: "User approved this tool call.",
         denied: false,
-        ...mode ? { mode } : {}
+        ...mode ? { mode } : {},
+        ...skill2 ? { skill: skill2 } : {},
+        ...enabledTools ? { enabledTools } : {}
       };
     }
     return {
       kind: "tool_result",
       toolUseId,
       content: rejectionContent,
-      denied: true
+      denied: true,
+      ...skill2 ? { skill: skill2 } : {},
+      ...enabledTools ? { enabledTools } : {}
     };
   }
   const id = `resume-${inputId}`;
   if (allowed) {
     const content = "I approve this tool call. Please continue.";
-    return mode ? { kind: "user_message", message: { id, content }, mode } : { kind: "user_message", message: { id, content } };
+    return {
+      kind: "user_message",
+      message: { id, content },
+      ...mode ? { mode } : {},
+      ...skill2 ? { skill: skill2 } : {},
+      ...enabledTools ? { enabledTools } : {}
+    };
   }
   return {
     kind: "user_message",
-    message: { id, content: rejectionContent }
+    message: { id, content: rejectionContent },
+    ...skill2 ? { skill: skill2 } : {},
+    ...enabledTools ? { enabledTools } : {}
   };
 }
 
@@ -32031,6 +32076,10 @@ async function resolveInteraction(ctx, req) {
   }
   const { entry } = await readSessionCacheEntry({ sessionId: req.sessionId });
   const controller = entry?.controller;
+  const carryOver = entry ? {
+    ...entry.lastSkill ? { skill: entry.lastSkill } : {},
+    ...entry.lastEnabledTools?.length ? { enabledTools: entry.lastEnabledTools } : {}
+  } : void 0;
   const resume = buildResumePayload({
     output: req.output,
     inputId: req.inputId,
@@ -32038,7 +32087,8 @@ async function resolveInteraction(ctx, req) {
     // `pendingInput.id === toolUseID` by construction (see
     // `convertGenericTool` / `fromSdkInput` in the provider), so
     // `req.inputId` IS the open tool_use_id for tool interactions.
-    toolUseId: req.inputId
+    toolUseId: req.inputId,
+    ...carryOver && (carryOver.skill || carryOver.enabledTools) ? { carryOver } : {}
   });
   const messages = resume.kind === "tool_result" ? [
     {
@@ -32059,7 +32109,9 @@ async function resolveInteraction(ctx, req) {
     chatId: req.sessionId,
     session: { resume: req.sessionId },
     messages,
-    ...resume.mode ? { mode: resume.mode } : {}
+    ...resume.mode ? { mode: resume.mode } : {},
+    ...resume.skill ? { skill: resume.skill } : {},
+    ...resume.enabledTools?.length ? { enabledTools: resume.enabledTools } : {}
   });
   return { resumed: true };
 }
@@ -32114,7 +32166,11 @@ async function runTask(ctx, req) {
     ...extraTools.length > 0 ? { tools: extraTools } : {}
   };
   if (!normalized.code && req.chatId) {
-    const task = await getTaskProvider().get(ctx, { id: req.chatId });
+    const { entry: sessionEntry } = await readSessionCacheEntry({
+      sessionId: req.chatId
+    });
+    const taskLookupId = sessionEntry?.taskId ?? req.chatId;
+    const task = await getTaskProvider().get(ctx, { id: taskLookupId });
     if (task) {
       const workdir = task.state?.workdir;
       const repo = task.config?.repo;
@@ -32124,6 +32180,13 @@ async function runTask(ctx, req) {
           ...repo ? { repo } : {}
         };
       }
+    } else {
+      logger.warn(ctx, "[runTask] task lookup miss \u2014 code.workdir unset", {
+        runId,
+        chatId: req.chatId,
+        taskLookupId,
+        sessionTaskId: sessionEntry?.taskId ?? null
+      });
     }
   }
   if (!normalized.code?.workdir && normalized.code?.repo) {
@@ -32191,6 +32254,19 @@ async function runTask(ctx, req) {
   publish(ctx, "chat.status", { chatId: runId, status: "busy" });
   runningChats.add(runId);
   logger.info(ctx, "[runTask.add]", { runId, runningChatsSize: runningChats.size });
+  if (req.chatId) {
+    void recordTurnSettings(ctx, {
+      chatId: req.chatId,
+      ...normalized.skill ? { skill: normalized.skill } : {},
+      ...normalized.enabledTools?.length ? { enabledTools: normalized.enabledTools } : {}
+    }).catch((err) => {
+      logger.warn(ctx, "[runTask] recordTurnSettings failed", {
+        runId,
+        chatId: req.chatId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
   try {
     const result = await getProvider().run(ctx, normalized, {
       onEvent: (event) => publish(ctx, "chat.event", { chatId: runId, event }),
@@ -32274,7 +32350,8 @@ async function runTask(ctx, req) {
         ...req.modelId ? { modelId: req.modelId } : {},
         ...req.thinking ? { thinking: req.thinking } : {},
         ...req.enabledTools?.length ? { enabledTools: req.enabledTools } : {},
-        ...req.skill ? { skill: req.skill } : {}
+        ...req.skill ? { skill: req.skill } : {},
+        ...req.references?.length ? { references: req.references } : {}
       };
       const feedbackEvent = {
         id: queued.id,
@@ -32658,6 +32735,22 @@ async function send(ctx, req) {
   publish(ctx, "chat.event", { chatId: req.chatId, event: userEvent });
   await appendCachedEvent({ sessionId: req.chatId, event: userEvent });
   if (isRunning(req.chatId)) {
+    if (req.mode) {
+      await setMode(ctx, { runId: req.chatId, mode: req.mode });
+    }
+    if (req.model) {
+      await setModel(ctx, { runId: req.chatId, model: req.model });
+    }
+    if (req.thinking) {
+      await setThinking(ctx, { runId: req.chatId, thinking: req.thinking });
+    }
+    if (req.skill || req.enabledTools?.length) {
+      logger.warn(ctx, "[runner.chat.send] skill/enabledTools change ignored mid-query", {
+        chatId: req.chatId,
+        skill: req.skill ?? null,
+        enabledToolsCount: req.enabledTools?.length ?? 0
+      });
+    }
     const queued = await enqueueMessage(ctx, {
       runId: req.chatId,
       content: req.content,
@@ -32768,6 +32861,12 @@ function parseUpdate(params) {
 }
 async function update(ctx, req) {
   const { chatId, patch } = req;
+  const { entry: session } = await readSessionCacheEntry({ sessionId: chatId });
+  if (session?.controller === "claudeCode") {
+    throw new Error(
+      "controller_mismatch: this chat is owned by the terminal Claude Code CLI. Send a message to take over before changing settings."
+    );
+  }
   if (patch.mode) {
     await setMode(ctx, { runId: chatId, mode: patch.mode });
   }
@@ -32817,7 +32916,11 @@ async function get(_ctx, req) {
     prefs: {
       mode: transcript.mode ?? "auto",
       model: session?.rollup.model ?? "",
-      thinking: { type: "disabled" }
+      // Same source as `mode`/`model` — the rollup is populated by the
+      // JSONL projector from the latest assistant turn's thinking config.
+      // Cold-loaded CC-watched chats reflect the session's current
+      // thinking setting in the picker without walking the event stream.
+      thinking: session?.rollup.thinking ?? { type: "disabled" }
     },
     isRunning: isRunning(req.chatId),
     ...session?.controller ? { controller: session.controller } : {}