@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/commands/agent/agent.js

@@ -0,0 +1,283 @@
+import { getVisibleProvider } from '../../utils/model/providerCatalog.js';
+import { buildAgentDetailMessage, buildAgentSummary, createAgent, getAgent, isKnownAgentProvider, listAgents, setAgentModelByName, setAgentOrchestratorByName, setAgentRoleByName, } from './agentStore.js';
+function normalizeProviderInput(rawProvider) {
+    if (!rawProvider) {
+        return null;
+    }
+    switch (rawProvider.trim().toLowerCase()) {
+        case 'z.ai':
+        case 'z-ai':
+            return 'zai';
+        case 'open-router':
+            return 'openrouter';
+        case 'ollama-cloud':
+        case 'ollama_cloud':
+        case 'ollamacloud':
+            return 'ollama-cloud';
+        default:
+            return rawProvider.trim().toLowerCase();
+    }
+}
+function parseProvider(value) {
+    const provider = normalizeProviderInput(value);
+    if (!provider || !isKnownAgentProvider(provider)) {
+        return null;
+    }
+    return provider;
+}
+function parseBooleanToken(value) {
+    if (!value) {
+        return null;
+    }
+    switch (value.trim().toLowerCase()) {
+        case 'true':
+        case '1':
+        case 'yes':
+        case 'y':
+        case 'si':
+        case 's':
+        case 'on':
+            return true;
+        case 'false':
+        case '0':
+        case 'no':
+        case 'n':
+        case 'off':
+            return false;
+        default:
+            return null;
+    }
+}
+function parseModelValue(tokens) {
+    const raw = tokens.join(' ').trim();
+    if (!raw) {
+        return null;
+    }
+    if (['clear', 'default', 'reset', 'none'].includes(raw.toLowerCase())) {
+        return null;
+    }
+    return raw;
+}
+function getProviderLabel(provider) {
+    return getVisibleProvider(provider).label;
+}
+function buildUsageMessage() {
+    return [
+        'Uso: /agent, /agent list [proveedor], /agent create <proveedor> <name> [profile],',
+        '/agent show <proveedor> <name>, /agent set-role <proveedor> <name> <role>,',
+        '/agent set-orchestrator <proveedor> <name> <true|false>, /agent set-model <proveedor> <name> <model|clear>',
+    ].join(' ');
+}
+async function buildListMessageAsync(provider) {
+    const agents = await listAgents(provider);
+    if (agents.length === 0) {
+        return provider
+            ? `No hay agentes guardados para ${getProviderLabel(provider)}.`
+            : 'No hay agentes guardados.';
+    }
+    const lines = [];
+    const grouped = provider
+        ? [[provider, agents]]
+        : Array.from(agents.reduce((map, agent) => {
+            const current = map.get(agent.provider) ?? [];
+            current.push(agent);
+            map.set(agent.provider, current);
+            return map;
+        }, new Map()));
+    for (const [groupProvider, groupAgents] of grouped) {
+        if (!provider) {
+            lines.push('');
+        }
+        lines.push(`${getProviderLabel(groupProvider)}:`);
+        for (const agent of groupAgents) {
+            lines.push(buildAgentSummary(agent));
+        }
+    }
+    return lines.join('\n').trimStart();
+}
+function parseCreateArgs(args) {
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0]?.toLowerCase() !== 'create') {
+        return null;
+    }
+    const provider = parseProvider(tokens[1]);
+    if (!provider) {
+        return null;
+    }
+    const name = tokens[2]?.trim();
+    if (!name) {
+        return null;
+    }
+    const profileName = tokens.slice(3).join(' ').trim() || undefined;
+    return { provider, name, profileName };
+}
+function parseShowArgs(args) {
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0]?.toLowerCase() !== 'show') {
+        return null;
+    }
+    const provider = parseProvider(tokens[1]);
+    const name = tokens[2]?.trim();
+    if (!provider || !name) {
+        return null;
+    }
+    return { provider, name };
+}
+function parseRoleArgs(args) {
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0]?.toLowerCase() !== 'set-role') {
+        return null;
+    }
+    const provider = parseProvider(tokens[1]);
+    const name = tokens[2]?.trim();
+    const role = tokens.slice(3).join(' ').trim();
+    if (!provider || !name || !role) {
+        return null;
+    }
+    return { provider, name, role };
+}
+function parseOrchestratorArgs(args) {
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0]?.toLowerCase() !== 'set-orchestrator') {
+        return null;
+    }
+    const provider = parseProvider(tokens[1]);
+    const name = tokens[2]?.trim();
+    const flag = parseBooleanToken(tokens[3]);
+    if (!provider || !name || flag === null) {
+        return null;
+    }
+    return { provider, name, isOrchestrator: flag };
+}
+function parseModelArgs(args) {
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0]?.toLowerCase() !== 'set-model') {
+        return null;
+    }
+    const provider = parseProvider(tokens[1]);
+    const name = tokens[2]?.trim();
+    if (!provider || !name || tokens.slice(3).length === 0) {
+        return null;
+    }
+    const model = parseModelValue(tokens.slice(3));
+    return { provider, name, model };
+}
+export const call = async (args, _context) => {
+    const trimmed = args.trim();
+    if (!trimmed || trimmed.toLowerCase() === 'list') {
+        return { type: 'text', value: await buildListMessageAsync() };
+    }
+    const tokens = trimmed.split(/\s+/).filter(Boolean);
+    const command = tokens[0]?.toLowerCase();
+    if (command === 'list') {
+        const provider = parseProvider(tokens[1]);
+        if (tokens[1] && !provider) {
+            return {
+                type: 'text',
+                value: `Proveedor invalido: ${tokens[1]}`,
+            };
+        }
+        return {
+            type: 'text',
+            value: await buildListMessageAsync(provider ?? undefined),
+        };
+    }
+    const createArgs = parseCreateArgs(trimmed);
+    if (createArgs) {
+        try {
+            const existing = await getAgent(createArgs.provider, createArgs.name);
+            if (existing) {
+                return {
+                    type: 'text',
+                    value: `El agente ya existe: ${existing.provider}/${existing.name}`,
+                };
+            }
+            const created = await createAgent(createArgs);
+            return {
+                type: 'text',
+                value: `Agente creado: ${created.provider}/${created.name}\nPerfil vinculado: ${created.profile ? `${created.profile.provider}/${created.profile.name}` : 'sin perfil'}`,
+            };
+        }
+        catch (error) {
+            return {
+                type: 'text',
+                value: `No se pudo crear el agente: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    const showArgs = parseShowArgs(trimmed);
+    if (showArgs) {
+        const agent = await getAgent(showArgs.provider, showArgs.name);
+        if (!agent) {
+            return {
+                type: 'text',
+                value: `No existe el agente ${showArgs.provider}/${showArgs.name}.`,
+            };
+        }
+        return { type: 'text', value: buildAgentDetailMessage(agent) };
+    }
+    const roleArgs = parseRoleArgs(trimmed);
+    if (roleArgs) {
+        try {
+            const updated = await setAgentRoleByName(roleArgs.provider, roleArgs.name, roleArgs.role);
+            if (!updated) {
+                return {
+                    type: 'text',
+                    value: `No existe el agente ${roleArgs.provider}/${roleArgs.name}.`,
+                };
+            }
+            return {
+                type: 'text',
+                value: `Rol actualizado para ${updated.provider}/${updated.name}: ${updated.roleKind ?? 'worker'}`,
+            };
+        }
+        catch (error) {
+            return {
+                type: 'text',
+                value: `No se pudo actualizar el rol: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    const orchestratorArgs = parseOrchestratorArgs(trimmed);
+    if (orchestratorArgs) {
+        const updated = await setAgentOrchestratorByName(orchestratorArgs.provider, orchestratorArgs.name, orchestratorArgs.isOrchestrator);
+        if (!updated) {
+            return {
+                type: 'text',
+                value: `No existe el agente ${orchestratorArgs.provider}/${orchestratorArgs.name}.`,
+            };
+        }
+        return {
+            type: 'text',
+            value: `Orquestador actualizado para ${updated.provider}/${updated.name}: ${updated.isOrchestrator ? 'true' : 'false'}`,
+        };
+    }
+    const modelArgs = parseModelArgs(trimmed);
+    if (modelArgs) {
+        try {
+            const updated = await setAgentModelByName(modelArgs.provider, modelArgs.name, modelArgs.model);
+            if (!updated) {
+                return {
+                    type: 'text',
+                    value: `No existe el agente ${modelArgs.provider}/${modelArgs.name}.`,
+                };
+            }
+            return {
+                type: 'text',
+                value: updated.modelOverride
+                    ? `Modelo actualizado para ${updated.provider}/${updated.name}: ${updated.modelOverride}`
+                    : `Modelo limpiado para ${updated.provider}/${updated.name}`,
+            };
+        }
+        catch (error) {
+            return {
+                type: 'text',
+                value: `No se pudo actualizar el modelo: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    return {
+        type: 'text',
+        value: buildUsageMessage(),
+    };
+};

package/dist/src/commands/agent/agentStore.js

@@ -0,0 +1,120 @@
+import { createProviderAgent, getProviderAgentByProviderAndName, getProviderWorkspaceById, getProviderWorkspaceByProvider, listProviderAgents, updateProviderAgent, upsertProviderWorkspace, } from '../../utils/orchestration/store/index.js';
+import { ensureProviderProfile, getProviderProfile, resolveProviderProfile, } from '../../utils/model/providerProfiles.js';
+import { getVisibleProvider } from '../../utils/model/providerCatalog.js';
+async function ensureWorkspace(provider) {
+    return ((await getProviderWorkspaceByProvider(provider)) ??
+        (await upsertProviderWorkspace({
+            provider,
+            displayName: getVisibleProvider(provider).label,
+            isEnabled: true,
+        })));
+}
+async function withHydratedAgent(agent) {
+    if (!agent) {
+        return null;
+    }
+    const hydratedWorkspace = (await getProviderWorkspaceById(agent.workspaceId));
+    if (!hydratedWorkspace) {
+        throw new Error(`Workspace no encontrado para el agente ${agent.id}.`);
+    }
+    const profile = agent.profileId ? getProviderProfile(agent.profileId) : null;
+    return {
+        ...agent,
+        provider: hydratedWorkspace.provider,
+        workspace: hydratedWorkspace,
+        profile: profile
+            ? {
+                id: profile.id,
+                provider: profile.provider,
+                name: profile.name,
+                agentName: profile.agentName,
+            }
+            : null,
+    };
+}
+export function isKnownAgentProvider(value) {
+    return Boolean(value);
+}
+export async function listAgents(provider) {
+    const workspace = provider ? await ensureWorkspace(provider) : null;
+    const agents = await listProviderAgents(workspace ? { workspaceId: workspace.id } : undefined);
+    const hydrated = await Promise.all(agents.map(agent => withHydratedAgent(agent)));
+    return hydrated.filter((agent) => agent !== null);
+}
+export async function getAgent(provider, name) {
+    const agent = await getProviderAgentByProviderAndName(provider, name);
+    return withHydratedAgent(agent);
+}
+export async function createAgent(params) {
+    const existing = await getAgent(params.provider, params.name);
+    if (existing) {
+        return existing;
+    }
+    const workspace = await ensureWorkspace(params.provider);
+    const profile = params.profileName?.trim()
+        ? ensureProviderProfile(params.provider, params.profileName.trim())
+        : resolveProviderProfile(params.provider, { createIfMissing: true }) ??
+            ensureProviderProfile(params.provider);
+    const created = await createProviderAgent({
+        workspaceId: workspace.id,
+        profileId: profile.id,
+        name: params.name,
+        roleKind: 'worker',
+        isOrchestrator: false,
+        isEnabled: true,
+    });
+    const hydrated = await withHydratedAgent(created);
+    if (!hydrated) {
+        throw new Error('No se pudo crear el agente.');
+    }
+    return hydrated;
+}
+export async function setAgentRoleByName(provider, name, role) {
+    const current = await getAgent(provider, name);
+    if (!current) {
+        return null;
+    }
+    return withHydratedAgent(await updateProviderAgent(current.id, { roleKind: role.trim() }));
+}
+export async function setAgentOrchestratorByName(provider, name, isOrchestrator) {
+    const current = await getAgent(provider, name);
+    if (!current) {
+        return null;
+    }
+    return withHydratedAgent(await updateProviderAgent(current.id, { isOrchestrator }));
+}
+export async function setAgentModelByName(provider, name, model) {
+    const current = await getAgent(provider, name);
+    if (!current) {
+        return null;
+    }
+    return withHydratedAgent(await updateProviderAgent(current.id, { modelOverride: model }));
+}
+export function buildAgentSummary(agent) {
+    const profileLabel = agent.profile
+        ? `${agent.profile.provider}/${agent.profile.name}`
+        : 'sin perfil';
+    const parts = [
+        `profile=${profileLabel}`,
+        `role=${agent.roleKind ?? 'worker'}`,
+        `orchestrator=${agent.isOrchestrator ? 'true' : 'false'}`,
+        agent.modelOverride ? `model=${agent.modelOverride}` : null,
+        `workspace=${agent.workspace.displayName}`,
+    ].filter(Boolean);
+    return `- ${agent.provider}/${agent.name}${parts.length > 0 ? ` [${parts.join(' | ')}]` : ''}`;
+}
+export function buildAgentDetailMessage(agent) {
+    const providerLabel = getVisibleProvider(agent.provider).label;
+    return [
+        `Proveedor: ${providerLabel}`,
+        `Agente: ${agent.name}`,
+        `ID: ${agent.id}`,
+        `Workspace: ${agent.workspace.displayName}`,
+        `Perfil: ${agent.profile ? `${agent.profile.provider}/${agent.profile.name}` : 'sin perfil'}`,
+        `Rol: ${agent.roleKind ?? 'worker'}`,
+        `Orquestador: ${agent.isOrchestrator ? 'true' : 'false'}`,
+        `Modelo: ${agent.modelOverride ?? 'sin override'}`,
+        `Creado: ${agent.createdAt}`,
+        `Actualizado: ${agent.updatedAt}`,
+    ].join('\n');
+}

package/dist/src/commands/agent/index.js

@@ -0,0 +1,9 @@
+const agent = {
+    type: 'local',
+    supportsNonInteractive: true,
+    name: 'agent',
+    description: 'Gestionar agentes por proveedor',
+    argumentHint: '[list [proveedor]|create <proveedor> <name> [profile]|show <proveedor> <name>|set-role <proveedor> <name> <role>|set-orchestrator <proveedor> <name> <true|false>|set-model <proveedor> <name> <model|clear>]',
+    load: () => import('./agent.js'),
+};
+export default agent;

package/dist/src/commands/agents/agents.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AgentsMenu } from '../../components/agents/AgentsMenu.js';
+import { getTools } from '../../tools.js';
+export async function call(onDone, context) {
+    const appState = context.getAppState();
+    const permissionContext = appState.toolPermissionContext;
+    const tools = getTools(permissionContext);
+    return _jsx(AgentsMenu, { tools: tools, onExit: onDone });
+}

package/dist/src/commands/agents/index.js

@@ -0,0 +1,7 @@
+const agents = {
+    type: 'local-jsx',
+    name: 'agents',
+    description: 'Gestionar configuraciones de agentes',
+    load: () => import('./agents.js'),
+};
+export default agents;

package/dist/src/commands/ant-trace/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

package/dist/src/commands/assistant/assistant.js

@@ -0,0 +1,16 @@
+export default null;
+export const defaultExport = null;
+export async function daemonMain() { }
+export async function runDaemonWorker() { }
+export async function environmentRunnerMain() { }
+export async function selfHostedRunnerMain() { }
+export async function connectHeadless() { }
+export async function startServer() { }
+export async function launchAssistantInstallWizard() { return null; }
+export async function launchAssistantSessionChooser() { return null; }
+export async function discoverAssistantSessions() { return []; }
+export async function createSSHSession() { throw new Error('Recovery stub: createSSHSession not implemented'); }
+export function createLocalSSHSession() { throw new Error('Recovery stub: createLocalSSHSession not implemented'); }
+export class SSHSessionError extends Error {
+}
+export function clearSkillIndexCache() { }

package/dist/src/commands/autofix-pr/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

package/dist/src/commands/backfill-sessions/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };

package/dist/src/commands/branch/branch.js

@@ -0,0 +1,205 @@
+import { randomUUID } from 'crypto';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { getOriginalCwd, getSessionId } from '../../bootstrap/state.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { parseJSONL } from '../../utils/json.js';
+import { getProjectDir, getTranscriptPath, getTranscriptPathForSession, isTranscriptMessage, saveCustomTitle, searchSessionsByCustomTitle, } from '../../utils/sessionStorage.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import { escapeRegExp } from '../../utils/stringUtils.js';
+/**
+ * Derive a single-line title base from the first user message.
+ * Collapses whitespace — multiline first messages (pasted stacks, code)
+ * otherwise flow into the saved title and break the resume hint.
+ */
+export function deriveFirstPrompt(firstUserMessage) {
+    const content = firstUserMessage?.message?.content;
+    if (!content)
+        return 'Branched conversation';
+    const raw = typeof content === 'string'
+        ? content
+        : content.find((block) => block.type === 'text')?.text;
+    if (!raw)
+        return 'Branched conversation';
+    return (raw.replace(/\s+/g, ' ').trim().slice(0, 100) || 'Branched conversation');
+}
+/**
+ * Creates a fork of the current conversation by copying from the transcript file.
+ * Preserves all original metadata (timestamps, gitBranch, etc.) while updating
+ * sessionId and adding forkedFrom traceability.
+ */
+async function createFork(customTitle) {
+    const forkSessionId = randomUUID();
+    const originalSessionId = getSessionId();
+    const projectDir = getProjectDir(getOriginalCwd());
+    const forkSessionPath = getTranscriptPathForSession(forkSessionId);
+    const currentTranscriptPath = getTranscriptPath();
+    // Ensure project directory exists
+    await mkdir(projectDir, { recursive: true, mode: 0o700 });
+    // Read current transcript file
+    let transcriptContent;
+    try {
+        transcriptContent = await readFile(currentTranscriptPath);
+    }
+    catch {
+        throw new Error('No conversation to branch');
+    }
+    if (transcriptContent.length === 0) {
+        throw new Error('No conversation to branch');
+    }
+    // Parse all transcript entries (messages + metadata entries like content-replacement)
+    const entries = parseJSONL(transcriptContent);
+    // Filter to only main conversation messages (exclude sidechains and non-message entries)
+    const mainConversationEntries = entries.filter((entry) => isTranscriptMessage(entry) && !entry.isSidechain);
+    // Content-replacement entries for the original session. These record which
+    // tool_result blocks were replaced with previews by the per-message budget.
+    // Without them in the fork JSONL, `claude -r {forkId}` reconstructs state
+    // with an empty replacements Map → previously-replaced results are classified
+    // as FROZEN and sent as full content (prompt cache miss + permanent overage).
+    // sessionId must be rewritten since loadTranscriptFile keys lookup by the
+    // session's messages' sessionId.
+    const contentReplacementRecords = entries
+        .filter((entry) => entry.type === 'content-replacement' &&
+        entry.sessionId === originalSessionId)
+        .flatMap(entry => entry.replacements);
+    if (mainConversationEntries.length === 0) {
+        throw new Error('No messages to branch');
+    }
+    // Build forked entries with new sessionId and preserved metadata
+    let parentUuid = null;
+    const lines = [];
+    const serializedMessages = [];
+    for (const entry of mainConversationEntries) {
+        // Create forked transcript entry preserving all original metadata
+        const forkedEntry = {
+            ...entry,
+            sessionId: forkSessionId,
+            parentUuid,
+            isSidechain: false,
+            forkedFrom: {
+                sessionId: originalSessionId,
+                messageUuid: entry.uuid,
+            },
+        };
+        // Build serialized message for LogOption
+        const serialized = {
+            ...entry,
+            sessionId: forkSessionId,
+        };
+        serializedMessages.push(serialized);
+        lines.push(jsonStringify(forkedEntry));
+        if (entry.type !== 'progress') {
+            parentUuid = entry.uuid;
+        }
+    }
+    // Append content-replacement entry (if any) with the fork's sessionId.
+    // Written as a SINGLE entry (same shape as insertContentReplacement) so
+    // loadTranscriptFile's content-replacement branch picks it up.
+    if (contentReplacementRecords.length > 0) {
+        const forkedReplacementEntry = {
+            type: 'content-replacement',
+            sessionId: forkSessionId,
+            replacements: contentReplacementRecords,
+        };
+        lines.push(jsonStringify(forkedReplacementEntry));
+    }
+    // Write the fork session file
+    await writeFile(forkSessionPath, lines.join('\n') + '\n', {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    return {
+        sessionId: forkSessionId,
+        title: customTitle,
+        forkPath: forkSessionPath,
+        serializedMessages,
+        contentReplacementRecords,
+    };
+}
+/**
+ * Generates a unique fork name by checking for collisions with existing session names.
+ * If "baseName (Branch)" already exists, tries "baseName (Branch 2)", "baseName (Branch 3)", etc.
+ */
+async function getUniqueForkName(baseName) {
+    const candidateName = `${baseName} (Branch)`;
+    // Check if this exact name already exists
+    const existingWithExactName = await searchSessionsByCustomTitle(candidateName, { exact: true });
+    if (existingWithExactName.length === 0) {
+        return candidateName;
+    }
+    // Name collision - find a unique numbered suffix
+    // Search for all sessions that start with the base pattern
+    const existingForks = await searchSessionsByCustomTitle(`${baseName} (Branch`);
+    // Extract existing fork numbers to find the next available
+    const usedNumbers = new Set([1]); // Consider " (Branch)" as number 1
+    const forkNumberPattern = new RegExp(`^${escapeRegExp(baseName)} \\(Branch(?: (\\d+))?\\)$`);
+    for (const session of existingForks) {
+        const match = session.customTitle?.match(forkNumberPattern);
+        if (match) {
+            if (match[1]) {
+                usedNumbers.add(parseInt(match[1], 10));
+            }
+            else {
+                usedNumbers.add(1); // " (Branch)" without number is treated as 1
+            }
+        }
+    }
+    // Find the next available number
+    let nextNumber = 2;
+    while (usedNumbers.has(nextNumber)) {
+        nextNumber++;
+    }
+    return `${baseName} (Branch ${nextNumber})`;
+}
+export async function call(onDone, context, args) {
+    const customTitle = args?.trim() || undefined;
+    const originalSessionId = getSessionId();
+    try {
+        const { sessionId, title, forkPath, serializedMessages, contentReplacementRecords, } = await createFork(customTitle);
+        // Build LogOption for resume
+        const now = new Date();
+        const firstPrompt = deriveFirstPrompt(serializedMessages.find(m => m.type === 'user'));
+        // Save custom title - use provided title or firstPrompt as default
+        // This ensures /status and /resume show the same session name
+        // Always add " (Branch)" suffix to make it clear this is a branched session
+        // Handle collisions by adding a number suffix (e.g., " (Branch 2)", " (Branch 3)")
+        const baseName = title ?? firstPrompt;
+        const effectiveTitle = await getUniqueForkName(baseName);
+        await saveCustomTitle(sessionId, effectiveTitle, forkPath);
+        logEvent('tengu_conversation_forked', {
+            message_count: serializedMessages.length,
+            has_custom_title: !!title,
+        });
+        const forkLog = {
+            date: now.toISOString().split('T')[0],
+            messages: serializedMessages,
+            fullPath: forkPath,
+            value: now.getTime(),
+            created: now,
+            modified: now,
+            firstPrompt,
+            messageCount: serializedMessages.length,
+            isSidechain: false,
+            sessionId,
+            customTitle: effectiveTitle,
+            contentReplacements: contentReplacementRecords,
+        };
+        // Resume into the fork
+        const titleInfo = title ? ` "${title}"` : '';
+        const resumeHint = `\nTo resume the original: claude -r ${originalSessionId}`;
+        const successMessage = `Branched conversation${titleInfo}. You are now in the branch.${resumeHint}`;
+        if (context.resume) {
+            await context.resume(sessionId, forkLog, 'fork');
+            onDone(successMessage, { display: 'system' });
+        }
+        else {
+            // Fallback if resume not available
+            onDone(`Branched conversation${titleInfo}. Resume with: /resume ${sessionId}`);
+        }
+        return null;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        onDone(`Failed to branch conversation: ${message}`);
+        return null;
+    }
+}

package/dist/src/commands/branch/index.js

@@ -0,0 +1,11 @@
+import { feature } from '../../recovery/bunBundleShim.js';
+const branch = {
+    type: 'local-jsx',
+    name: 'branch',
+    // 'fork' alias only when /fork doesn't exist as its own command
+    aliases: feature('FORK_SUBAGENT') ? [] : ['fork'],
+    description: 'Crear una rama de la conversación actual en este punto',
+    argumentHint: '[nombre]',
+    load: () => import('./branch.js'),
+};
+export default branch;

package/dist/src/commands/break-cache/index.js

@@ -0,0 +1 @@
+export default { isEnabled: () => false, isHidden: true, name: 'stub' };