omnikey-cli 1.4.1 → 1.5.1

package/backend-dist/agent/agentPrompts.js

@@ -53,7 +53,9 @@ ${config_1.config.browserDebugPort !== undefined
 - Skip the script only for purely factual/conversational requests with no live data dependency (e.g. "what is 2+2").
 
 **Script phasing — one phase per turn:**
+- **Act immediately — no upfront planning.** For any multi-step task, emit the **first** script right away without reasoning through future steps first. Decide each next step only *after* you see the terminal output from the previous one. Long plans written before any script is run produce long reasoning blocks that get cut off — emit the script and let the output guide you.
 - Break every multi-step task into the smallest logical unit that can independently succeed or fail. Emit that script, wait for \`TERMINAL OUTPUT:\`, assess the result, then write the next script. Never combine phases that have independent failure modes into a single block — a mid-script failure loses all context for recovery.
+- **Keep each script short and atomic** — prefer under 30 lines, doing exactly one operation (check one thing, install one package, make one change, run one command). If a script would need more, split it into two turns.
 - Natural phase boundaries: **(1)** check / install dependencies → **(2)** inspect / probe current state → **(3)** make one targeted change → **(4)** verify the change took effect. Add a boundary wherever a failure would require a different next step than a success.
 - Single-step read-only queries ("list files", "show env") need no splitting — one script is fine.
 
@@ -118,9 +120,13 @@ ${installedMcps
 2. ${config_1.config.aiProvider === 'anthropic' ? 'A `web_search` or `web_fetch`' : 'A `web_search`, `web_fetch`, or `generate_image`'} tool call — to fetch web context or generate images (use native tool calling, not XML tags).
 3. \`<final_answer>...</final_answer>\` — your conclusion once you have enough information.
 
-**Critical rule:** After receiving \`TERMINAL OUTPUT:\` you MUST immediately produce either \`<shell_script>\` or \`<final_answer>\`. Never output raw text, markdown, or any other format. If the terminal output contains enough information to answer the user's request, output \`<final_answer>\` right away.
+**Critical rule — zero tolerance for text outside tags:**
+- Your **entire response** — from the very first character to the very last — must be the tag and its contents. Nothing before the opening tag. Nothing after the closing tag.
+- Do NOT write reasoning, planning, or commentary before acting. Emit the tag immediately. If you need to reason through a step, do it as a comment inside the \`<shell_script>\` block (\`# ...\`), never as free text outside.
+- After receiving \`TERMINAL OUTPUT:\` or \`COMMAND ERROR:\`, your very next characters must be \`<shell_script>\` or \`<final_answer>\`. No exceptions.
+- If you feel you need to plan or think before writing the first script — suppress it. Emit \`<shell_script>\` for the first small step immediately. You will have the output to guide the next step.
 
-No plain text, reasoning, or other tags outside these blocks. Never wrap in additional XML/JSON.
+Never wrap in additional XML/JSON.
 
 **Shell script structure:**
 ${!isWindows

package/backend-dist/agent/agentServer.js

@@ -234,7 +234,7 @@ async function enforceSessionCap(subscriptionId, logger) {
         logger.error('Failed to enforce agent session cap', { subscriptionId, error: err });
     }
 }
-async function getOrCreateSession(sessionId, subscription, platform, log, isCronJob = false) {
+async function getOrCreateSession(sessionId, subscription, platform, log, isCronJob = false, groupName) {
     // 1. Try to resume from a persisted DB record.
     try {
         const dbSession = await agentSession_1.AgentSession.findOne({
@@ -246,6 +246,7 @@ async function getOrCreateSession(sessionId, subscription, platform, log, isCron
                 subscription,
                 history,
                 turns: dbSession.turns,
+                groupName: dbSession.groupName ?? null,
             };
             log.info('Resumed agent session from DB', {
                 sessionId,
@@ -309,6 +310,7 @@ ${prompt}
                 historyJson: JSON.stringify(entry.history),
                 turns: 0,
                 lastActiveAt: new Date(),
+                groupName: groupName ?? null,
             },
         });
         if (!created) {
@@ -317,6 +319,7 @@ ${prompt}
                 subscription,
                 history,
                 turns: dbSession.turns,
+                groupName: dbSession.groupName ?? null,
             };
             log.info('Reused existing agent session row from DB during create path', {
                 sessionId,
@@ -347,7 +350,7 @@ ${prompt}
     };
 }
 async function runAgentTurnInternal(sessionId, subscription, clientMessage, send, log, options) {
-    const { sessionState: session, hasStoredPrompt } = await getOrCreateSession(sessionId, subscription, clientMessage.platform, log, options?.isCronJob);
+    const { sessionState: session, hasStoredPrompt } = await getOrCreateSession(sessionId, subscription, clientMessage.platform, log, options?.isCronJob, clientMessage.group_name);
     // Count this call as one agent iteration.
     session.turns += 1;
     log.info('Starting agent turn', {
@@ -479,6 +482,38 @@ async function runAgentTurnInternal(sessionId, subscription, clientMessage, send
             temperature: 0.2,
         });
         await recordUsage(result);
+        // When the model's output was cut off mid-generation (hit the provider's
+        // max-token ceiling), it may have produced a partial shell script or plain
+        // reasoning text with no closing tag.  Processing that as-is would either
+        // send a malformed script to the frontend or silently recurse without any
+        // recovery signal.  Instead, push the truncated fragment as an assistant
+        // message and inject a terse directive that forces the model to emit a
+        // valid tag on the very next call.
+        if (result.finish_reason === 'length') {
+            log.warn('Agent response truncated at output limit; injecting recovery directive', {
+                sessionId,
+                contentLength: result.content.length,
+            });
+            if (result.content.trim()) {
+                (0, utils_1.pushToSessionHistory)(logger_1.logger, session, result.assistantMessage);
+            }
+            (0, utils_1.pushToSessionHistory)(logger_1.logger, session, {
+                role: 'user',
+                content: [
+                    'Your previous response was cut off because it exceeded the output length limit.',
+                    'Do NOT repeat or continue what you wrote.',
+                    'Respond immediately with exactly one of:',
+                    '- <shell_script>...</shell_script>',
+                    '- <final_answer>...</final_answer>',
+                    'No reasoning. No explanation. Just the tag.',
+                ].join('\n'),
+            });
+            result = await ai_client_1.aiClient.complete(aiModel, session.history, {
+                tools: tools?.length ? tools : undefined,
+                temperature: 0.2,
+            });
+            await recordUsage(result);
+        }
         let content = result.content.trim();
         if (!content && result.finish_reason !== 'tool_calls') {
             log.warn('Agent LLM returned empty content; sending generic error to client.');
@@ -596,26 +631,75 @@ async function runAgentTurnInternal(sessionId, subscription, clientMessage, send
                 sender: 'agent',
                 content: hasFinalAnswerTag ? content : `<final_answer>\n${content}\n</final_answer>`,
             });
-            void (0, sessionGrouping_1.updateSessionGroup)(sessionId, subscription.id);
+            // Only re-classify when the session doesn't already have a group name.
+            // Re-classification is expensive (LLM call) and unnecessary once a group
+            // has been assigned — the cron in sessionGrouping.ts is responsible for
+            // periodic refreshes if descriptions ever need updating.
+            if (!session.groupName) {
+                void (0, sessionGrouping_1.updateSessionGroup)(sessionId, subscription.id).then(async () => {
+                    // Reflect the newly-assigned group back into the in-memory session
+                    // so subsequent turns in this same session also skip re-classification.
+                    try {
+                        const refreshed = await agentSession_1.AgentSession.findOne({
+                            where: { id: sessionId, subscriptionId: subscription.id },
+                            attributes: ['groupName'],
+                        });
+                        if (refreshed?.groupName) {
+                            session.groupName = refreshed.groupName;
+                        }
+                    }
+                    catch (err) {
+                        log.warn('Failed to read back groupName after classification', { error: err });
+                    }
+                });
+            }
+            else {
+                log.info('Skipping session group classification — group already assigned', {
+                    sessionId,
+                    groupName: session.groupName,
+                });
+            }
         }
         else if (content) {
-            // Fallback: the LLM returned content without any recognized tag and it
-            // is not the final turn (e.g. plain-text conclusion after terminal
-            // output). Treat it as a final answer so the client is never left
-            // hanging.
-            log.info('Agent returned untagged content on a non-final turn; treating as assistant response and looping the function again.', {
+            const untaggedDepth = options?.untaggedDepth ?? 0;
+            // Safety valve: after two consecutive format-correction attempts the
+            // model is clearly stuck.  Abort rather than loop indefinitely.
+            if (untaggedDepth >= 2) {
+                log.warn('Agent stuck in untagged response loop; aborting after max retries', {
+                    sessionId,
+                    untaggedDepth,
+                });
+                await persistSessionToDB(sessionId, session);
+                (0, utils_1.sendFinalAnswer)(send, sessionId, 'The agent failed to produce a structured response after multiple attempts. Please try again.', true);
+                return;
+            }
+            log.info('Agent returned untagged content; injecting format-correction directive', {
                 sessionId,
                 subscriptionId: subscription.id,
                 turn: session.turns,
+                untaggedDepth,
+            });
+            // Push the untagged content as an assistant turn so the model sees what
+            // it wrote, then immediately follow with a user message that firmly
+            // redirects it back to the required tag format.
+            (0, utils_1.pushToSessionHistory)(logger_1.logger, session, { role: 'assistant', content });
+            (0, utils_1.pushToSessionHistory)(logger_1.logger, session, {
+                role: 'user',
+                content: [
+                    'Your response was plain text, which is not a valid format.',
+                    'You MUST respond with exactly one of:',
+                    '- <shell_script>...</shell_script> — to run terminal commands',
+                    '- <final_answer>...</final_answer> — to conclude',
+                    'Respond immediately with the tag. No reasoning, no explanation.',
+                ].join('\n'),
             });
-            (0, utils_1.pushToSessionHistory)(log, session, { role: 'assistant', content });
             await persistSessionToDB(sessionId, session);
             await runAgentTurnInternal(sessionId, subscription, {
                 sender: 'agent',
                 session_id: sessionId,
                 content: '',
                 is_web_call: true,
-            }, send, logger_1.logger, options);
+            }, send, logger_1.logger, { ...options, untaggedDepth: untaggedDepth + 1 });
         }
         else {
             log.warn('Agent returned empty content with no recognized tags; sending error', {
@@ -633,6 +717,8 @@ async function runAgentTurnInternal(sessionId, subscription, clientMessage, send
     }
 }
 async function runAgentTurn(sessionId, subscription, clientMessage, send, log, options) {
+    // untaggedDepth always starts at 0 for external callers; it is only threaded
+    // through the internal recursive path.
     await runAgentTurnInternal(sessionId, subscription, clientMessage, send, log, options);
 }
 function attachAgentWebSocketServer(server) {

package/backend-dist/agent/sessionGrouping.js

@@ -87,26 +87,25 @@ function extractProjectPath(texts) {
     return qualified[0]?.[0] ?? null;
 }
 // ---------------------------------------------------------------------------
-// Build a deterministic 3-4 sentence description from the project path.
-// Used as a fallback when the LLM does not return a usable description.
-// When a project path is available it is included verbatim so downstream
-// agent prompts can rely on it as the project root.
+// Deterministic 3-sentence fallback description.
+// The description always answers, in order:
+//   1. Where is the project root located?
+//   2. What is the purpose of this project?
+//   3. If it is a coding project, what is the primary programming language?
+// Used when the LLM does not return a usable description.
 // ---------------------------------------------------------------------------
 function buildDescription(projectPath, groupName) {
-    if (!projectPath) {
+    if (projectPath) {
         return [
-            `You are working on the ${groupName} project.`,
-            `This group collects sessions related to ${groupName}.`,
-            `No specific file path has been associated with this group yet.`,
-            `Use this context to keep responses focused on the ${groupName} topic.`,
+            `Project root: ${projectPath} (the ${groupName} project).`,
+            `Purpose: ongoing work on the ${groupName} codebase.`,
+            `Primary language: not yet determined from session context.`,
         ].join(' ');
     }
-    const projectName = projectPath.split('/').filter(Boolean).pop() ?? groupName;
     return [
-        `You are working in ${projectPath} — the ${projectName} project.`,
-        `This group collects sessions related to the ${projectName} codebase.`,
-        `Treat ${projectPath} as the project root when interpreting file references and commands.`,
-        `Keep responses scoped to this project's structure and conventions.`,
+        `Project root: not specified — no absolute path has been associated with the ${groupName} group yet.`,
+        `Purpose: sessions grouped under ${groupName}.`,
+        `Primary language: not applicable (no coding project identified).`,
     ].join(' ');
 }
 async function classifyGroup(userInputs, existingGroups) {
@@ -123,18 +122,19 @@ ${userInputs.map((m, i) => `${i + 1}. ${m}`).join('\n')}
 Existing groups:
 ${existingText}
 
-Rules:
+Rules for the group name:
 1. Look for file system paths, repository names, or project names in the messages.
 2. Identify the root project — if "/Users/john/projects/my-app/src/file.ts" appears, the group is "my-app".
 3. If an existing group clearly matches, return its EXACT name.
 4. Otherwise create a concise group name: 2-4 words, Title Case (e.g. "OmniKey AI", "Music Video Editor", "Client Website").
-5. ALWAYS write a 3-4 sentence description (roughly 3-4 lines, 250-500 characters) that explains:
-   - what the project / group is about,
-   - the kind of work that happens in these sessions,
-   - any relevant tech stack, repo, or domain hints inferred from the messages,
-   - and the absolute file path of the project root when one is present in the messages.
-   If a file path is found, you MUST include the exact absolute path verbatim in the description (e.g. "Project root: /Users/john/projects/my-app."). Start the description with "You are working in <path> — the <project-name> project." when a path is available, otherwise start with "You are working on the <project-name> project.". Do not use markdown, bullet points, or newlines — keep it as a single paragraph.
-6. If no paths exist and the session is purely general/conversational, use group name "General" and still produce a 3-4 sentence description summarizing the recurring topic.
+5. If the session is purely general/conversational with no project signal, use "General".
+
+Rules for the description (CRITICAL):
+The description is appended to user input as <project_context> whenever the user picks this project, so it must be short, factual, and load-bearing. Write a SINGLE paragraph of 3-4 sentences (max 4 sentences, no markdown, no bullet points, no newlines) that answers these three questions in order:
+   1. Where is the project root located? Quote the exact absolute path verbatim when one is present in the messages (e.g. "Project root: /Users/john/projects/my-app."). If no path is present, say so explicitly.
+   2. What is the purpose of this project? One sentence summarising what the project / group is for, inferred from the messages.
+   3. If it is a coding project, what is the primary programming language? Name the language (e.g. TypeScript, Python, Go, Rust) when it can be inferred from file extensions, framework names, package files, or explicit mentions. If it is not a coding project, say "Not a coding project." If the language cannot be inferred, say "Primary language not identified from the available context."
+Keep the whole description under ~500 characters. Do NOT add extra commentary, tech-stack lists, workflow notes, or session summaries beyond what the three questions require.
 
 Respond with ONLY valid JSON, no markdown:
 {"groupName":"...","groupDescription":"..."}`;
@@ -158,15 +158,27 @@ Respond with ONLY valid JSON, no markdown:
         const groupName = response.groupName.trim().slice(0, 100);
         if (!groupName)
             return null;
-        // If this matches an existing group, always reuse the stored description.
+        // When we fall through from the existingMatch branch to regenerate a stale
+        // description, preserve the canonical existing group name so we don't
+        // fragment groups by re-casing the name.
+        let canonicalName = null;
+        // If this matches an existing group, reuse the stored description ONLY when it
+        // already follows the new shape (must mention "Project root" and "Primary
+        // language"). Otherwise fall through and let the LLM-generated description
+        // replace it, so old verbose descriptions are upgraded in place.
         const existingMatch = existingGroups.find((g) => g.groupName.toLowerCase() === groupName.toLowerCase());
         if (existingMatch) {
-            const groupDescription = existingMatch.groupDescription ??
-                buildDescription(extractProjectPath(userInputs), groupName);
-            return { groupName: existingMatch.groupName, groupDescription };
+            const stored = existingMatch.groupDescription ?? '';
+            const hasNewShape = /project root/i.test(stored) && /primary language/i.test(stored);
+            if (hasNewShape) {
+                return { groupName: existingMatch.groupName, groupDescription: stored };
+            }
+            // Fall through: regenerate description using the LLM output below, but
+            // keep the canonical existing group name so we don't fragment groups.
+            canonicalName = existingMatch.groupName;
         }
         // New group: prefer the LLM description but fall back to the deterministic builder.
-        // Description is now a 3-4 sentence paragraph (no newlines, capped at 1000 chars
+        // Description is a single 3-4 sentence paragraph (no newlines, capped at 800 chars
         // to leave headroom over the ~500 char target while still bounding storage).
         const rawDesc = response.groupDescription.trim();
         const projectPath = extractProjectPath(userInputs);
@@ -177,10 +189,15 @@ Respond with ONLY valid JSON, no markdown:
         // Safety net: if the LLM ignored the rule and a path exists in the messages
         // but is missing from the description, append it so the contract holds.
         if (projectPath && !groupDescription.includes(projectPath)) {
-            groupDescription = `${groupDescription} Project root: ${projectPath}.`.trim();
+            groupDescription = `Project root: ${projectPath}. ${groupDescription}`.trim();
         }
-        groupDescription = groupDescription.slice(0, 1000);
-        return { groupName, groupDescription };
+        groupDescription = groupDescription.slice(0, 800);
+        return {
+            // Preserve the canonical existing group name when we fell through from
+            // the existingMatch branch to regenerate a stale description.
+            groupName: canonicalName ?? groupName,
+            groupDescription,
+        };
     }
     catch (err) {
         logger_1.logger.warn('Session group classification failed', { error: err });
@@ -188,6 +205,102 @@ Respond with ONLY valid JSON, no markdown:
     }
 }
 // ---------------------------------------------------------------------------
+// Fetch up to 10 recent user inputs from sessions already in a group.
+// Used to give the LLM richer context about the group when classifying a
+// new session or when refreshing a description via the cron job.
+// ---------------------------------------------------------------------------
+async function fetchSiblingInputs(subscriptionId, groupName, excludeSessionId) {
+    const sessions = await agentSession_1.AgentSession.findAll({
+        where: excludeSessionId
+            ? { subscriptionId, groupName, id: { [sequelize_1.Op.ne]: excludeSessionId } }
+            : { subscriptionId, groupName },
+        order: [['last_active_at', 'DESC']],
+        limit: 15,
+        attributes: ['historyJson'],
+    });
+    const collected = [];
+    for (const s of sessions) {
+        for (const inp of extractUserInputs(s.historyJson)) {
+            collected.push(inp);
+            if (collected.length >= 10)
+                break;
+        }
+        if (collected.length >= 10)
+            break;
+    }
+    return collected;
+}
+// ---------------------------------------------------------------------------
+// LLM: generate or update a group description using combined inputs.
+// When isUpdateMode is true the LLM is asked to UPDATE the existing
+// description with new findings rather than write one from scratch.
+// ---------------------------------------------------------------------------
+async function enrichGroupDescription(groupName, allInputs, existingDescription, isUpdateMode) {
+    if (!allInputs.length)
+        return null;
+    const projectPath = extractProjectPath(allInputs);
+    const messagesText = allInputs.map((m, i) => `${i + 1}. ${m}`).join('\n');
+    const prompt = isUpdateMode && existingDescription
+        ? `Update the project group description for "${groupName}" based on new session data.
+
+Current description:
+"${existingDescription}"
+
+Recent user messages from sessions in this group:
+${messagesText}
+
+Update the description to incorporate any new findings. Keep the same 3-4 sentence structure answering in order:
+1. Where is the project root? (Quote the exact absolute path verbatim when present.)
+2. What is the purpose of this project?
+3. What is the primary programming language?
+
+Rules: single paragraph, under ~500 characters, no markdown, no bullet points, no newlines. Preserve correct existing information. Only change what the messages provide new or better details on.
+
+Respond with ONLY valid JSON: {"groupDescription":"..."}`
+        : `Generate a description for the project group "${groupName}" based on these session messages.
+
+Messages:
+${messagesText}
+
+Write a SINGLE paragraph of 3-4 sentences (no markdown, no bullet points, no newlines) answering in order:
+1. Where is the project root? (Quote the exact absolute path verbatim when present, or say so if absent.)
+2. What is the purpose of this project?
+3. What is the primary programming language? (Name it when inferable; "Primary language not identified." if not.)
+
+Keep the whole description under ~500 characters.
+
+Respond with ONLY valid JSON: {"groupDescription":"..."}`;
+    try {
+        const result = await ai_client_1.aiClient.complete(aiModel, [
+            {
+                role: 'system',
+                content: 'You are a session categorization assistant. Respond only with the requested JSON object, no extra text.',
+            },
+            { role: 'user', content: prompt },
+        ], { temperature: 0 });
+        const raw = result.content
+            .trim()
+            .replace(/^```(?:json)?\n?/, '')
+            .replace(/\n?```$/, '')
+            .trim();
+        const parsed = JSON.parse(raw);
+        const response = zod_1.z.object({ groupDescription: zod_1.z.string() }).parse(parsed);
+        let description = response.groupDescription
+            .trim()
+            .replace(/\s*\n+\s*/g, ' ')
+            .replace(/\s{2,}/g, ' ')
+            .trim();
+        if (projectPath && !description.includes(projectPath)) {
+            description = `Project root: ${projectPath}. ${description}`.trim();
+        }
+        return description.slice(0, 800);
+    }
+    catch (err) {
+        logger_1.logger.warn('Group description enrichment failed', { groupName, error: err });
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
 // Public: update one session's group
 // ---------------------------------------------------------------------------
 async function updateSessionGroup(sessionId, subscriptionId) {
@@ -218,10 +331,25 @@ async function updateSessionGroup(sessionId, subscriptionId) {
             groupName: s.groupName,
             groupDescription: s.groupDescription ?? null,
         }));
+        // Step 1: classify to determine the group name and an initial description
         const result = await classifyGroup(inputs, existingGroups);
         if (!result)
             return;
-        await agentSession_1.AgentSession.update({ groupName: result.groupName, groupDescription: result.groupDescription }, { where: { id: sessionId } });
+        // Step 2: if the session was matched to an existing group, fetch sibling
+        // inputs to enrich the description with broader project context.
+        const isExistingGroup = existingGroups.some((g) => g.groupName.toLowerCase() === result.groupName.toLowerCase());
+        let finalDescription = result.groupDescription;
+        if (isExistingGroup) {
+            const siblingInputs = await fetchSiblingInputs(subscriptionId, result.groupName, sessionId);
+            if (siblingInputs.length > 0) {
+                // Combine current session inputs with recent sibling inputs (cap at 18).
+                const combinedInputs = [...inputs, ...siblingInputs].slice(0, 18);
+                const enriched = await enrichGroupDescription(result.groupName, combinedInputs, result.groupDescription, true);
+                if (enriched)
+                    finalDescription = enriched;
+            }
+        }
+        await agentSession_1.AgentSession.update({ groupName: result.groupName, groupDescription: finalDescription }, { where: { id: sessionId } });
         logger_1.logger.info('Session group updated', { sessionId, groupName: result.groupName });
     }
     catch (err) {
@@ -229,21 +357,70 @@ async function updateSessionGroup(sessionId, subscriptionId) {
     }
 }
 // ---------------------------------------------------------------------------
-// Public: refresh all sessions for a subscription (used by cron)
+// Cron helper: refresh the description for one group by collecting the most
+// recent 10 user inputs across all sessions in that group and asking the LLM
+// to UPDATE the existing description with any new findings.
 // ---------------------------------------------------------------------------
-async function refreshAllSessionGroups(subscriptionId) {
+async function refreshGroupDescription(subscriptionId, groupName, existingDescription) {
     try {
         const sessions = await agentSession_1.AgentSession.findAll({
-            where: { subscriptionId },
+            where: { subscriptionId, groupName },
             order: [['last_active_at', 'DESC']],
-            limit: 50,
-            attributes: ['id', 'historyJson'],
+            limit: 15,
+            attributes: ['historyJson'],
+        });
+        const allInputs = [];
+        for (const s of sessions) {
+            for (const inp of extractUserInputs(s.historyJson)) {
+                allInputs.push(inp);
+                if (allInputs.length >= 10)
+                    break;
+            }
+            if (allInputs.length >= 10)
+                break;
+        }
+        if (!allInputs.length)
+            return;
+        const newDescription = await enrichGroupDescription(groupName, allInputs, existingDescription, true);
+        if (!newDescription)
+            return;
+        // Sync the updated description to every session in this group.
+        await agentSession_1.AgentSession.update({ groupDescription: newDescription }, { where: { subscriptionId, groupName } });
+        logger_1.logger.info('Group description refreshed', { subscriptionId, groupName });
+    }
+    catch (err) {
+        logger_1.logger.error('Failed to refresh group description', { subscriptionId, groupName, error: err });
+    }
+}
+// ---------------------------------------------------------------------------
+// Public: refresh all sessions for a subscription (used by cron)
+// ---------------------------------------------------------------------------
+async function refreshAllSessionGroups(subscriptionId) {
+    try {
+        // Refresh descriptions for all existing groups (one LLM call per group).
+        const groupRows = await agentSession_1.AgentSession.findAll({
+            where: {
+                subscriptionId,
+                groupName: { [sequelize_1.Op.not]: null },
+            },
+            attributes: ['groupName', 'groupDescription'],
+            group: ['group_name'],
         });
         logger_1.logger.info('Refreshing session groups', {
             subscriptionId,
-            count: sessions.length,
+            groupCount: groupRows.length,
+        });
+        for (const row of groupRows) {
+            await refreshGroupDescription(subscriptionId, row.groupName, row.groupDescription ?? null);
+        }
+        // Also classify any sessions that haven't been grouped yet.
+        const ungroupedSessions = await agentSession_1.AgentSession.findAll({
+            where: { subscriptionId, groupName: null },
+            order: [['last_active_at', 'DESC']],
+            limit: 20,
+            attributes: ['id'],
         });
-        for (const session of sessions) {
+        for (const session of ungroupedSessions) {
             await updateSessionGroup(session.id, subscriptionId);
         }
     }
@@ -258,7 +435,7 @@ async function refreshAllSessionGroups(subscriptionId) {
 // Cron: run every 6 hours across all subscriptions
 // ---------------------------------------------------------------------------
 function startGroupingCronJob() {
-    const SIX_HOURS_MS = 6 * 60 * 60 * 1000;
+    const ONE_HOUR_MS = 60 * 60 * 1000;
     const tick = async () => {
         try {
             const subscriptions = await subscription_1.Subscription.findAll({ attributes: ['id'] });
@@ -273,15 +450,16 @@ function startGroupingCronJob() {
             logger_1.logger.error('Session grouping cron failed', { error: err });
         }
     };
-    setInterval(() => void tick(), SIX_HOURS_MS);
-    logger_1.logger.info('Session grouping cron started (6h interval)');
+    setInterval(() => void tick(), ONE_HOUR_MS);
+    logger_1.logger.info('Session grouping cron started (1h interval)');
     // If no session has a group yet (e.g. first startup after the feature was
     // added, or a fresh self-hosted install with existing sessions), run the
-    // full backfill immediately rather than waiting 6 hours.
+    // full backfill immediately rather than waiting 1 hours.
     void (async () => {
         try {
             const ungrouped = await agentSession_1.AgentSession.count({ where: { groupName: null } });
             const grouped = await agentSession_1.AgentSession.count({ where: { groupName: { [sequelize_1.Op.not]: null } } });
+            logger_1.logger.info(`Session grouping backfill check: ${ungrouped} ungrouped sessions, ${grouped} grouped sessions`);
             if (ungrouped > 0 && grouped === 0) {
                 logger_1.logger.info('No sessions have a group yet — running initial grouping backfill', {
                     sessionCount: ungrouped,

package/backend-dist/index.js

@@ -78,8 +78,8 @@ app.get('/macos/appcast', (req, res) => {
     const appcastUrl = `${baseUrl}/macos/appcast`;
     // These should match the values embedded into the macOS app
     // Info.plist in macOS/build_release_dmg.sh.
-    const bundleVersion = '36';
-    const shortVersion = '1.0.35';
+    const bundleVersion = '37';
+    const shortVersion = '1.0.36';
     const xml = `<?xml version="1.0" encoding="utf-8"?>
 <rss version="2.0"
      xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "CLI for onboarding users to Omnikey AI and configuring OPENAI_API_KEY. Use Yarn for install/build.",
   "engines": {
     "node": ">=14.0.0",