loopengine 0.1.92 → 0.1.94

package/dist/core/system-agents/templates.js

@@ -1,53 +1,135 @@
+import { nextTimeOfDay, parseTimeOfDay, workspaceTimeZone } from '../time-zone.js';
+const GMAIL_KEYS = ['GMAIL_CLIENT_ID', 'GMAIL_CLIENT_SECRET', 'GMAIL_REFRESH_TOKEN'];
+const SHOPIFY_KEYS = ['SHOPIFY_STORE_DOMAIN', 'SHOPIFY_ADMIN_TOKEN'];
+const GITHUB_KEYS = ['GITHUB_TOKEN', 'GITHUB_DEFAULT_REPO'];
+const SLACK_KEYS = ['SLACK_BOT_TOKEN', 'SLACK_DEFAULT_CHANNEL'];
+const WEB_SEARCH_KEYS = [['TAVILY_API_KEY', 'BRAVE_API_KEY', 'FIRECRAWL_API_KEY']];
+const DOCS_NOTE = 'Put your policies and help articles in the project\'s docs folder, as Markdown or text files (or point DOCS_SEARCH_PATH at another folder)';
 export const STARTER_TEMPLATES = [
     {
         id: 'customer-email-replies',
         category: 'Customer service',
         candidate: {
             title: 'Answer customer emails',
-            summary: 'Reads each new customer email, looks up what it needs, and drafts a reply. Routine answers go out once you allow them; refunds and anything unusual wait for you.',
-            trigger: { kind: 'event', description: 'each new customer email' },
+            summary: 'Checks the support inbox every 10 minutes, looks up each customer\'s order, and replies. Every reply waits for your approval until you trust it; refund requests are left for a person.',
+            trigger: { kind: 'schedule', description: 'every 10 minutes, for new emails', every: '10m' },
             hoursPerWeek: 5,
             fit: 7,
             risk: 'medium',
-            asksFirst: ['sending a reply', 'refunds', 'discounts'],
+            asksFirst: ['sending a reply'],
             needs: [
-                { kind: 'api', name: 'Email', description: 'your support inbox' },
-                { kind: 'ability', name: 'lp-docs-search', description: 'your help articles and policies, so replies follow them' },
-                { kind: 'messaging', name: 'Slack', description: 'Slack, to approve replies and refunds' },
+                { kind: 'ability', name: 'lp-gmail', description: 'your support inbox' },
+                { kind: 'ability', name: 'lp-shopify', description: 'your store\'s orders' },
+                { kind: 'ability', name: 'lp-docs-search', description: 'your help articles and policies' },
             ],
             agent: {
                 name: 'customer-email-replies',
-                systemPrompt: `You answer customer emails for our business.
+                systemPrompt: `You answer customer emails for our business, from our support inbox.
 
-For each email:
-1. Work out what the customer wants: order status, a product question, a return or refund, a complaint, or something else.
-2. Look up what you need before answering, such as the order, its shipping status, or our policies. Never guess an order detail, a date or a policy.
-3. Draft a short, friendly reply in the customer's language. Use their name, answer the question first, and say what happens next.
-4. Send it with the email tool.
+When asked to handle new emails:
+1. Find them with gmail_search, query "is:unread in:inbox". Skip newsletters, receipts, automatic notifications and "no-reply" senders: mark those read and move on.
+2. For each customer email, read the whole conversation with gmail_get_thread first.
+3. Work out what they want: order status, a product question, a return or refund, a complaint, or something else.
+4. Look up what you need before answering: the order with shopify_find_orders (by the order number they give, or their email) and shopify_get_order, and our policies with search_docs. Never guess an order detail, a date or a policy.
+5. Reply with gmail_send, passing reply_to_message_id so it stays in the same thread: short, friendly, in the customer's language, using their name, answering the question first and saying what happens next.
+6. Mark the email read with gmail_modify_labels (remove "UNREAD").
 
 Rules:
-- Refunds, discounts, replacements and anything that costs money: draft it, explain your reasoning in one line, and let a person approve it.
-- If the customer is angry, mentions a lawyer, a chargeback or a safety problem, don't promise anything; draft a calm reply for a person to review.
-- If you can't find the order or the answer, say so in the draft rather than inventing one.
-- Never share another customer's information.`,
-                exampleMessage: 'New email from Sam Lee: "Hi, my order #1042 still hasn\'t arrived and it\'s been 10 days. Where is it?"',
+- Refunds, returns and replacements are handled by a person: reply that their request has been passed to the team, then star the email (add "STARRED") instead of acting on it.
+- If the customer is angry, mentions a lawyer, a chargeback or a safety problem, don't promise anything; save a calm reply with gmail_create_draft and star the email for a person.
+- If you can't find the order or the answer, say so and ask for the order number; don't invent one.
+- Never share one customer's information with anyone else.`,
+                scheduleMessage: 'Handle new customer emails in the support inbox.',
+                exampleMessage: 'Handle new customer emails in the support inbox.',
             },
         },
+        setup: {
+            abilities: ['lp-gmail', 'lp-shopify', 'lp-docs-search'],
+            keys: [...GMAIL_KEYS, ...SHOPIFY_KEYS],
+            env: { DOCS_SEARCH_PATH: 'docs' },
+            rules: [
+                { name: 'template-read-mail-allowed', tool: 'gmail_search', decision: 'allow' },
+                { name: 'template-read-thread-allowed', tool: 'gmail_get_thread', decision: 'allow' },
+                { name: 'template-drafts-allowed', tool: 'gmail_create_draft', decision: 'allow' },
+                { name: 'template-labels-allowed', tool: 'gmail_modify_labels', decision: 'allow' },
+                { name: 'template-replies-need-approval', tool: 'gmail_send', decision: 'ask' },
+                { name: 'template-no-refunds', tool: 'shopify_create_refund', decision: 'deny' },
+            ],
+            schedule: { every: '10m', name: 'Check the support inbox', message: 'Handle new customer emails in the support inbox.' },
+            needsApprovals: true,
+            notes: [DOCS_NOTE],
+        },
+    },
+    {
+        id: 'refund-approvals',
+        category: 'Customer service',
+        candidate: {
+            title: 'Refund approvals',
+            summary: 'Checks the inbox for refund and return requests, checks each against the order and your return policy, and proposes the refund and the reply. Both wait for your approval.',
+            trigger: { kind: 'schedule', description: 'every 10 minutes, for new refund requests', every: '10m' },
+            hoursPerWeek: 3,
+            fit: 7,
+            risk: 'high',
+            asksFirst: ['issuing a refund', 'sending the reply'],
+            needs: [
+                { kind: 'ability', name: 'lp-gmail', description: 'your support inbox' },
+                { kind: 'ability', name: 'lp-shopify', description: 'your store\'s orders and refunds' },
+                { kind: 'ability', name: 'lp-docs-search', description: 'your return policy' },
+            ],
+            agent: {
+                name: 'refund-approvals',
+                systemPrompt: `You handle refund and return requests for our store, from our support inbox.
+
+When asked to handle new refund requests:
+1. Find them with gmail_search, query "is:unread in:inbox (refund OR return OR damaged OR broken OR "money back")". Read each conversation with gmail_get_thread. If an email isn't really a refund or return request, leave it unread for the support team.
+2. Find the order with shopify_find_orders (the order number they give, or their email) and read it with shopify_get_order: what was bought, when, how much, what's already been refunded, whether it was delivered.
+3. Check the request against our return policy with search_docs: the return window, whether the item is eligible, and whether the reason is covered.
+4. Decide what to propose: a full refund, a partial refund, refunding shipping, or no refund (and which part of the policy says so).
+5. Work out the exact amount with shopify_preview_refund. Never state an amount you haven't previewed.
+6. Issue it with shopify_create_refund, with a note giving the policy rule and the facts from the order. A person approves it first.
+7. Once the refund is done, reply with gmail_send (reply_to_message_id set): what was refunded, to which payment method, and that it takes 5–10 business days to arrive. Then mark the email read with gmail_modify_labels.
+
+Rules:
+- Never refund more than was paid, and never refund an order twice: check refunds on the order first.
+- If the refund is denied, don't try again; save a reply with gmail_create_draft explaining what you'd suggest instead, and star the email for a person.
+- If the order can't be found, ask the customer for the order number; don't guess.
+- If the customer mentions a chargeback, a lawyer or a safety problem, don't act; star the email for a person.`,
+                scheduleMessage: 'Handle new refund and return requests in the support inbox.',
+                exampleMessage: 'Handle new refund and return requests in the support inbox.',
+            },
+        },
+        setup: {
+            abilities: ['lp-gmail', 'lp-shopify', 'lp-docs-search'],
+            keys: [...GMAIL_KEYS, ...SHOPIFY_KEYS],
+            env: { DOCS_SEARCH_PATH: 'docs' },
+            rules: [
+                { name: 'template-read-mail-allowed', tool: 'gmail_search', decision: 'allow' },
+                { name: 'template-read-thread-allowed', tool: 'gmail_get_thread', decision: 'allow' },
+                { name: 'template-drafts-allowed', tool: 'gmail_create_draft', decision: 'allow' },
+                { name: 'template-labels-allowed', tool: 'gmail_modify_labels', decision: 'allow' },
+                { name: 'template-preview-allowed', tool: 'shopify_preview_refund', decision: 'allow' },
+                { name: 'template-refunds-need-approval', tool: 'shopify_create_refund', decision: 'ask' },
+                { name: 'template-replies-need-approval', tool: 'gmail_send', decision: 'ask' },
+            ],
+            schedule: { every: '10m', name: 'Check for refund requests', message: 'Handle new refund and return requests in the support inbox.' },
+            needsApprovals: true,
+            notes: [DOCS_NOTE + ' — especially your return policy'],
+        },
     },
     {
         id: 'incident-triage',
         category: 'Operations',
         candidate: {
             title: 'Triage incidents',
-            summary: 'Takes an alert or a bug report, works out what broke and how bad it is, finds related recent changes, and proposes the next step for the on-call person to approve.',
-            trigger: { kind: 'on_request', description: 'when an alert or report is passed to it in Chat or Slack' },
+            summary: 'Takes an alert or a bug report, works out what broke and how bad it is, finds the deploys and changes that likely caused it, and posts a summary to Slack. Opening or commenting on issues waits for approval.',
+            trigger: { kind: 'on_request', description: 'when an alert or report is passed to it in Chat, Slack or over HTTP' },
             hoursPerWeek: 3,
             fit: 6,
             risk: 'medium',
-            asksFirst: ['opening or changing issues', 'posting to channels', 'any action on a system'],
+            asksFirst: ['opening or commenting on issues'],
             needs: [
-                { kind: 'api', name: 'GitHub', description: 'GitHub or your issue tracker' },
-                { kind: 'messaging', name: 'Slack', description: 'Slack, so on-call can approve from the alert thread' },
+                { kind: 'ability', name: 'lp-github', description: 'your repository\'s commits, deploys and issues' },
+                { kind: 'ability', name: 'lp-slack-notifier', description: 'posting the summary to Slack' },
             ],
             agent: {
                 name: 'incident-triage',
@@ -56,69 +138,208 @@ Rules:
 When you get an alert, error or bug report:
 1. Summarise it in two sentences: what is failing and who is affected.
 2. Rate the severity: SEV1 (customers can't use the product), SEV2 (a major feature is broken), SEV3 (degraded or a workaround exists), SEV4 (minor).
-3. Look for likely causes: recent deploys, merged changes and open issues touching the same area. List the top two or three with links.
-4. Propose one next step: who should look, what to check first, and whether to roll back.
+3. Find what changed shortly before it started: github_list_workflow_runs for recent deploys and failed builds, github_list_pull_requests for recently merged changes, and github_list_commits (narrowed with since_hours and path) for detail. Match times carefully.
+4. Check whether it's already known with github_search_issues; read a match with github_get_issue.
+5. Post a short summary to Slack with post_to_slack: what's broken, severity, the most likely cause with links, and one next step (who should look, what to check, or whether to roll back).
+6. If an issue already tracks it, add your findings with github_comment_issue; otherwise, for SEV1 or SEV2, open one with github_create_issue. Both ask a person first.
 
 Rules:
-- Only read on your own. Opening or editing an issue, posting to a channel, paging someone or any rollback needs a person's approval.
+- Only read on your own; never roll anything back yourself.
 - Say how sure you are. If the evidence is thin, say what would confirm it instead of guessing.
-- Keep the summary short enough to read on a phone.`,
+- Keep the Slack summary short enough to read on a phone.`,
                 exampleMessage: 'Alert: checkout-api error rate 18% (normally under 1%) since 14:05 UTC. Errors: "timeout connecting to payments".',
             },
         },
+        setup: {
+            abilities: ['lp-github', 'lp-slack-notifier'],
+            keys: [...GITHUB_KEYS, ...SLACK_KEYS],
+            rules: [
+                { name: 'template-slack-summary-allowed', tool: 'post_to_slack', decision: 'allow' },
+                { name: 'template-new-issues-need-approval', tool: 'github_create_issue', decision: 'ask' },
+                { name: 'template-comments-need-approval', tool: 'github_comment_issue', decision: 'ask' },
+            ],
+            needsApprovals: true,
+            notes: ['Send it alerts: paste one into Chat, have your alerting tool call it over HTTP, or reply to it in Slack'],
+        },
     },
     {
         id: 'expense-approvals',
         category: 'Finance',
         candidate: {
             title: 'Check expense claims',
-            summary: 'Reads each expense claim and its receipt, checks it against your policy, and routes it: claims within policy are prepared for approval, anything outside policy is flagged with the reason.',
-            trigger: { kind: 'event', description: 'each new expense claim' },
+            summary: 'Checks the claims inbox, reads each claim and its receipt, checks it against your expense policy, and sends the approver a one-line verdict. Replies to claimants wait for your approval.',
+            trigger: { kind: 'schedule', description: 'every 15 minutes, for new claims', every: '15m' },
             hoursPerWeek: 3,
             fit: 7,
             risk: 'high',
-            asksFirst: ['approving a claim', 'paying anything out', 'replying to the claimant'],
+            asksFirst: ['replying to the claimant'],
             needs: [
-                { kind: 'api', name: 'Email', description: 'the inbox or form where claims arrive' },
-                { kind: 'ability', name: 'lp-docs-search', description: 'your expense policy, so checks follow it' },
-                { kind: 'messaging', name: 'Slack', description: 'Slack, so approvers decide in one click' },
+                { kind: 'ability', name: 'lp-gmail', description: 'the inbox where claims arrive' },
+                { kind: 'ability', name: 'lp-docs-search', description: 'your expense policy' },
             ],
             agent: {
                 name: 'expense-approvals',
                 systemPrompt: `You check expense claims against our expense policy.
 
-For each claim:
-1. Read the amount, currency, date, merchant, category and who submitted it, from the claim and its receipt.
-2. Check it against the policy: the category is allowed, it's under the limit, the receipt matches the amount and date, and it isn't a duplicate of an earlier claim.
-3. Write a one-line verdict: "Within policy" or "Outside policy: <reason>", followed by the details you checked.
-4. Send the verdict to the approver. Within-policy claims are prepared for approval; outside-policy ones are flagged.
+When asked to check new claims:
+1. Find them with gmail_search, query "is:unread in:inbox". Read each with gmail_get_thread.
+2. Read the amount, currency, date, merchant, category and who submitted it, from the email and its receipt (the attachment names show whether a receipt is there).
+3. Check it against the expense policy with search_docs: the category is allowed, it's under the limit, the receipt matches the amount and date, and it isn't a duplicate of an earlier claim (search the inbox for the same merchant and amount).
+4. Write a one-line verdict: "Within policy" or "Outside policy: <reason>", then the details you checked.
+5. Email the verdict to the approver at the address in the EXPENSE_APPROVER_EMAIL setting with gmail_send, then mark the claim read with gmail_modify_labels.
 
 Rules:
 - Never approve or pay a claim yourself. A person always decides.
-- If the receipt is missing or unreadable, say so and ask the claimant for it; don't fill in values.
+- If the receipt is missing or unreadable, draft a reply to the claimant asking for it with gmail_create_draft; don't fill in values.
 - If the policy doesn't cover the case, say which part is unclear rather than deciding.`,
-                exampleMessage: 'New claim from Priya: client dinner, Bistro 21, 2026-10-20, $186.40 for 3 people. Receipt attached.',
+                scheduleMessage: 'Check the new expense claims in the inbox.',
+                exampleMessage: 'Check the new expense claims in the inbox.',
             },
         },
+        setup: {
+            abilities: ['lp-gmail', 'lp-docs-search'],
+            keys: [...GMAIL_KEYS],
+            env: { DOCS_SEARCH_PATH: 'docs' },
+            rules: [
+                { name: 'template-read-mail-allowed', tool: 'gmail_search', decision: 'allow' },
+                { name: 'template-read-thread-allowed', tool: 'gmail_get_thread', decision: 'allow' },
+                { name: 'template-drafts-allowed', tool: 'gmail_create_draft', decision: 'allow' },
+                { name: 'template-labels-allowed', tool: 'gmail_modify_labels', decision: 'allow' },
+                { name: 'template-emails-need-approval', tool: 'gmail_send', decision: 'ask' },
+            ],
+            schedule: { every: '15m', name: 'Check for new claims', message: 'Check the new expense claims in the inbox.' },
+            needsApprovals: true,
+            notes: [DOCS_NOTE + ' — especially your expense policy', 'Set EXPENSE_APPROVER_EMAIL (Environment tab) to the approver\'s address'],
+        },
+    },
+    {
+        id: 'lead-follow-up',
+        category: 'Sales',
+        candidate: {
+            title: 'Lead follow-up',
+            summary: 'Every hour, picks up new leads in HubSpot, researches each on the web, and drafts a short, personal first email. Sending and updating the CRM wait for your approval.',
+            trigger: { kind: 'schedule', description: 'every hour, for new leads', every: '1h' },
+            hoursPerWeek: 3,
+            fit: 6,
+            risk: 'medium',
+            asksFirst: ['sending the first email', 'updating the lead'],
+            needs: [
+                { kind: 'ability', name: 'lp-hubspot', description: 'your leads in HubSpot' },
+                { kind: 'ability', name: 'lp-web-search', description: 'researching each lead' },
+                { kind: 'ability', name: 'lp-gmail', description: 'the inbox to send from' },
+            ],
+            agent: {
+                name: 'lead-follow-up',
+                systemPrompt: `You follow up with new leads for our business.
+
+What we sell (edit this):
+- [What your product does, in one sentence]
+- [Who it is for]
+- [The one result customers care about most]
+
+When asked to follow up with new leads:
+1. Find them with hubspot_find_contacts: lead_status "NEW", created_in_last_days 2.
+2. For each, read hubspot_get_contact. Skip anyone with an owner, recent notes, or a last-contacted date: someone is already on it.
+3. Research them with web_search and web_fetch: what their company does, its size, and anything recent that matters (funding, hiring, a launch). Note your sources.
+4. Work out what they most likely need from us, in one sentence.
+5. Send a short first email (under 120 words) with gmail_send: a specific opening based on your research, one sentence on how we help with that need, and one easy question to reply to. A person approves it first.
+6. Log what you sent and found with hubspot_add_note, and set the lead to "ATTEMPTED_TO_CONTACT" with hubspot_update_contact.
+
+Rules:
+- Never invent facts about a lead. If research finds nothing reliable, write a simple, honest email instead.
+- No pressure tactics, fake urgency or discounts you weren't told about.
+- If the lead looks like a competitor, a student or spam, add a note saying so and don't email them.`,
+                scheduleMessage: 'Follow up with the new leads in HubSpot.',
+                exampleMessage: 'Follow up with the new leads in HubSpot.',
+            },
+        },
+        setup: {
+            abilities: ['lp-hubspot', 'lp-web-search', 'lp-gmail'],
+            keys: ['HUBSPOT_ACCESS_TOKEN', ...WEB_SEARCH_KEYS, ...GMAIL_KEYS],
+            rules: [
+                { name: 'template-notes-allowed', tool: 'hubspot_add_note', decision: 'allow' },
+                { name: 'template-lead-updates-need-approval', tool: 'hubspot_update_contact', decision: 'ask' },
+                { name: 'template-no-new-contacts', tool: 'hubspot_create_contact', decision: 'deny' },
+                { name: 'template-emails-need-approval', tool: 'gmail_send', decision: 'ask' },
+            ],
+            schedule: { every: '1h', name: 'Follow up with new leads', message: 'Follow up with the new leads in HubSpot.' },
+            needsApprovals: true,
+            notes: ['Edit "What we sell" at the top of its instructions (Overview tab)'],
+        },
+    },
+    {
+        id: 'inbox-to-tasks',
+        category: 'Operations',
+        candidate: {
+            title: 'Inbox to tasks',
+            summary: 'Checks a shared inbox every 10 minutes and turns each request into a task (a GitHub issue) with an owner and a due date, then tells the sender who is handling it.',
+            trigger: { kind: 'schedule', description: 'every 10 minutes, for new emails', every: '10m' },
+            hoursPerWeek: 3,
+            fit: 7,
+            risk: 'low',
+            asksFirst: ['replying to the sender'],
+            needs: [
+                { kind: 'ability', name: 'lp-gmail', description: 'the shared inbox' },
+                { kind: 'ability', name: 'lp-github', description: 'tasks, as GitHub issues' },
+            ],
+            agent: {
+                name: 'inbox-to-tasks',
+                systemPrompt: `You turn requests in our shared inbox into tasks, kept as GitHub issues.
+
+Who handles what (edit this; GitHub usernames):
+- Billing and invoices: [username]
+- Technical problems: [username]
+- Everything else: [username]
+
+When asked to handle new emails:
+1. Find them with gmail_search, query "is:unread in:inbox". Read each with gmail_get_thread.
+2. Decide whether it's a request someone needs to act on. Newsletters, receipts, out-of-office replies and spam are not: mark them read and move on.
+3. Check whether a task already exists with github_search_issues (the sender and subject). If so, add the new details with github_comment_issue instead.
+4. Otherwise open one with github_create_issue: a short title starting with a verb, a two-line summary, the sender, the due date (the date they asked for, or 2 working days if they didn't say), and the owner from the list above as the assignee.
+5. Reply to the sender with gmail_send (reply_to_message_id set): who is handling it and by when. A person approves it first.
+6. Mark the email read with gmail_modify_labels.
+
+Rules:
+- If an email holds several requests, make one task for each.
+- Never promise a fix or a refund in the reply; only say who is handling it and by when.`,
+                scheduleMessage: 'Turn the new emails in the shared inbox into tasks.',
+                exampleMessage: 'Turn the new emails in the shared inbox into tasks.',
+            },
+        },
+        setup: {
+            abilities: ['lp-gmail', 'lp-github'],
+            keys: [...GMAIL_KEYS, ...GITHUB_KEYS],
+            rules: [
+                { name: 'template-read-mail-allowed', tool: 'gmail_search', decision: 'allow' },
+                { name: 'template-read-thread-allowed', tool: 'gmail_get_thread', decision: 'allow' },
+                { name: 'template-labels-allowed', tool: 'gmail_modify_labels', decision: 'allow' },
+                { name: 'template-tasks-allowed', tool: 'github_create_issue', decision: 'allow' },
+                { name: 'template-task-updates-allowed', tool: 'github_comment_issue', decision: 'allow' },
+                { name: 'template-replies-need-approval', tool: 'gmail_send', decision: 'ask' },
+            ],
+            schedule: { every: '10m', name: 'Check the shared inbox', message: 'Turn the new emails in the shared inbox into tasks.' },
+            needsApprovals: true,
+            notes: ['Edit "Who handles what" at the top of its instructions (Overview tab)', 'Point GITHUB_DEFAULT_REPO at the repository your team keeps tasks in'],
+        },
     },
     {
         id: 'weekly-research-digest',
         category: 'Research',
         candidate: {
             title: 'Weekly research digest',
-            summary: 'Once a week, searches the web for news on the topics you choose and writes a short digest with links.',
-            trigger: { kind: 'schedule', description: 'once a week', every: '7d' },
+            summary: 'Every Monday morning, searches the web for news on the topics you choose and posts a short digest with links to Slack.',
+            trigger: { kind: 'schedule', description: 'Mondays at 9:00', every: '7d' },
             hoursPerWeek: 2,
             fit: 6,
             risk: 'low',
-            asksFirst: ['sending the digest to anyone'],
+            asksFirst: [],
             needs: [
                 { kind: 'ability', name: 'lp-web-search', description: 'web search' },
-                { kind: 'key', name: 'TAVILY_API_KEY', description: 'a web search key (Tavily, Brave or Firecrawl)' },
+                { kind: 'ability', name: 'lp-slack-notifier', description: 'posting the digest to Slack' },
             ],
             agent: {
                 name: 'weekly-research-digest',
-                systemPrompt: `You write a weekly research digest.
+                systemPrompt: `You write a weekly research digest and post it to Slack.
 
 Topics to follow (edit this list):
 - [Your industry or market]
@@ -126,21 +347,42 @@ Topics to follow (edit this list):
 - [Technologies or regulations you care about]
 
 Each week:
-1. Search the web for what happened in the last 7 days on each topic.
-2. Open the most relevant pages and read them; don't rely on search snippets.
+1. Search the web with web_search for what happened in the last 7 days on each topic.
+2. Open the most relevant pages with web_fetch and read them; don't rely on search snippets.
 3. Write the digest: for each topic, up to three items, each with a one-sentence summary, why it matters to us, and the link.
 4. End with "Worth a closer look": the single most important item, and why.
+5. Post it with post_to_slack.
 
 Rules:
 - Only include things published in the last 7 days, and give each item's date.
 - Prefer original sources over aggregators. Never invent a link.
 - If a topic had no real news, say so in one line.`,
-                scheduleMessage: 'Write this week\'s research digest.',
-                exampleMessage: 'Write this week\'s research digest.',
+                scheduleMessage: 'Write and post this week\'s research digest.',
+                exampleMessage: 'Write and post this week\'s research digest.',
             },
         },
+        setup: {
+            abilities: ['lp-web-search', 'lp-slack-notifier'],
+            keys: [...WEB_SEARCH_KEYS, ...SLACK_KEYS],
+            rules: [
+                { name: 'template-search-allowed', tool: 'web_search', decision: 'allow' },
+                { name: 'template-fetch-allowed', tool: 'web_fetch', decision: 'allow' },
+                { name: 'template-digest-post-allowed', tool: 'post_to_slack', decision: 'allow' },
+            ],
+            schedule: { every: '7d', at: '09:00', weekday: 1, name: 'Weekly research digest', message: 'Write and post this week\'s research digest.' },
+            needsApprovals: false,
+            notes: ['Edit "Topics to follow" at the top of its instructions (Overview tab)'],
+        },
     },
 ];
 export function starterTemplate(id) {
     return STARTER_TEMPLATES.find((t) => t.id === id);
 }
+/** The first run of a template's schedule: its time of day (and weekday)
+ * next, in the workspace's time zone; undefined when it has none. */
+export function templateScheduleStart(schedule, nowMs = Date.now(), timeZone = workspaceTimeZone()) {
+    const at = schedule.at ? parseTimeOfDay(schedule.at) : undefined;
+    if (!at)
+        return undefined;
+    return new Date(nextTimeOfDay(at, nowMs, timeZone, schedule.weekday)).toISOString();
+}

package/dist/core/system-tools/schedule.js

@@ -1,4 +1,5 @@
 import { cancelScheduledTask, createScheduledTask, getScheduledTask, listScheduledTasks, } from '../scheduler.js';
+import { formatWallTime, workspaceTimeZone } from '../time-zone.js';
 /** How many active (not done or cancelled) tasks one agent may create
  * through these tools — each run is a model call, so a runaway loop of
  * "schedule another one" stops here. The console and API aren't capped. */
@@ -6,7 +7,12 @@ function maxActivePerAgent() {
     const n = Number(process.env.LOOPENGINE_SCHEDULER_MAX_PER_AGENT);
     return Number.isInteger(n) && n > 0 ? n : 25;
 }
-function summary(t) {
+/** next_run_at as the workspace's wall-clock time, so the model can
+ * confirm "tomorrow at 9:00" without converting from UTC. */
+function nextRunLocal(t, timeZone) {
+    return t.next_run_at ? `${formatWallTime(Date.parse(t.next_run_at), timeZone)} (${timeZone})` : undefined;
+}
+function summary(t, timeZone) {
     return {
         task_id: t.task_id,
         task_name: t.task_name,
@@ -14,11 +20,15 @@ function summary(t) {
         schedule: t.schedule,
         status: t.status,
         next_run_at: t.next_run_at,
+        next_run_local: nextRunLocal(t, timeZone),
         run_count: t.run_count,
         last_status: t.last_status,
     };
 }
 export function createScheduleTools(agentName) {
+    // Read once per run: the time zone is in the tool description, which
+    // should stay the same from call to call.
+    const timeZone = workspaceTimeZone();
     async function ownTask(taskId, tool) {
         const task = await getScheduledTask(taskId);
         // Another agent's task reads exactly like a missing one.
@@ -28,7 +38,7 @@ export function createScheduleTools(agentName) {
     }
     const scheduleTask = {
         name: 'system_schedule_task',
-        description: 'Schedule a message to yourself for later — once at a set time, or repeatedly on an interval — like setting a reminder or a cron job. When it fires you receive the message as a new conversation (none of the current one carries over, so make the message self-contained) and handle it with your tools as usual, with no person live. A tool call that needs approval goes wherever your approval requests are sent and waits; if nowhere is set, it is denied. Use only when the user asks for something to happen later or regularly, never on your own initiative. Use the user\'s time zone (ask if unclear), prefer the longest interval that serves them since each run is a model call, and confirm the schedule back in plain words. Returns task_id and next_run_at.',
+        description: 'Schedule a message to yourself for later — once at a set time, or repeatedly on an interval — like setting a reminder or a cron job. When it fires you receive the message as a new conversation (none of the current one carries over, so make the message self-contained) and handle it with your tools as usual, with no person live. A tool call that needs approval goes wherever your approval requests are sent and waits; if nowhere is set, it is denied. Use only when the user asks for something to happen later or regularly, never on your own initiative. Times are in this workspace\'s time zone, ' + timeZone + ', unless you give an offset, so when the user means another time zone, give its offset. Prefer the longest interval that serves them since each run is a model call, and confirm the schedule back in plain words. Returns task_id, next_run_at and next_run_local (the workspace\'s time).',
         input_schema: {
             type: 'object',
             properties: {
@@ -38,8 +48,8 @@ export function createScheduleTools(agentName) {
                 },
                 schedule: {
                     type: 'object',
-                    description: 'Either { "run_at": "<ISO 8601 timestamp with time zone>" } for once, or { "every": "<interval>" } to repeat until cancelled — a number plus s/m/h/d, e.g. "30m", "1h", "1d"; 30s at the shortest. A repeating task keeps its first slot: started at 10:07 with "1h", it fires at 11:07, 12:07, ...',
-                    properties: { run_at: { type: 'string' }, every: { type: 'string' } },
+                    description: 'Either { "run_at": "<ISO 8601 timestamp>" } for once, or { "every": "<interval>", ... } to repeat until cancelled — a number plus s/m/h/d, e.g. "30m", "1h", "1d"; 30s at the shortest. A timestamp without an offset, like "2026-11-02T09:00", is in the workspace\'s time zone (' + timeZone + '). A repeating task keeps its first slot: started at 10:07 with "1h", it fires at 11:07, 12:07, ... For a time of day or day of week, add "at" (24-hour "HH:MM") and for weekly "weekday": "every day at 9am" is { "every": "1d", "at": "09:00" }; "every Monday at 9am" is { "every": "7d", "at": "09:00", "weekday": "monday" }. Daily and weekly tasks keep their time of day when the clocks change. Or give "start_at", a timestamp, for the first run.',
+                    properties: { run_at: { type: 'string' }, every: { type: 'string' }, at: { type: 'string' }, weekday: { type: 'string' }, start_at: { type: 'string' } },
                 },
                 task_name: { type: 'string', description: 'Optional short label, shown when listing tasks and in the console.' },
                 notify: { type: 'boolean', description: 'Optional — also send each run\'s result through your notifier (where your approval requests go), so a person sees it.' },
@@ -58,7 +68,7 @@ export function createScheduleTools(agentName) {
                 task_name: typeof input.task_name === 'string' ? input.task_name : undefined,
                 notify: input.notify === true,
             });
-            return JSON.stringify({ task_id: task.task_id, next_run_at: task.next_run_at, schedule: task.schedule });
+            return JSON.stringify({ task_id: task.task_id, next_run_at: task.next_run_at, next_run_local: nextRunLocal(task, timeZone), schedule: task.schedule });
         },
     };
     const listTasks = {
@@ -76,7 +86,7 @@ export function createScheduleTools(agentName) {
         },
         execute: async (input) => {
             const status = typeof input.status === 'string' ? input.status : undefined;
-            return JSON.stringify((await listScheduledTasks({ agent: agentName, status })).map(summary));
+            return JSON.stringify((await listScheduledTasks({ agent: agentName, status })).map((t) => summary(t, timeZone)));
         },
         safe: true,
     };

package/dist/core/time-zone.d.ts

@@ -0,0 +1,40 @@
+export declare const TIME_ZONE_ENV = "LOOPENGINE_TIME_ZONE";
+export interface WallTime {
+    year: number;
+    /** 1–12 */
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+}
+export declare function isValidTimeZone(timeZone: unknown): timeZone is string;
+/** The server's own time zone. */
+export declare function serverTimeZone(): string;
+/** The workspace's time zone: LOOPENGINE_TIME_ZONE when it's a real one,
+ * else the server's. */
+export declare function workspaceTimeZone(): string;
+/** Every time zone this server knows, for the console's picker. */
+export declare function listTimeZones(): string[];
+/** The wall-clock time (and weekday, 0 = Sunday) at `ms` in `timeZone`. */
+export declare function wallTimeAt(ms: number, timeZone: string): WallTime & {
+    weekday: number;
+};
+/** The instant a wall-clock time in `timeZone` happens. Fields may
+ * overflow (day 32, hour 25), as with Date.UTC. */
+export declare function instantOf(t: WallTime, timeZone: string): number;
+/** An ISO 8601 timestamp as ms. One with a "Z" or an offset is exact;
+ * one without ("2026-11-02T09:00") is a wall-clock time in `timeZone`.
+ * NaN when it isn't a timestamp. */
+export declare function parseTimestamp(value: string, timeZone: string): number;
+/** "09:00" as [hours, minutes], or undefined when it isn't a time. */
+export declare function parseTimeOfDay(value: string): [number, number] | undefined;
+/** The next time it's `at` ("09:00") in `timeZone`, strictly after
+ * `nowMs`, on `weekday` (0 = Sunday) when given. */
+export declare function nextTimeOfDay(at: [number, number], nowMs: number, timeZone: string, weekday?: number): number;
+/** `ms` moved by whole calendar days in `timeZone`, keeping its time of
+ * day across a daylight-saving change. */
+export declare function addCalendarDays(ms: number, days: number, timeZone: string): number;
+/** `ms` as "2026-11-02 09:00" in `timeZone`, for tool results the model
+ * reads back to a person. */
+export declare function formatWallTime(ms: number, timeZone: string): string;