@heylemon/lemonade 0.6.7 → 0.7.0

package/dist/agents/model-fallback.js

@@ -1,6 +1,7 @@
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "./defaults.js";
 import { coerceToFailoverError, describeFailoverError, isFailoverError, isTimeoutError, } from "./failover-error.js";
 import { buildModelAliasIndex, modelKey, parseModelRef, resolveConfiguredModelRef, resolveModelRefFromString, } from "./model-selection.js";
+import { isLikelyContextOverflowError } from "./pi-embedded-helpers.js";
 import { ensureAuthProfileStore, isProfileInCooldown, resolveAuthProfileOrder, } from "./auth-profiles.js";
 function isAbortError(err) {
     if (!err || typeof err !== "object")
@@ -179,13 +180,17 @@ export async function runWithModelFallback(params) {
         catch (err) {
             if (shouldRethrowAbort(err))
                 throw err;
+            const errMessage = err instanceof Error ? err.message : String(err);
+            if (isLikelyContextOverflowError(errMessage))
+                throw err;
             const normalized = coerceToFailoverError(err, {
                 provider: candidate.provider,
                 model: candidate.model,
             }) ?? err;
-            if (!isFailoverError(normalized))
+            const isKnownFailover = isFailoverError(normalized);
+            if (!isKnownFailover && i === candidates.length - 1)
                 throw err;
-            lastError = normalized;
+            lastError = isKnownFailover ? normalized : err;
             const described = describeFailoverError(normalized);
             attempts.push({
                 provider: candidate.provider,

package/dist/agents/pi-tool-definition-adapter.js

@@ -1,6 +1,10 @@
 import { logDebug, logError } from "../logger.js";
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
 import { normalizeToolName } from "./tool-policy.js";
 import { jsonResult } from "./tools/common.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function describeToolExecutionError(err) {
     if (err instanceof Error) {
         const message = err.message?.trim() ? err.message : String(err);
@@ -8,6 +12,26 @@ function describeToolExecutionError(err) {
     }
     return { message: String(err) };
 }
+function normalizeToolExecutionResult(params) {
+    const { toolName, result } = params;
+    if (result && typeof result === "object") {
+        const record = result;
+        if (Array.isArray(record.content)) {
+            return result;
+        }
+        const details = "details" in record ? record.details : record;
+        const safeDetails = details ?? { status: "ok", tool: toolName };
+        return {
+            content: [{ type: "text", text: JSON.stringify(safeDetails, null, 2) }],
+            details: safeDetails,
+        };
+    }
+    const safeDetails = result ?? { status: "ok", tool: toolName };
+    return {
+        content: [{ type: "text", text: JSON.stringify(safeDetails, null, 2) }],
+        details: safeDetails,
+    };
+}
 export function toToolDefinitions(tools) {
     return tools.map((tool) => {
         const name = tool.name || "tool";
@@ -19,36 +43,87 @@ export function toToolDefinitions(tools) {
             // biome-ignore lint/suspicious/noExplicitAny: TypeBox schema from pi-agent-core uses a different module instance.
             parameters: tool.parameters,
             execute: async (toolCallId, params, onUpdate, _ctx, signal) => {
-                // KNOWN: pi-coding-agent `ToolDefinition.execute` has a different signature/order
-                // than pi-agent-core `AgentTool.execute`. This adapter keeps our existing tools intact.
+                let executeParams = params;
                 try {
-                    return await tool.execute(toolCallId, params, signal, onUpdate);
+                    const hookRunner = getGlobalHookRunner();
+                    if (hookRunner?.hasHooks("before_tool_call")) {
+                        try {
+                            const hookResult = await hookRunner.runBeforeToolCall({
+                                toolName: name,
+                                params: isPlainObject(params) ? params : {},
+                            }, { toolName: name });
+                            if (hookResult?.block) {
+                                throw new Error(hookResult.blockReason || "Tool call blocked by plugin hook");
+                            }
+                            if (hookResult?.params && isPlainObject(hookResult.params)) {
+                                executeParams = isPlainObject(params)
+                                    ? { ...params, ...hookResult.params }
+                                    : hookResult.params;
+                            }
+                        }
+                        catch (hookErr) {
+                            if (hookErr instanceof Error && hookErr.message.includes("blocked by plugin hook")) {
+                                throw hookErr;
+                            }
+                            logDebug(`before_tool_call hook failed: tool=${normalizedName} error=${String(hookErr)}`);
+                        }
+                    }
+                    const rawResult = await tool.execute(toolCallId, executeParams, signal, onUpdate);
+                    const result = normalizeToolExecutionResult({
+                        toolName: normalizedName,
+                        result: rawResult,
+                    });
+                    if (hookRunner?.hasHooks("after_tool_call")) {
+                        try {
+                            await hookRunner.runAfterToolCall({
+                                toolName: name,
+                                params: isPlainObject(executeParams) ? executeParams : {},
+                                result,
+                            }, { toolName: name });
+                        }
+                        catch (hookErr) {
+                            logDebug(`after_tool_call hook failed: tool=${normalizedName} error=${String(hookErr)}`);
+                        }
+                    }
+                    return result;
                 }
                 catch (err) {
                     if (signal?.aborted)
                         throw err;
-                    const name = err && typeof err === "object" && "name" in err
+                    const errName = err && typeof err === "object" && "name" in err
                         ? String(err.name)
                         : "";
-                    if (name === "AbortError")
+                    if (errName === "AbortError")
                         throw err;
                     const described = describeToolExecutionError(err);
                     if (described.stack && described.stack !== described.message) {
                         logDebug(`tools: ${normalizedName} failed stack:\n${described.stack}`);
                     }
                     logError(`[tools] ${normalizedName} failed: ${described.message}`);
-                    return jsonResult({
+                    const errorResult = jsonResult({
                         status: "error",
                         tool: normalizedName,
                         error: described.message,
                     });
+                    const hookRunner = getGlobalHookRunner();
+                    if (hookRunner?.hasHooks("after_tool_call")) {
+                        try {
+                            await hookRunner.runAfterToolCall({
+                                toolName: normalizedName,
+                                params: isPlainObject(params) ? params : {},
+                                error: described.message,
+                            }, { toolName: normalizedName });
+                        }
+                        catch (hookErr) {
+                            logDebug(`after_tool_call hook failed: tool=${normalizedName} error=${String(hookErr)}`);
+                        }
+                    }
+                    return errorResult;
                 }
             },
         };
     });
 }
-// Convert client tools (OpenResponses hosted tools) to ToolDefinition format
-// These tools are intercepted to return a "pending" result instead of executing
 export function toClientToolDefinitions(tools, onClientToolCall) {
     return tools.map((tool) => {
         const func = tool.function;
@@ -58,11 +133,9 @@ export function toClientToolDefinitions(tools, onClientToolCall) {
             description: func.description ?? "",
             parameters: func.parameters,
             execute: async (toolCallId, params, _onUpdate, _ctx, _signal) => {
-                // Notify handler that a client tool was called
                 if (onClientToolCall) {
                     onClientToolCall(func.name, params);
                 }
-                // Return a pending result - the client will execute this tool
                 return jsonResult({
                     status: "pending",
                     tool: func.name,

package/dist/agents/system-prompt.js

@@ -347,7 +347,24 @@ export function buildAgentSystemPrompt(params) {
         "Never reply with a list of approaches/options when a single tool call would suffice.",
         "CRITICAL: NEVER stop after announcing what you're going to do. Do NOT say 'I'll check your LinkedIn' and then stop. Say it AND immediately do it in the same response — search, open browser, navigate, find the answer, and return it. The user should never have to ask twice. One request = one complete answer.",
         "",
+        "## Native macOS Apps & Optional CLIs",
+        "By default, use built-in macOS apps for common tasks:",
+        "- **Reminders** → use the macOS Reminders app via AppleScript (`osascript`). Do NOT require any CLI tool.",
+        "- **Calendar** → use `lemon-calendar` (Google Calendar). For local macOS Calendar, use AppleScript.",
+        "- **Notes** → use Apple Notes via AppleScript.",
+        "",
+        "Optional third-party app CLIs (Things, Obsidian, Bear Notes) should ONLY be installed when the user explicitly mentions those apps by name:",
+        '- User says "set a reminder" → use macOS Reminders app. Done.',
+        '- User says "add this to Things" → silently install `things-cli` via brew in the background (`brew install things-cli 2>/dev/null`), then use it. No warning, no asking.',
+        '- User says "save this to Obsidian" → silently install `obsidian-cli` via brew (`brew install obsidian-cli 2>/dev/null`), then use it.',
+        '- User says "add a note in Bear" → silently install `grizzly` via brew (`brew install grizzly 2>/dev/null`), then use it.',
+        "",
+        "Internal CLI tools (summarize, blogwatcher, gemini-cli, ffmpeg, etc.) are automatically installed when the user activates a persona/skill pack. Assume they are available — do NOT try to install them yourself or warn the user about them.",
+        "",
+        "CRITICAL: NEVER show install warnings or ask the user to install CLIs upfront. The user does NOT need to install anything for basic functionality. Only install app-specific CLIs when a specific third-party app is mentioned, and do it silently as part of completing the task.",
+        "",
         "## Screenshots",
+        "CRITICAL: When asked to take a screenshot, ALWAYS take one. NEVER say you can't. NEVER tell the user to press Cmd+Shift+3/4 themselves. NEVER try to use the browser for screenshots of native windows.",
         'Endpoint: `curl -s "http://127.0.0.1:19848/screenshot?name=SHORT_NAME"`',
         'Returns: `{"path": "/path/to/file.jpg", "mode": "window"}`',
         "",
@@ -360,6 +377,7 @@ export function buildAgentSystemPrompt(params) {
         "If user refers to a past screenshot and the path is no longer in conversation, run `ls ~/.lemonade/tmp/screenshots/` to find it by name.",
         "",
         "Usage: returned path works with `message` tool (send via WhatsApp/Slack) and `image` tool (analyze).",
+        "Fallback: if the screenshot endpoint is unavailable, use `screencapture -x /tmp/screenshot.png` directly.",
         "",
         "## Third-Party App Requests (Trello, Jira, LinkedIn, Asana, HubSpot, Salesforce, Todoist, etc.)",
         "",
@@ -550,7 +568,8 @@ export function buildAgentSystemPrompt(params) {
         'If a capability is unavailable, say something like "I can\'t do that right now" or suggest an alternative. Never ask the user to configure keys, edit config files, or troubleshoot infrastructure.',
         "",
         "## Cron / Reminders",
-        "ALWAYS use the `cron` tool (action: add/update/remove/list/run/status) for managing cron jobs and reminders.",
+        "For reminders: use the `cron` tool by default. If the user wants a native macOS Reminder, use AppleScript with the Reminders app. If the user mentions Things specifically, silently install things-cli (`brew install things-cli 2>/dev/null`) and use it.",
+        "ALWAYS use the `cron` tool (action: add/update/remove/list/run/status) for managing cron jobs and scheduled tasks.",
         "NEVER use `exec` or shell commands to read/write cron files (e.g. ~/.lemonade/cron/jobs.json) directly — the gateway cron service will not detect the change.",
         "",
         "### Choosing sessionTarget and payload kind",

package/dist/auto-reply/reply/session.js

@@ -11,6 +11,15 @@ import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
 import { formatInboundBodyWithSenderMeta } from "./inbound-sender-meta.js";
 import { normalizeInboundTextNewlines } from "./inbound-text.js";
 import { normalizeSessionDeliveryFields } from "../../utils/delivery-context.js";
+import { archiveSessionTranscripts } from "../../gateway/session-utils.fs.js";
+const DEFAULT_PARENT_FORK_MAX_TOKENS = 100_000;
+function resolveParentForkMaxTokens(cfg) {
+    const configured = cfg.session?.parentForkMaxTokens;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured >= 0) {
+        return Math.floor(configured);
+    }
+    return DEFAULT_PARENT_FORK_MAX_TOKENS;
+}
 function forkSessionFromParent(params) {
     const parentSessionFile = resolveSessionFilePath(params.parentEntry.sessionId, params.parentEntry);
     if (!parentSessionFile || !fs.existsSync(parentSessionFile))
@@ -62,8 +71,11 @@ export async function initSessionState(params) {
         ? sessionCfg.resetTriggers
         : DEFAULT_RESET_TRIGGERS;
     const sessionScope = sessionCfg?.scope ?? "per-sender";
+    const parentForkMaxTokens = resolveParentForkMaxTokens(cfg);
     const storePath = resolveStorePath(sessionCfg?.store, { agentId });
-    const sessionStore = loadSessionStore(storePath);
+    const sessionStore = loadSessionStore(storePath, {
+        skipCache: true,
+    });
     let sessionKey;
     let sessionEntry;
     let sessionId;
@@ -129,6 +141,15 @@ export async function initSessionState(params) {
     sessionKey = resolveSessionKey(sessionScope, sessionCtxForState, mainKey);
     const entry = sessionStore[sessionKey];
     const previousSessionEntry = resetTriggered && entry ? { ...entry } : undefined;
+    if (previousSessionEntry?.sessionId) {
+        archiveSessionTranscripts({
+            sessionId: previousSessionEntry.sessionId,
+            storePath,
+            sessionFile: previousSessionEntry.sessionFile,
+            agentId,
+            reason: "reset",
+        });
+    }
     const now = Date.now();
     const isThread = resolveThreadFlag({
         sessionKey,
@@ -242,13 +263,18 @@ export async function initSessionState(params) {
         parentSessionKey &&
         parentSessionKey !== sessionKey &&
         sessionStore[parentSessionKey]) {
-        const forked = forkSessionFromParent({
-            parentEntry: sessionStore[parentSessionKey],
-        });
-        if (forked) {
-            sessionId = forked.sessionId;
-            sessionEntry.sessionId = forked.sessionId;
-            sessionEntry.sessionFile = forked.sessionFile;
+        const parentEntry = sessionStore[parentSessionKey];
+        const parentTokens = parentEntry.totalTokens ?? 0;
+        if (parentForkMaxTokens > 0 && parentTokens > parentForkMaxTokens) {
+            sessionEntry.forkedFromParent = true;
+        }
+        else {
+            const forked = forkSessionFromParent({ parentEntry });
+            if (forked) {
+                sessionId = forked.sessionId;
+                sessionEntry.sessionId = forked.sessionId;
+                sessionEntry.sessionFile = forked.sessionFile;
+            }
         }
     }
     if (!sessionEntry.sessionFile) {

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.6.7",
-  "commit": "2965fd60321e809102f7cf3b40bb4a8bb6e009cb",
-  "builtAt": "2026-02-28T10:36:45.544Z"
+  "version": "0.7.0",
+  "commit": "105eba9ae37816020018df1fa07a598f417517a7",
+  "builtAt": "2026-03-02T05:54:52.350Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -0,0 +1 @@
+155aed5143b97b9dd8e4548c7aa0a4bbde8088ee944fe179bb596cc327b75752