@cjhyy/code-shell-core 0.6.0-rc.14 → 0.6.0-rc.15

package/dist/settings/manager.js

@@ -51,14 +51,35 @@ export function isProtectedSettingKey(key) {
     return PROTECTED_SETTING_ROOTS.has(root);
 }
 const FORBIDDEN_SETTING_KEY_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
+function isForbiddenSettingKeySegment(key) {
+    return FORBIDDEN_SETTING_KEY_SEGMENTS.has(key);
+}
 function parseDottedSettingKey(key) {
     const parts = key.split(".");
     if (parts.length === 0 ||
-        parts.some((seg) => seg.length === 0 || FORBIDDEN_SETTING_KEY_SEGMENTS.has(seg))) {
+        parts.some((seg) => seg.length === 0 || isForbiddenSettingKeySegment(seg))) {
         throw new Error(`invalid setting key: ${key}`);
     }
     return parts;
 }
+function sanitizeSettingsValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitizeSettingsValue(entry));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (isForbiddenSettingKeySegment(key))
+            continue;
+        out[key] = sanitizeSettingsValue(child);
+    }
+    return out;
+}
+function sanitizeSettingsObject(data) {
+    return sanitizeSettingsValue(data);
+}
 function isOwnPlainObject(parent, key) {
     if (!Object.prototype.hasOwnProperty.call(parent, key))
         return false;
@@ -174,7 +195,7 @@ export class SettingsManager {
         }
         // 5. CLI flags (highest priority)
         if (flagOverrides && Object.keys(flagOverrides).length > 0) {
-            this.sources.push({ name: "flag", priority: 4, data: flagOverrides });
+            this.sources.push({ name: "flag", priority: 4, data: sanitizeSettingsObject(flagOverrides) });
         }
         // Sort by priority ascending (merge in order, later wins)
         this.sources.sort((a, b) => a.priority - b.priority);
@@ -215,7 +236,7 @@ export class SettingsManager {
         const userPath = join(userHome(), ".code-shell", "settings.json");
         if (readUser && existsSync(userPath)) {
             try {
-                const userRaw = JSON.parse(readFileSync(userPath, "utf-8"));
+                const userRaw = sanitizeSettingsObject(JSON.parse(readFileSync(userPath, "utf-8")));
                 const result = migrateModels({
                     providers: userRaw.providers ?? [],
                     models: userRaw.models ?? [],
@@ -227,14 +248,15 @@ export class SettingsManager {
                         providers: result.providers,
                         models: result.models,
                     };
+                    const sanitized = sanitizeSettingsObject(migrated);
                     // Atomic write (tmp+rename) — a concurrent load must not see a
                     // half-written file. File exists here (existsSync guard above).
-                    this.atomicWriteJson(userPath, migrated);
+                    this.atomicWriteJson(userPath, sanitized);
                     // Re-deep-merge with the migrated user data so the validate
                     // call sees the new shape rather than the legacy one.
                     const userSource = this.sources.find((s) => s.name === "user");
                     if (userSource)
-                        userSource.data = migrated;
+                        userSource.data = sanitized;
                     const remerged = this.deepMerge();
                     this.merged = validateSettings(remerged);
                     return this.merged;
@@ -263,7 +285,7 @@ export class SettingsManager {
             const parsed = JSON.parse(readFileSync(path, "utf-8"));
             if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
                 return;
-            const raw = parsed;
+            const raw = sanitizeSettingsObject(parsed);
             const result = migrateConfig(raw);
             if (!result.changed)
                 return;
@@ -279,10 +301,11 @@ export class SettingsManager {
             // Atomic write (tmp+rename) so a concurrent load can't read a half-written
             // migrated file — matches the normal save path (atomicWriteJson). The file
             // exists here (existsSync guard above), so the recursive mkdir is a no-op.
-            this.atomicWriteJson(path, result.config);
+            const sanitized = sanitizeSettingsObject(result.config);
+            this.atomicWriteJson(path, sanitized);
             const source = this.sources.find((s) => s.name === sourceName);
             if (source)
-                source.data = result.config;
+                source.data = sanitized;
         }
         catch {
             // Best-effort — fall through to normal merge/validate.
@@ -318,7 +341,7 @@ export class SettingsManager {
                 const raw = readFileSync(path, "utf-8");
                 const parsed = JSON.parse(raw);
                 if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-                    current = parsed;
+                    current = sanitizeSettingsObject(parsed);
                 }
             }
             catch {
@@ -500,7 +523,7 @@ function parseConfigFile(path) {
         const ext = extname(path).toLowerCase();
         const parsed = ext === ".yaml" || ext === ".yml" ? parseYaml(content) : JSON.parse(content);
         if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            return parsed;
+            return sanitizeSettingsObject(parsed);
         }
     }
     catch {
@@ -527,9 +550,17 @@ function resolveConfigPath(jsonPath) {
     return null;
 }
 function merge(base, override) {
-    const result = { ...base };
+    const result = {};
+    for (const [key, value] of Object.entries(base)) {
+        if (isForbiddenSettingKeySegment(key))
+            continue;
+        result[key] = value;
+    }
     for (const [key, value] of Object.entries(override)) {
-        if (value === null) {
+        if (isForbiddenSettingKeySegment(key)) {
+            continue;
+        }
+        else if (value === null) {
             delete result[key];
         }
         else if (typeof value === "object" &&

package/dist/settings/schema.d.ts

@@ -366,6 +366,13 @@ export declare const SettingsSchema: z.ZodObject<{
         storageDir?: string | undefined;
         maxHistory?: number | undefined;
     }>>;
+    worktree: z.ZodDefault<z.ZodObject<{
+        branchPrefix: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        branchPrefix: string;
+    }, {
+        branchPrefix?: string | undefined;
+    }>>;
     mcpServers: z.ZodDefault<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodString;
         command: z.ZodOptional<z.ZodString>;
@@ -1240,6 +1247,13 @@ export declare const SettingsSchema: z.ZodObject<{
         storageDir?: string | undefined;
         maxHistory?: number | undefined;
     }>>;
+    worktree: z.ZodDefault<z.ZodObject<{
+        branchPrefix: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        branchPrefix: string;
+    }, {
+        branchPrefix?: string | undefined;
+    }>>;
     mcpServers: z.ZodDefault<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodString;
         command: z.ZodOptional<z.ZodString>;
@@ -2114,6 +2128,13 @@ export declare const SettingsSchema: z.ZodObject<{
         storageDir?: string | undefined;
         maxHistory?: number | undefined;
     }>>;
+    worktree: z.ZodDefault<z.ZodObject<{
+        branchPrefix: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        branchPrefix: string;
+    }, {
+        branchPrefix?: string | undefined;
+    }>>;
     mcpServers: z.ZodDefault<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodString;
         command: z.ZodOptional<z.ZodString>;

package/dist/settings/schema.js

@@ -2,6 +2,7 @@
  * Settings schema with Zod validation.
  */
 import { z } from "zod";
+import { DEFAULT_WORKTREE_BRANCH_PREFIX, isValidWorktreeBranchPrefix, normalizeWorktreeBranchPrefix, } from "../git/worktree/slug.js";
 /**
  * Tri-state project capability overlay. Lives in PROJECT settings only and
  * layers over the global baseline (disabledSkills / disabledPlugins /
@@ -30,6 +31,12 @@ export const CapabilityOverridesSchema = z
     pluginHooks: z.record(CapabilityOverrideSchema).optional(),
 })
     .optional();
+const WorktreeBranchPrefixSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .refine(isValidWorktreeBranchPrefix, "Invalid git branch prefix")
+    .transform((value) => normalizeWorktreeBranchPrefix(value));
 export const SettingsSchema = z
     .object({
     agent: z
@@ -214,6 +221,11 @@ export const SettingsSchema = z
         maxHistory: z.number().default(100),
     })
         .default({}),
+    worktree: z
+        .object({
+        branchPrefix: WorktreeBranchPrefixSchema.default(DEFAULT_WORKTREE_BRANCH_PREFIX),
+    })
+        .default({}),
     // The record key IS the server name at runtime (MCPManager.connectAll
     // uses Object.entries keys; desktop's persist strips the `name` field and
     // keys by it via stripNameFromServer). So `name` here is optional and

package/dist/tool-system/builtin/index.js

@@ -3,9 +3,9 @@
  */
 import { readToolDef, readTool } from "./read.js";
 import { writeToolDef, writeTool } from "./write.js";
-import { generateImageToolDef, generateImageTool, isGenerateImageAvailable } from "./generate-image.js";
+import { generateImageToolDef, generateImageTool, isGenerateImageAvailable, } from "./generate-image.js";
 import { editModelCatalogToolDef, editModelCatalogTool } from "./edit-model-catalog.js";
-import { generateVideoToolDef, generateVideoTool, isGenerateVideoAvailable } from "./generate-video.js";
+import { generateVideoToolDef, generateVideoTool, isGenerateVideoAvailable, } from "./generate-video.js";
 import { viewImageToolDef, viewImageTool } from "./view-image.js";
 import { editToolDef, editTool } from "./edit.js";
 import { applyPatchToolDef, applyPatchTool } from "./apply-patch/index.js";
@@ -16,19 +16,19 @@ import { webSearchToolDef, webSearchTool, isWebSearchAvailable } from "./web-sea
 import { webFetchToolDef, webFetchTool } from "./web-fetch.js";
 import { askUserToolDef, askUserTool } from "./ask-user.js";
 import { agentToolDef, agentTool, agentStatusToolDef, agentStatusTool, agentCancelToolDef, agentCancelTool, agentSendInputToolDef, agentSendInputTool, } from "./agent.js";
-import { enterPlanModeToolDef, enterPlanModeTool, exitPlanModeToolDef, exitPlanModeTool } from "./plan.js";
+import { enterPlanModeToolDef, enterPlanModeTool, exitPlanModeToolDef, exitPlanModeTool, } from "./plan.js";
 import { toolSearchToolDef, toolSearchTool } from "./tool-search.js";
 import { todoWriteToolDef, todoWriteTool } from "./task.js";
-import { enterWorktreeToolDef, enterWorktreeTool, exitWorktreeToolDef, exitWorktreeTool } from "./worktree.js";
+import { enterWorktreeToolDef, enterWorktreeTool, exitWorktreeToolDef, exitWorktreeTool, switchSessionWorkspaceToolDef, switchSessionWorkspaceTool, } from "./worktree.js";
 import { sleepToolDef, sleepTool } from "./sleep.js";
 import { configToolDef, configTool } from "./config.js";
 import { notebookEditToolDef, notebookEditTool } from "./notebook-edit.js";
 import { lspToolDef, lspTool } from "./lsp.js";
-import { cronCreateToolDef, cronCreateTool, cronDeleteToolDef, cronDeleteTool, cronListToolDef, cronListTool } from "./cron.js";
-import { driveClaudeCodeToolDef, driveClaudeCodeTool, driveAgentToolDef, driveAgentTool, DRIVE_AGENT_TOOL_TIMEOUT_MS } from "./drive-claude-code.js";
+import { cronCreateToolDef, cronCreateTool, cronDeleteToolDef, cronDeleteTool, cronListToolDef, cronListTool, } from "./cron.js";
+import { driveClaudeCodeToolDef, driveClaudeCodeTool, driveAgentToolDef, driveAgentTool, DRIVE_AGENT_TOOL_TIMEOUT_MS, } from "./drive-claude-code.js";
 import { checkQuotaToolDef, checkQuotaTool } from "./check-quota.js";
 import { skillToolDef, skillTool } from "./skill.js";
-import { mcpToolDef, mcpToolExecute, listMcpResourcesToolDef, listMcpResourcesTool, readMcpResourceToolDef, readMcpResourceTool } from "./mcp-tools.js";
+import { mcpToolDef, mcpToolExecute, listMcpResourcesToolDef, listMcpResourcesTool, readMcpResourceToolDef, readMcpResourceTool, } from "./mcp-tools.js";
 import { replToolDef, replTool } from "./repl.js";
 import { briefToolDef, briefTool } from "./brief.js";
 import { powershellToolDef, powershellTool } from "./powershell.js";
@@ -344,6 +344,16 @@ export const BUILTIN_TOOLS = [
         },
         execute: exitWorktreeTool,
     },
+    {
+        definition: {
+            ...switchSessionWorkspaceToolDef,
+            source: "builtin",
+            permissionDefault: "ask",
+            isReadOnly: false,
+            isConcurrencySafe: false,
+        },
+        execute: switchSessionWorkspaceTool,
+    },
     // ─── Phase 5: Utility Tools ────────────────────────────────────
     {
         definition: {
@@ -723,7 +733,7 @@ export const BUILTIN_TOOL_GUARDS = new Map([
     [useCredentialToolDef.name, (ctx) => isUseCredentialAvailable(ctx.cwd)],
     // InjectCredential hidden until ≥1 cookie credential exists (browser injection
     // is cookie-only). Also degrades at call time if no browser bridge is wired.
-    [injectCredentialToolDef.name, (ctx) => isInjectCredentialAvailable(ctx.cwd)],
+    [injectCredentialToolDef.name, (ctx) => isInjectCredentialAvailable(ctx.cwd, ctx.settingsScope)],
     [completeGoalToolDef.name, (ctx) => ctx.hasGoal === true],
     [cancelGoalToolDef.name, (ctx) => ctx.hasGoal === true],
 ]);

package/dist/tool-system/builtin/memory.js

@@ -17,9 +17,10 @@
 import { MemoryManager } from "../../session/memory.js";
 const VALID_SCOPES = ["user", "dream"];
 const VALID_TYPES = ["user", "feedback", "project", "reference"];
+const VALID_ORIGINS = ["auto", "manual", "dream"];
 function parseScope(raw) {
     if (typeof raw !== "string")
-        return "Error: scope is required (\"user\" or \"dream\")";
+        return 'Error: scope is required ("user" or "dream")';
     if (!VALID_SCOPES.includes(raw)) {
         return `Error: scope must be "user" or "dream", got "${raw}"`;
     }
@@ -30,6 +31,11 @@ function parseScope(raw) {
 function parseLocation(raw) {
     return raw === "global" ? "global" : "project";
 }
+function parseOrigin(raw) {
+    return typeof raw === "string" && VALID_ORIGINS.includes(raw)
+        ? raw
+        : undefined;
+}
 function mmFor(ctx, scope, location = "project") {
     // location=global → omit projectDir so the manager points at the global store.
     return new MemoryManager({
@@ -46,7 +52,7 @@ const LOCATION_SCHEMA = {
 export const memoryListToolDef = {
     name: "MemoryList",
     description: "List persistent memory entries from one scope. " +
-        "Returns each entry's name, type, and short description (not the full content — use MemoryRead for that). " +
+        "Returns each entry's id, origin, counts, name, type, and short description (not the full content — use MemoryRead for that). " +
         "Use this before MemorySave/MemoryDelete to find the exact name to target. " +
         'Scopes: "user" (entries the user owns; you need permission to modify) or "dream" (auto-consolidation workspace; you may freely modify).',
     inputSchema: {
@@ -73,7 +79,9 @@ export async function memoryListTool(args, ctx) {
         if (entries.length === 0)
             return `(no memories in scope "${scope}")`;
         return entries
-            .map((e) => `- [${e.type}] ${e.name} — ${e.description}`)
+            .map((e) => `- [${e.type}] ${e.name} ` +
+            `(id:${e.id ?? "(none)"}, origin:${e.origin ?? "manual"}, use:${e.useCount ?? 0}, updates:${e.updateCount ?? 0}) — ` +
+            e.description)
             .join("\n");
     }
     catch (err) {
@@ -127,15 +135,24 @@ export async function memoryReadTool(args, ctx) {
             if (cb) {
                 // scope here is always "user"|"dream" (validated above); pending is
                 // never tool-readable, so the narrower event type is correct.
-                void cb({ type: "memory_recalled", name: entry.name, scope: scope, location });
+                void cb({
+                    type: "memory_recalled",
+                    name: entry.name,
+                    scope: scope,
+                    location,
+                });
             }
         }
         catch {
             // ignore — the read result below is what matters
         }
         return (`name: ${entry.name}\n` +
+            `id: ${entry.id ?? ""}\n` +
             `description: ${entry.description}\n` +
             `type: ${entry.type}\n` +
+            `origin: ${entry.origin ?? "manual"}\n` +
+            `useCount: ${entry.useCount ?? 0}\n` +
+            `updateCount: ${entry.updateCount ?? 0}\n` +
             `\n${entry.content}`);
     }
     catch (err) {
@@ -145,7 +162,7 @@ export async function memoryReadTool(args, ctx) {
 // ─── MemorySave ────────────────────────────────────────────────────────────
 export const memorySaveToolDef = {
     name: "MemorySave",
-    description: "Create or overwrite a memory entry. Same name → overwrite. " +
+    description: "Create or update a memory entry. Before saving, scan the injected memory index and/or call MemoryList; for the same durable topic, update the existing entry by id instead of creating date-stamped variants. " +
         'Saving to scope "user" requires user permission (you will see a confirmation prompt). ' +
         'Saving to scope "dream" is automatic — it is your auto-consolidation workspace. ' +
         "Pick `type` carefully: " +
@@ -154,7 +171,7 @@ export const memorySaveToolDef = {
         "project (non-obvious facts about ongoing work), " +
         "reference (pointers to external resources). " +
         "Pick `location`: global (a lesson/preference true in ANY project) vs project (this repo only). " +
-        "If a memory in the injected index is now stale or wrong, overwrite it (same name) or MemoryDelete it — keep the store correct rather than letting contradictions pile up. " +
+        "If a memory in the injected index is now stale or wrong, update it by id or MemoryDelete it — keep the store correct rather than letting contradictions pile up. " +
         "The `description` is a one-line summary shown in the index; the `content` is the full body.",
     inputSchema: {
         type: "object",
@@ -165,9 +182,13 @@ export const memorySaveToolDef = {
                 description: "Which scope to save to",
             },
             location: LOCATION_SCHEMA,
+            id: {
+                type: "string",
+                description: "Stable id from MemoryList/MemoryRead when updating an existing memory. Omit only for genuinely new topics.",
+            },
             name: {
                 type: "string",
-                description: "Short kebab-case identifier (also becomes the filename slug)",
+                description: "Short stable topic identifier; avoid dates, versions, or batch suffixes",
             },
             description: {
                 type: "string",
@@ -192,11 +213,14 @@ export async function memorySaveTool(args, ctx) {
         return scope;
     }
     const name = args.name;
+    const id = args.id;
     const description = args.description;
     const type = args.type;
     const content = args.content;
     if (typeof name !== "string" || !name)
         return "Error: name is required";
+    if (id !== undefined && typeof id !== "string")
+        return "Error: id must be a string";
     if (typeof description !== "string")
         return "Error: description is required";
     if (typeof content !== "string")
@@ -207,12 +231,20 @@ export async function memorySaveTool(args, ctx) {
     try {
         const location = parseLocation(args.location);
         const mm = mmFor(ctx, scope, location);
+        const dreamLoop = ctx?.__dreamLoop === true;
+        const forcedOrigin = dreamLoop
+            ? "dream"
+            : scope === "user"
+                ? "manual"
+                : (parseOrigin(args.origin) ?? "manual");
         const fileName = mm.save({
+            id,
             name,
             description,
             type: type,
             content,
-        });
+            origin: forcedOrigin,
+        }, { forceOrigin: forcedOrigin });
         return `Saved memory "${name}" → ${location}/${scope}/${fileName}`;
     }
     catch (err) {

package/dist/tool-system/builtin/worktree.d.ts

@@ -3,6 +3,8 @@
  */
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
+export declare const switchSessionWorkspaceToolDef: ToolDefinition;
+export declare function switchSessionWorkspaceTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const enterWorktreeToolDef: ToolDefinition;
 export declare function enterWorktreeTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const exitWorktreeToolDef: ToolDefinition;

package/dist/tool-system/builtin/worktree.js

@@ -4,6 +4,49 @@
 import { existsSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 import { createWorktree, removeWorktree, listWorktrees, validateWorktreeSlug, selectPlatformScript, runWorktreeSetup, worktreeHasUncommittedOrAheadChanges, currentBranch, } from "../../git/worktree.js";
+export const switchSessionWorkspaceToolDef = {
+    name: "SwitchSessionWorkspace",
+    description: "Switch this current conversation session into or out of a workspace through the host UI path. " +
+        "Use this when you need isolated or parallel work in a git worktree, when you need to move " +
+        "this conversation to an existing worktree path/branch, or when you are done and should return " +
+        "this current conversation to main. This is the correct way to move THIS conversation's session " +
+        "into or out of a worktree on desktop.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            target: {
+                type: "string",
+                description: "Workspace target: 'main', a new slug, an existing worktree path, or an existing branch name.",
+            },
+        },
+        required: ["target"],
+    },
+};
+export async function switchSessionWorkspaceTool(args, ctx) {
+    const target = stringArg(args.target);
+    if (!target)
+        return "Error: target is required";
+    const bridge = ctx?.workspace;
+    if (!bridge) {
+        return ("SwitchSessionWorkspace is not available in this host. " +
+            "Use the host's supported workspace controls instead.");
+    }
+    try {
+        const workspace = await bridge.switch(target);
+        ctx?.setSessionWorkspace?.(workspace);
+        const details = workspace.kind === "worktree" && workspace.worktree
+            ? `\n  Branch: ${workspace.worktree.branch}`
+            : "";
+        return (`Switched session workspace:\n` +
+            `  Path: ${workspace.root}` +
+            details +
+            `\n\n` +
+            nextTurnNotice(workspace.root, ctx?.cwd ?? workspace.root));
+    }
+    catch (err) {
+        return `Error switching workspace: ${err.message}`;
+    }
+}
 export const enterWorktreeToolDef = {
     name: "EnterWorktree",
     description: "Switch the current session workspace. Target can be a new worktree slug, " +
@@ -40,6 +83,7 @@ export async function enterWorktreeTool(args, ctx) {
     };
     const fromRoot = fromWorkspace.root;
     const currentTurnRoot = ctx?.cwd ?? fromRoot;
+    const branchPrefix = ctx?.engine?.readWorktreeBranchPrefix?.(mainRoot);
     try {
         if (target === "main") {
             const workspace = { root: mainRoot, kind: "main" };
@@ -50,12 +94,13 @@ export async function enterWorktreeTool(args, ctx) {
                 `  From: ${fromRoot}\n\n` +
                 nextTurnNotice(mainRoot, currentTurnRoot));
         }
-        const selected = resolveWorktreeTarget({
+        const selected = await resolveWorktreeTarget({
             target,
             cwd: ctx?.cwd ?? mainRoot,
             mainRoot,
             sessionId,
             currentWorkspace: fromWorkspace,
+            branchPrefix,
         });
         const workspace = toSessionWorkspace(selected, fromWorkspace);
         persistSessionWorkspace(sessionManager, sessionId, workspace, ctx);
@@ -125,7 +170,7 @@ export async function exitWorktreeTool(args, ctx) {
         return `Error: unknown action "${requested}" (expected keep, detach, or discard).`;
     }
     const hasPendingChanges = existsSync(workspace.worktree.path) &&
-        worktreeHasUncommittedOrAheadChanges(workspace.worktree.path, workspace.worktree.baseRef);
+        (await worktreeHasUncommittedOrAheadChanges(workspace.worktree.path, workspace.worktree.baseRef));
     const action = requested ?? (hasPendingChanges ? undefined : "detach");
     if (!action) {
         return (`Error: worktree has uncommitted changes or new commits. Choose action "keep" to preserve ` +
@@ -137,10 +182,11 @@ export async function exitWorktreeTool(args, ctx) {
     }
     const mainRoot = sessionManager.readCwd(sessionId) ?? workspace.root;
     const currentTurnRoot = ctx?.cwd ?? workspace.root;
+    const branchPrefix = ctx?.engine?.readWorktreeBranchPrefix?.(mainRoot);
     try {
         let removal;
         if (action === "discard" || action === "detach") {
-            const otherOwners = otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, workspace.worktree.path);
+            const otherOwners = await otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, workspace.worktree.path);
             if (otherOwners.length > 0) {
                 const mainWorkspace = { root: mainRoot, kind: "main" };
                 persistSessionWorkspace(sessionManager, sessionId, mainWorkspace, ctx);
@@ -149,7 +195,7 @@ export async function exitWorktreeTool(args, ctx) {
             }
         }
         if (action === "discard") {
-            removal = removeWorktree(workspace.worktree.path, true);
+            removal = removeWorktree(workspace.worktree.path, true, { prefix: branchPrefix });
         }
         else if (action === "detach") {
             removal = removeWorktree(workspace.worktree.path, false);
@@ -196,15 +242,15 @@ function sessionServices(ctx) {
     }
     return { ok: true, sessionId, sessionManager };
 }
-function otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, worktreePath) {
+async function otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, worktreePath) {
     const workspaceOwners = sessionManager
         .list(Number.MAX_SAFE_INTEGER)
         .map((session) => ({ sessionId: session.sessionId, workspace: session.workspace }))
         .filter((owner) => owner.workspace !== undefined);
-    const entry = listWorktrees(mainRoot, {
+    const entry = (await listWorktrees(mainRoot, {
         currentSessionId: sessionId,
         workspaceOwners,
-    }).find((worktree) => resolve(worktree.path) === resolve(worktreePath));
+    })).find((worktree) => resolve(worktree.path) === resolve(worktreePath));
     return (entry?.occupiedBySessionIds ?? []).filter((owner) => owner !== sessionId);
 }
 function sharedWorktreeRemovalSkippedMessage(otherOwners, mainRoot, currentTurnRoot) {
@@ -213,8 +259,8 @@ function sharedWorktreeRemovalSkippedMessage(otherOwners, mainRoot, currentTurnR
         `Back to ${mainRoot} starting next turn.\n` +
         nextTurnNotice(mainRoot, currentTurnRoot));
 }
-function resolveWorktreeTarget(opts) {
-    const entries = listWorktrees(opts.mainRoot);
+async function resolveWorktreeTarget(opts) {
+    const entries = await listWorktrees(opts.mainRoot);
     const pathTarget = pathLike(opts.target) ? resolvePathTarget(opts.target, opts.cwd) : undefined;
     const branchTarget = normalizeBranchName(opts.target);
     const match = entries.find((entry) => {
@@ -230,7 +276,7 @@ function resolveWorktreeTarget(opts) {
                 worktreePath: match.path,
                 worktreeName: match.path.split(/[\\/]/).pop() ?? match.branch,
                 worktreeBranch: match.branch,
-                originalBranch: currentBranch(opts.mainRoot),
+                originalBranch: await currentBranch(opts.mainRoot),
                 sessionId: opts.sessionId,
                 createdAt: Date.now(),
             },
@@ -241,7 +287,9 @@ function resolveWorktreeTarget(opts) {
         throw new Error(`no existing worktree found at ${opts.target}`);
     }
     validateWorktreeSlug(opts.target);
-    const created = createWorktree(opts.mainRoot, opts.target, opts.sessionId);
+    const created = await createWorktree(opts.mainRoot, opts.target, opts.sessionId, {
+        prefix: opts.branchPrefix,
+    });
     return { created: true, session: created, from: created.originalBranch ?? "HEAD" };
 }
 function toSessionWorkspace(selected, currentWorkspace) {

package/dist/tool-system/context.d.ts

@@ -40,6 +40,8 @@ export interface ToolRuntimeHost {
         linux?: string;
         windows?: string;
     } | undefined;
+    /** Branch prefix used for CodeShell-managed worktree branches. */
+    readWorktreeBranchPrefix?(cwd?: string): string | undefined;
     /** Resolve a setup-only sandbox for a newly-created worktree root. */
     resolveWorktreeSetupSandbox?(cwd: string): Promise<SandboxBackend | undefined>;
     /** Resolve setup-only shell env for a newly-created worktree root. */
@@ -180,6 +182,7 @@ export interface SubAgentSpawner {
 export interface ToolVisibilityContext {
     cwd: string;
     hasGoal: boolean;
+    settingsScope?: import("../settings/manager.js").SettingsScope;
 }
 export interface ToolContext {
     /** Active working directory for this Engine. */
@@ -348,6 +351,13 @@ export interface ToolContext {
      * docs/superpowers/specs/2026-06-16-browser-automation-mvp.md.
      */
     browser?: import("./browser-bridge.js").BrowserBridge;
+    /**
+     * Host-backed workspace switch bridge. Desktop wires this to Electron main so
+     * the model's SwitchSessionWorkspace tool goes through the same path as the UI
+     * switcher. Undefined outside hosts that can switch this conversation's
+     * session workspace.
+     */
+    workspace?: import("./workspace-bridge.js").WorkspaceBridge;
     /**
      * Inject a stored cookie credential into the built-in browser (restore its
      * login state so the AI can drive the page as that account). The host
@@ -359,7 +369,7 @@ export interface ToolContext {
     injectCredentialToBrowser?: InjectCredentialFn;
 }
 /** Inject a cookie credential into the built-in browser (host-implemented). */
-export type InjectCredentialFn = (credentialId: string) => Promise<{
+export type InjectCredentialFn = (credentialId: string, credentialScope?: "full" | "project") => Promise<{
     ok: boolean;
     count?: number;
     error?: string;

package/dist/tool-system/mcp-manager.d.ts

@@ -6,6 +6,12 @@
 import type { Tool as McpTool } from "@modelcontextprotocol/sdk/types.js";
 import type { MCPServerConfig, RegisteredTool } from "../types.js";
 import { ToolRegistry } from "./registry.js";
+interface MCPResourceInfo {
+    uri: string;
+    name: string;
+    description?: string;
+    serverName: string;
+}
 /**
  * Read a required secret from `process.env` by NAME (Codex-style env-secret
  * handling — the value is never persisted in MCP config). A referenced env var
@@ -125,13 +131,10 @@ export declare class MCPManager {
     /**
      * List resources from MCP servers.
      */
-    listResources(serverName?: string, signal?: AbortSignal): Promise<Array<{
-        uri: string;
-        name: string;
-        description?: string;
-    }>>;
+    listResources(serverName?: string, signal?: AbortSignal): Promise<MCPResourceInfo[]>;
     /**
      * Read a resource from an MCP server.
      */
     readResource(serverName: string, uri: string, signal?: AbortSignal): Promise<string>;
 }
+export {};