update prompt controller and loader to use new prompt files

Reviewed-on: kjannette/deClawed-Assity-Kitty#4

.gitignore

@@ -5,6 +5,7 @@ build/
 accountsAndCredentials/credentials.json
 accountsAndCredentials/accounts.json
 accountsAndCredentials/token*.json
+accountsAndCredentials/token.json.bak
 !accountsAndCredentials/*.example.json
 
 # Runtime output

package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.26.0",
+        "@modelcontextprotocol/sdk": "^1.30.0",
         "googleapis": "^171.4.0",
         "zod": "^3.25.76"
       },
@@ -501,12 +501,12 @@
       "license": "MIT"
     },
     "node_modules/@modelcontextprotocol/sdk": {
-      "version": "1.26.0",
+      "version": "1.30.0",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.26.0.tgz",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.30.0.tgz",
-      "integrity": "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg==",
+      "integrity": "sha512-xKd8OIzlqNzcqcNumGAa6g+PW2kjD5vrpcKOnfldAUPP3j7lnqMPwlTXQm8gF+UwH72z0lqaRbjr9hqGz0eITA==",
       "license": "MIT",
       "dependencies": {
-        "@hono/node-server": "^1.19.9",
+        "@hono/node-server": "^1.19.9 || ^2.0.5",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "content-type": "^1.0.5",

package.json

@@ -19,7 +19,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "googleapis": "^171.4.0",
     "zod": "^3.25.76"
   },

src/loaders/prompt-config-loaders.ts

@@ -3,11 +3,13 @@ import { google, gmail_v1, sheets_v4, calendar_v3 } from "googleapis";
 import { OAuth2Client } from "google-auth-library";
 import fs from "fs";
 import path from "path";
-
+import { fileURLToPath } from "url";
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 export const PROJECT_ROOT = path.resolve(__dirname, "..", "..");
 const SECRETS_DIR = path.join(PROJECT_ROOT, "accountsAndCredentials");
 const CREDENTIALS_PATH = path.join(SECRETS_DIR, "credentials.json");
@@ -20,130 +22,130 @@ const ACTION_PROMPT_PATH = path.join(PROMPTS_DIR, "take-action-on-emails.txt");
 // Account configuration
 // ---------------------------------------------------------------------------
 export interface AccountConfig {
-  label: string;
+    label: string;
-  tokenFile: string;
+    tokenFile: string;
-  spreadsheetId?: string;
+    spreadsheetId?: string;
-  calendarId?: string;
+    calendarId?: string;
 }
 
 export interface AccountsMap {
-  [key: string]: AccountConfig;
+    [key: string]: AccountConfig;
 }
 
 export const loadAccounts = (): AccountsMap => {
-  if (!fs.existsSync(ACCOUNTS_PATH)) {
+    if (!fs.existsSync(ACCOUNTS_PATH)) {
-    throw new Error(`Missing accounts.json at ${ACCOUNTS_PATH}.`);
+        throw new Error(`Missing accounts.json at ${ACCOUNTS_PATH}.`);
-  }
+    }
-  return JSON.parse(fs.readFileSync(ACCOUNTS_PATH, "utf-8"));
+    return JSON.parse(fs.readFileSync(ACCOUNTS_PATH, "utf-8"));
 };
 
 export const getTokenPath = (account: string): string => {
-  const accts = loadAccounts();
+    const accts = loadAccounts();
-  const acct = accts[account];
+    const acct = accts[account];
-  if (!acct) {
+    if (!acct) {
-    const available = Object.keys(accts).join(", ");
+        const available = Object.keys(accts).join(", ");
-    throw new Error(
+        throw new Error(
-      `Unknown account "${account}". Available accounts: ${available}`
+            `Unknown account "${account}". Available accounts: ${available}`
-    );
+        );
-  }
+    }
-  return path.join(SECRETS_DIR, acct.tokenFile);
+    return path.join(SECRETS_DIR, acct.tokenFile);
 };
 
 export const getSummaryPath = (account: string): string => {
-  if (account === "work") {
+    if (account === "work") {
-    return path.join(PROJECT_ROOT, "mailSummaries", "summary.json");
+        return path.join(PROJECT_ROOT, "mailSummaries", "summary.json");
-  }
+    }
-  return path.join(PROJECT_ROOT, "mailSummaries", `summary-${account}.json`);
+    return path.join(PROJECT_ROOT, "mailSummaries", `summary-${account}.json`);
 };
 
 export const VALID_ACCOUNTS = ["work", "secondary"] as const;
 export const accounts = loadAccounts();
 
 const accountDescription = VALID_ACCOUNTS
-  .map((key) => `"${key}" (${accounts[key]?.label ?? key})`)
+    .map((key) => `"${key}" (${accounts[key]?.label ?? key})`)
-  .join(" or ");
+    .join(" or ");
 
 export const accountSchema = z
-  .enum(VALID_ACCOUNTS)
+    .enum(VALID_ACCOUNTS)
-  .describe(`Which email account to use: ${accountDescription}`);
+    .describe(`Which email account to use: ${accountDescription}`);
 
 // ---------------------------------------------------------------------------
 // Prompt loaders
 // ---------------------------------------------------------------------------
 const loadPromptFile = (filePath: string, label: string): string => {
-  if (!fs.existsSync(filePath)) {
+    if (!fs.existsSync(filePath)) {
-    console.error(`Warning: ${filePath} not found. ${label} will be missing.`);
+        console.error(`Warning: ${filePath} not found. ${label} will be missing.`);
-    return "";
+        return "";
-  }
+    }
-  return fs.readFileSync(filePath, "utf-8");
+    return fs.readFileSync(filePath, "utf-8");
 };
 
 export const loadClassificationPrompt = (): string =>
-  loadPromptFile(CLASSIFY_PROMPT_PATH, "Classification instructions");
+    loadPromptFile(CLASSIFY_PROMPT_PATH, "Classification instructions");
 
 export const loadActionPrompt = (): string =>
-  loadPromptFile(ACTION_PROMPT_PATH, "Action instructions");
+    loadPromptFile(ACTION_PROMPT_PATH, "Action instructions");
 
 // ---------------------------------------------------------------------------
 // Auth helpers — generic OAuth2 client, then service-specific factories
 // ---------------------------------------------------------------------------
 export const getOAuth2Client = (account: string): OAuth2Client => {
-  const tokenPath = getTokenPath(account);
+    const tokenPath = getTokenPath(account);
 
-  if (!fs.existsSync(CREDENTIALS_PATH)) {
+    if (!fs.existsSync(CREDENTIALS_PATH)) {
-    throw new Error(
+        throw new Error(
-      `Missing credentials.json at ${CREDENTIALS_PATH}. Run "npm run auth" first.`
+            `Missing credentials.json at ${CREDENTIALS_PATH}. Run "npm run auth" first.`
+        );
+    }
+    if (!fs.existsSync(tokenPath)) {
+        throw new Error(
+            `Missing token file at ${tokenPath} for account "${account}". Run "npm run auth" first.`
+        );
+    }
+
+    const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    const { client_id, client_secret, redirect_uris } =
+        credentials.installed || credentials.web;
+
+    const oAuth2Client = new google.auth.OAuth2(
+        client_id,
+        client_secret,
+        redirect_uris[0]
     );
-  }
-  if (!fs.existsSync(tokenPath)) {
-    throw new Error(
-      `Missing token file at ${tokenPath} for account "${account}". Run "npm run auth" first.`
-    );
-  }
 
-  const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    const token = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
-  const { client_id, client_secret, redirect_uris } =
+    oAuth2Client.setCredentials(token);
-    credentials.installed || credentials.web;
 
-  const oAuth2Client = new google.auth.OAuth2(
+    oAuth2Client.on("tokens", (newTokens) => {
-    client_id,
+        const current = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
-    client_secret,
+        fs.writeFileSync(
-    redirect_uris[0]
+            tokenPath,
-  );
+            JSON.stringify({ ...current, ...newTokens }, null, 2)
+        );
+        console.error(`Token refreshed and saved for account "${account}".`);
+    });
 
-  const token = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+    return oAuth2Client;
-  oAuth2Client.setCredentials(token);
-
-  oAuth2Client.on("tokens", (newTokens) => {
-    const current = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
-    fs.writeFileSync(
-      tokenPath,
-      JSON.stringify({ ...current, ...newTokens }, null, 2)
-    );
-    console.error(`Token refreshed and saved for account "${account}".`);
-  });
-
-  return oAuth2Client;
 };
 
 export const getGmailClient = (account: string): gmail_v1.Gmail =>
-  google.gmail({ version: "v1", auth: getOAuth2Client(account) });
+    google.gmail({ version: "v1", auth: getOAuth2Client(account) });
 
 export const getSheetsClient = (account: string): sheets_v4.Sheets =>
-  google.sheets({ version: "v4", auth: getOAuth2Client(account) });
+    google.sheets({ version: "v4", auth: getOAuth2Client(account) });
 
 export const getCalendarClient = (account: string): calendar_v3.Calendar =>
-  google.calendar({ version: "v3", auth: getOAuth2Client(account) });
+    google.calendar({ version: "v3", auth: getOAuth2Client(account) });
 
 export const getSpreadsheetId = (account: string): string => {
-  const acct = accounts[account];
+    const acct = accounts[account];
-  if (!acct?.spreadsheetId || acct.spreadsheetId === "PASTE_YOUR_SHEET_ID_HERE") {
+    if (!acct?.spreadsheetId || acct.spreadsheetId === "PASTE_YOUR_SHEET_ID_HERE") {
-    throw new Error(
+        throw new Error(
-      `No spreadsheetId configured for account "${account}" in accounts.json.`
+            `No spreadsheetId configured for account "${account}" in accounts.json.`
-    );
+        );
-  }
+    }
-  return acct.spreadsheetId;
+    return acct.spreadsheetId;
 };
 
 export const getCalendarId = (account: string): string =>
-  accounts[account]?.calendarId ?? "primary";
+    accounts[account]?.calendarId ?? "primary";

src/prompt-controller-service/prompt-controller-service.ts

@@ -1,64 +1,56 @@
 import { server } from "../McpServer.js";
 import {
-  accounts,
+    accounts,
-  loadClassificationPrompt,
+    loadClassificationPrompt,
-  loadActionPrompt,
+    loadActionPrompt,
 } from "../loaders/prompt-config-loaders.js";
 
 // ---------------------------------------------------------------------------
-// Prompt: review_emails (work account)
+// Prompt: Classify Emails (Phase 1)
 // ---------------------------------------------------------------------------
 server.registerPrompt(
-  "review_emails",
+    "classify-emails",
-  {
+    {
-    description:
+        description: "Phase 1: Organize, prioritize, and summarize incoming recruiter emails.",
-      `Review WORK inbox (${accounts.work?.label ?? "work"}): classify emails, delete A+C, summarize B+D, log B to spreadsheet, create calendar events.`,
+    },
-  },
+    () => {
-  () => {
+        const phase1 = loadClassificationPrompt();
-    const phase1 = loadClassificationPrompt();
+        return {
-    const phase2 = loadActionPrompt();
+            messages: [
-    return {
+                {
-      messages: [
+                    role: "user" as const,
-        {
+                    content: {
-          role: "user" as const,
+                        type: "text" as const,
-          content: {
+                        text: `ACCOUNT: Use account = "work" for ALL tool calls in this session.\n\n` +
-            type: "text" as const,
+                            (phase1 || "Review my new emails and classify them by job application category.")
-            text:
+                    },
-              `ACCOUNT: Use account = "work" for ALL tool calls in this session.\n\n` +
+                },
-              (phase1 || "Review my new emails and classify them by job application category.") +
+            ],
-              (phase2 ? `\n\n${phase2}` : ""),
+        };
-          },
+    }
-        },
-      ],
-    };
-  }
 );
 
 // ---------------------------------------------------------------------------
-// Prompt: review_secondary_emails (secondary account)
+// Prompt: Take Action on Emails (Phase 2)
 // ---------------------------------------------------------------------------
 server.registerPrompt(
-  "review_secondary_emails",
+    "take-action-on-emails",
-  {
+    {
-    description:
+        description: "Phase 2: Log Category B recruiters to spreadsheet and create calendar events.",
-      `Review SECONDARY inbox (${accounts.secondary?.label ?? "secondary"}): classify emails, delete A+C, summarize B+D, log B to spreadsheet, create calendar events.`,
+    },
-  },
+    () => {
-  () => {
+        const phase2 = loadActionPrompt();
-    const phase1 = loadClassificationPrompt();
+        return {
-    const phase2 = loadActionPrompt();
+            messages: [
-    return {
+                {
-      messages: [
+                    role: "user" as const,
-        {
+                    content: {
-          role: "user" as const,
+                        type: "text" as const,
-          content: {
+                        text: `ACCOUNT: Use account = "work" for ALL tool calls in this session.\n\n` +
-            type: "text" as const,
+                            (phase2 || "Process remaining action items for flagged recruiters.")
-            text:
+                    },
-              `ACCOUNT: Use account = "secondary" for ALL tool calls in this session.\n\n` +
+                },
-              (phase1 || "Review my new emails and classify them by job application category.") +
+            ],
-              (phase2 ? `\n\n${phase2}` : ""),
+        };
-          },
+    }
-        },
-      ],
-    };
-  }
 );

src/prompts/classify-emails.txt

@@ -1,14 +1,11 @@
-You are an expert Executive Assistant AI specialized in email management and productivity. Your goal is to organize, prioritize, and summarize incoming emails to maximize user efficiency.
+You are an expert Executive Assistant AI specialized in email management and productivity. Your goal is to organize, prioritize, and summarize incoming emails to maximize user efficiency. I have been applying for jobs, which generates a large volume of responses. 
 
-I have been applying for jobs, which generates a large volume of responses. 
+Review the first 200 emails in my inbox. Apply the following instructions to those emails.
-
-Review, in reverse chronoloical order, the first 150 emails in my inbox. Apply the following instructions to those emails.
 
 STEP 1: Constraints
 - Do not make up information.
 
 STEP 2: CLASSIFY each email into exactly one category.
-
 Category A - Acknowledgement Only
 The employer confirms receipt of my application but requires no action from me. Typical language: "We received your application," "Your application is under review," "We will contact you if selected." No next steps are requested.
 
@@ -21,13 +18,15 @@ The employer declines to move forward. Typical language: "We have decided to pur
 Category D - Other
 The email does not fit into categories A, B, or C. This includes non-job-application emails, newsletters, promotional content, or ambiguous messages that do not clearly match another category.
 
-STEP 3: DELETE emails classified as Category A and Category C.
+STEP 3: STAR REVIEWED EMAILS
+- For EVERY single email processed and reviewed in this run (Categories A, B, C, and D), apply the Gmail "STARRED" system label or use your email tool to add a star to the message. 
 
-STEP 4: ("Anti step") -  NEVER DELETE Category B emails.
+STEP 4: Confirm, via natural language output in the chat window, the total number of emails fetched for review and successfully starred.
 
-STEP 5: SUMMARIZE emails classified as Category B and Category D. For each, include:
+STEP 5: SUMMARIZE emails classified as Category B and Category D.
+For each, state:
 1. Sender name and email address
 2. Email subject line
 3. Date and time received
 4. Category (B or D)
-5. Suggested action I should take
+5. Suggested action I should take

src/prompts/take-action-on-emails.txt

@@ -1,12 +1,9 @@
 PHASE 2: TAKE ACTION ON CATEGORY B EMAILS
-
 After completing classification (Phase 1), perform the following actions for each email classified as Category B (Advancement to Next Step).
 
 STEP 1: LOG TO SPREADSHEET
 For each Category B email, extract as much of the following information as possible from the email contents and log it using the log_recruiter_contact tool:
-
 A column exists for:
-
 - Recruiter Name
 - Recruiter Email
 - Recruiter Phone/Tel
@@ -15,7 +12,7 @@ A column exists for:
 - Subsequent Contacts: any follow-up communication with this recruiter about this role
 - Recruiter Call Scheduled: if the email contains scheduling information, extract ALL details — date, time, platform (Zoom, MS Teams, Google Meet, etc.), meeting link, phone number to call — and note whether they confirm having your cell number or might not have it
 
-A row should already exists for the same recruiter email + company/role combination (from a previous email), the tool will UPDATE the existing row. Provide all available fields and the tool handles merging.
+If a row already exists for the same recruiter email + company/role combination (from a previous email), the tool will UPDATE the existing row. Provide all available fields and the tool handles merging.
 
 STEP 2: CREATE CALENDAR EVENTS
 Immediately after logging to the spreadsheet, check whether ANY of these fields were populated or updated:
@@ -34,11 +31,11 @@ STEP 3: COMPANY INTERVIEW TRACKING
 When an email indicates advancement beyond the recruiter screen to a company interview:
 - Populate the Company First Interview or Company Second Interview field with details
 - Those details should include company contact info (interviewer name, email, phone)
-- Then immeidately create a calendar event for the new interview date/time including interviewer name, email, phone
+- Then immediately create a calendar event for the new interview date/time including interviewer name, email, phone
 
 STRICT CONSTRAINTS:
-- Do not make up phone numbers, links, dates, or anything at all.  If it does not exist in text wihtin a verifiable email, IT DOES NOT EXIST.
+- Do not make up phone numbers, links, dates, or anything at all. If it does not exist in text within a verifiable email, IT DOES NOT EXIST.
-- PAST-DATE CHECK: Before creating a calendar event. 1) verify today's date from an external, reliable source; 2) compare the proposed meeting date/time against today's date; 3) iIf the meeting date has already passed, do NOT create a calendar event for it. Still log it to the spreadsheet, but skip the calendar step. The tool will also enforce this server-side.
+- PAST-DATE CHECK: Before creating a calendar event: 1) verify today's date from an external, reliable source; 2) compare the proposed meeting date/time against today's date; 3) if the meeting date has already passed, do NOT create a calendar event for it. Still log it to the spreadsheet, but skip the calendar step. The tool will also enforce this server-side.
 - As described in more detail below, each new date/time value in a scheduling column = one new calendar event. Never skip this.
 - Always use the same account for calendar events as was used for email fetching.
 - Do not create duplicate calendar events for the same meeting (same company representative && same job description | same company && same date time)

src/tools/tools-email.ts

@@ -3,303 +3,358 @@ import { gmail_v1 } from "googleapis";
 import fs from "fs";
 import { server } from "../McpServer.js";
 import {
-  accountSchema,
+    accountSchema,
-  getGmailClient,
+    getGmailClient,
-  getSummaryPath,
+    getSummaryPath,
-  loadClassificationPrompt,
+    loadClassificationPrompt,
-  loadActionPrompt,
+    loadActionPrompt,
 } from "../loaders/prompt-config-loaders.js";
 
 // ---------------------------------------------------------------------------
 // Email parsing helpers
 // ---------------------------------------------------------------------------
 export const getHeader = (
-  headers: gmail_v1.Schema$MessagePartHeader[] | undefined,
+    headers: gmail_v1.Schema$MessagePartHeader[] | undefined,
-  name: string
+    name: string
 ): string => {
-  if (!headers) return "";
+    if (!headers) return "";
-  const header = headers.find(
+    const header = headers.find(
-    (h) => h.name?.toLowerCase() === name.toLowerCase()
+        (h) => h.name?.toLowerCase() === name.toLowerCase()
-  );
+    );
-  return header?.value ?? "";
+    return header?.value ?? "";
 };
 
 export const decodeBody = (message: gmail_v1.Schema$Message): string => {
-  const parts = message.payload?.parts;
+    const parts = message.payload?.parts;
-  let encoded = "";
+    let encoded = "";
 
-  if (parts) {
+    if (parts) {
-    const textPart = parts.find((p) => p.mimeType === "text/plain");
+        const textPart = parts.find((p) => p.mimeType === "text/plain");
-    encoded = textPart?.body?.data ?? "";
+        encoded = textPart?.body?.data ?? "";
+
+        if (!encoded) {
+            const htmlPart = parts.find((p) => p.mimeType === "text/html");
+            encoded = htmlPart?.body?.data ?? "";
+        }
+    } else {
+        encoded = message.payload?.body?.data ?? "";
+    }
 
     if (!encoded) {
-      const htmlPart = parts.find((p) => p.mimeType === "text/html");
+        return message.snippet ?? "";
-      encoded = htmlPart?.body?.data ?? "";
     }
-  } else {
-    encoded = message.payload?.body?.data ?? "";
-  }
 
-  if (!encoded) {
+    return Buffer.from(encoded, "base64url").toString("utf-8");
-    return message.snippet ?? "";
-  }
-
-  return Buffer.from(encoded, "base64url").toString("utf-8");
 };
 
 // ---------------------------------------------------------------------------
 // Tool: fetch_new_emails
 // ---------------------------------------------------------------------------
 server.registerTool(
-  "fetch_new_emails",
+    "fetch_new_emails",
-  {
+    {
-    description:
+        description:
-      "Fetch unread emails from a Gmail inbox. Returns sender, date, " +
+            "Fetch unread emails from a Gmail inbox. Returns sender, date, " +
-      "subject, message ID, and body text for each message. The message IDs " +
+            "subject, message ID, and body text for each message. The message IDs " +
-      "can be passed to delete_emails later. Specify which account to fetch from.",
+            "must be passed to star_emails after evaluation. Specify which account to fetch from.",
-    inputSchema: {
+        inputSchema: {
-      account: accountSchema,
+            account: accountSchema,
-      maxResults: z
+            maxResults: z
-        .number()
+                .number()
-        .min(1)
+                .min(1)
-        .max(100)
+                .max(200)
-        .describe("Maximum number of unread emails to fetch (1-100)"),
+                .describe("Maximum number of unread emails to fetch (1-200)"),
+        },
     },
-  },
+    async ({ account, maxResults }) => {
-  async ({ account, maxResults }) => {
+        try {
-    try {
+            const gmail = getGmailClient(account);
-      const gmail = getGmailClient(account);
 
-      const listResponse = await gmail.users.messages.list({
+            const listResponse = await gmail.users.messages.list({
-        userId: "me",
+                userId: "me",
-        q: "is:unread",
+                q: "is:unread",
-        maxResults,
+                maxResults,
-      });
+            });
 
-      const messageIds = listResponse.data.messages ?? [];
+            const messageIds = listResponse.data.messages ?? [];
 
-      if (messageIds.length === 0) {
+            if (messageIds.length === 0) {
-        return {
+                return {
-          content: [{ type: "text" as const, text: "No unread emails found." }],
+                    content: [{ type: "text" as const, text: "No unread emails found." }],
-        };
+                };
-      }
+            }
 
-      const emails: string[] = [];
+            const emails: string[] = [];
 
-      for (const msg of messageIds) {
+            for (const msg of messageIds) {
-        const detail = await gmail.users.messages.get({
+                const detail = await gmail.users.messages.get({
-          userId: "me",
+                    userId: "me",
-          id: msg.id!,
+                    id: msg.id!,
-          format: "full",
+                    format: "full",
-        });
+                });
 
-        const headers = detail.data.payload?.headers;
+                const headers = detail.data.payload?.headers;
-        const from = getHeader(headers, "From");
+                const from = getHeader(headers, "From");
-        const subject = getHeader(headers, "Subject");
+                const subject = getHeader(headers, "Subject");
-        const date = getHeader(headers, "Date");
+                const date = getHeader(headers, "Date");
-        const body = decodeBody(detail.data);
+                const body = decodeBody(detail.data);
 
-        const truncatedBody =
+                const truncatedBody =
-          body.length > 2000 ? body.substring(0, 2000) + "\n[...truncated]" : body;
+                    body.length > 2000 ? body.substring(0, 2000) + "\n[...truncated]" : body;
 
-        emails.push(
+                emails.push(
-          [
+                    [
-            `MESSAGE_ID: ${msg.id}`,
+                        `MESSAGE_ID: ${msg.id}`,
-            `FROM: ${from}`,
+                        `FROM: ${from}`,
-            `DATE: ${date}`,
+                        `DATE: ${date}`,
-            `SUBJECT: ${subject}`,
+                        `SUBJECT: ${subject}`,
-            `BODY:\n${truncatedBody}`,
+                        `BODY:\n${truncatedBody}`,
-          ].join("\n")
+                    ].join("\n")
-        );
+                );
-      }
+            }
 
-      const classificationInstructions = loadClassificationPrompt();
+            const classificationInstructions = loadClassificationPrompt();
-      const actionInstructions = loadActionPrompt();
+            const actionInstructions = loadActionPrompt();
-      const instructionsBlock =
+            const instructionsBlock =
-        (classificationInstructions
+                (classificationInstructions
-          ? `\n\n${"=".repeat(60)}\nCLASSIFICATION INSTRUCTIONS (PHASE 1):\n${"=".repeat(60)}\n${classificationInstructions}`
+                    ? `\n\n${"=".repeat(60)}\nCLASSIFICATION INSTRUCTIONS (PHASE 1):\n${"=".repeat(60)}\n${classificationInstructions}`
-          : "") +
+                    : "") +
-        (actionInstructions
+                (actionInstructions
-          ? `\n\n${"=".repeat(60)}\nACTION INSTRUCTIONS (PHASE 2):\n${"=".repeat(60)}\n${actionInstructions}`
+                    ? `\n\n${"=".repeat(60)}\nACTION INSTRUCTIONS (PHASE 2):\n${"=".repeat(60)}\n${actionInstructions}`
-          : "");
+                    : "");
 
-      return {
+            return {
-        content: [
+                content: [
-          {
+                    {
-            type: "text" as const,
+                        type: "text" as const,
-            text:
+                        text:
-              `Found ${emails.length} unread email(s):\n\n` +
+                            `Found ${emails.length} unread email(s):\n\n` +
-              `${"=".repeat(60)}\n${emails.join(`\n${"=".repeat(60)}\n`)}` +
+                            `${"=".repeat(60)}\n${emails.join(`\n${"=".repeat(60)}\n`)}` +
-              instructionsBlock,
+                            instructionsBlock,
-          },
+                    },
-        ],
+                ],
-      };
+            };
-    } catch (error) {
+        } catch (error) {
-      const errMsg = error instanceof Error ? error.message : String(error);
+            const errMsg = error instanceof Error ? error.message : String(error);
-      return {
+            return {
-        content: [
+                content: [
-          {
+                    {
-            type: "text" as const,
+                        type: "text" as const,
-            text: `Error fetching emails: ${errMsg}`,
+                        text: `Error fetching emails: ${errMsg}`,
-          },
+                    },
-        ],
+                ],
-      };
+            };
+        }
     }
-  }
 );
 
 // ---------------------------------------------------------------------------
 // Tool: delete_emails
 // ---------------------------------------------------------------------------
 server.registerTool(
-  "delete_emails",
+    "delete_emails",
-  {
+    {
-    description:
+        description:
-      "Move emails to trash by their Gmail message IDs. Use this for " +
+            "Move emails to trash by their Gmail message IDs. Use this for " +
-      "category A (acknowledgements) and category C (rejections) emails. " +
+            "category A (acknowledgements) and category C (rejections) emails. " +
-      "Specify which account the emails belong to.",
+            "Specify which account the emails belong to.",
-    inputSchema: {
+        inputSchema: {
-      account: accountSchema,
+            account: accountSchema,
-      messageIds: z
+            messageIds: z
-        .array(z.string())
+                .array(z.string())
-        .describe("Array of Gmail message IDs to move to trash"),
+                .describe("Array of Gmail message IDs to move to trash"),
+        },
     },
-  },
+    async ({ account, messageIds }) => {
-  async ({ account, messageIds }) => {
-    try {
-      const gmail = getGmailClient(account);
-      const results: string[] = [];
-
-      for (const id of messageIds) {
         try {
-          await gmail.users.messages.trash({
+            const gmail = getGmailClient(account);
-            userId: "me",
+            const results: string[] = [];
-            id,
-          });
-          results.push(`Trashed: ${id}`);
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          results.push(`Failed to trash ${id}: ${errMsg}`);
-        }
-      }
 
-      return {
+            for (const id of messageIds) {
-        content: [
+                try {
-          {
+                    await gmail.users.messages.trash({
-            type: "text" as const,
+                        userId: "me",
-            text: `Delete results:\n${results.join("\n")}`,
+                        id,
-          },
+                    });
-        ],
+                    results.push(`Trashed: ${id}`);
-      };
+                } catch (err) {
-    } catch (error) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
-      const errMsg = error instanceof Error ? error.message : String(error);
+                    results.push(`Failed to trash ${id}: ${errMsg}`);
-      return {
+                }
-        content: [
+            }
-          {
+
-            type: "text" as const,
+            return {
-            text: `Error deleting emails: ${errMsg}`,
+                content: [
-          },
+                    {
-        ],
+                        type: "text" as const,
-      };
+                        text: `Delete results:\n${results.join("\n")}`,
+                    },
+                ],
+            };
+        } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Error deleting emails: ${errMsg}`,
+                    },
+                ],
+            };
+        }
     }
-  }
 );
 
 // ---------------------------------------------------------------------------
 // Tool: append_to_summary
 // ---------------------------------------------------------------------------
 interface SummaryEntry {
-  senderName: string;
+    senderName: string;
-  senderEmail: string;
+    senderEmail: string;
-  dateReceived: string;
+    dateReceived: string;
-  subject: string;
+    subject: string;
-  category: "B" | "D";
+    category: "B" | "D";
-  addedAt: string;
+    addedAt: string;
 }
 
 server.registerTool(
-  "append_to_summary",
+    "append_to_summary",
-  {
+    {
-    description:
+        description:
-      "Append classified email entries to the local summary file. Use this " +
+            "Append classified email entries to the local summary file. Use this " +
-      "for category B (advancement to next step) and category D (other) emails. " +
+            "for category B (advancement to next step) and category D (other) emails. " +
-      "Each entry records the sender, date, subject, and category. " +
+            "Each entry records the sender, date, subject, and category. " +
-      "Specify which account the emails belong to.",
+            "Specify which account the emails belong to.",
-    inputSchema: {
+        inputSchema: {
-      account: accountSchema,
+            account: accountSchema,
-      entries: z
+            entries: z
-        .array(
+                .array(
-          z.object({
+                    z.object({
-            senderName: z.string().describe("Name of the sender"),
+                        senderName: z.string().describe("Name of the sender"),
-            senderEmail: z.string().describe("Email address of the sender"),
+                        senderEmail: z.string().describe("Email address of the sender"),
-            dateReceived: z
+                        dateReceived: z
-              .string()
+                            .string()
-              .describe("Date and time the email was received"),
+                            .describe("Date and time the email was received"),
-            subject: z.string().describe("Email subject line"),
+                        subject: z.string().describe("Email subject line"),
-            category: z
+                        category: z
-              .enum(["B", "D"])
+                            .enum(["B", "D"])
-              .describe(
+                            .describe(
-                "Category: B = advancement to next step, D = other/uncategorized"
+                                "Category: B = advancement to next step, D = other/uncategorized"
-              ),
+                            ),
-          })
+                    })
-        )
+                )
-        .describe("Array of email summary entries to append"),
+                .describe("Array of email summary entries to append"),
+        },
     },
-  },
+    async ({ account, entries }) => {
-  async ({ account, entries }) => {
+        try {
-    try {
+            const summaryPath = getSummaryPath(account);
-      const summaryPath = getSummaryPath(account);
 
-      let summary: SummaryEntry[] = [];
+            let summary: SummaryEntry[] = [];
-      if (fs.existsSync(summaryPath)) {
+            if (fs.existsSync(summaryPath)) {
-        summary = JSON.parse(fs.readFileSync(summaryPath, "utf-8"));
+                summary = JSON.parse(fs.readFileSync(summaryPath, "utf-8"));
-      }
+            }
 
-      const now = new Date();
+            const now = new Date();
-      const nowIso = now.toISOString();
+            const nowIso = now.toISOString();
-      const newEntries: SummaryEntry[] = entries.map((e) => ({
+            const newEntries: SummaryEntry[] = entries.map((e) => ({
-        ...e,
+                ...e,
-        addedAt: nowIso,
+                addedAt: nowIso,
-      }));
+            }));
 
-      summary.push(...newEntries);
+            summary.push(...newEntries);
 
-      const RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+            const RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
-      const cutoff = now.getTime() - RETENTION_MS;
+            const cutoff = now.getTime() - RETENTION_MS;
-      const beforePurge = summary.length;
+            const beforePurge = summary.length;
-      summary = summary.filter(
+            summary = summary.filter(
-        (entry) => new Date(entry.addedAt).getTime() >= cutoff
+                (entry) => new Date(entry.addedAt).getTime() >= cutoff
-      );
+            );
-      const purged = beforePurge - summary.length;
+            const purged = beforePurge - summary.length;
 
-      fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
+            fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
 
-      const purgeNote = purged > 0
+            const purgeNote = purged > 0
-        ? `\nPurged ${purged} entry/entries older than 30 days.`
+                ? `\nPurged ${purged} entry/entries older than 30 days.`
-        : "";
+                : "";
 
-      return {
+            return {
-        content: [
+                content: [
-          {
+                    {
-            type: "text" as const,
+                        type: "text" as const,
-            text:
+                        text:
-              `Appended ${newEntries.length} entry/entries to summary.\n` +
+                            `Appended ${newEntries.length} entry/entries to summary.\n` +
-              `Total entries in summary: ${summary.length}\n` +
+                            `Total entries in summary: ${summary.length}\n` +
-              `Summary file: ${summaryPath}` +
+                            `Summary file: ${summaryPath}` +
-              purgeNote,
+                            purgeNote,
-          },
+                    },
-        ],
+                ],
-      };
+            };
-    } catch (error) {
+        } catch (error) {
-      const errMsg = error instanceof Error ? error.message : String(error);
+            const errMsg = error instanceof Error ? error.message : String(error);
-      return {
+            return {
-        content: [
+                content: [
-          {
+                    {
-            type: "text" as const,
+                        type: "text" as const,
-            text: `Error appending to summary: ${errMsg}`,
+                        text: `Error appending to summary: ${errMsg}`,
-          },
+                    },
-        ],
+                ],
-      };
+            };
+        }
+    }
+);
+// --------------------------------------------------------------------------- //
+// Tool: star_emails
+// --------------------------------------------------------------------------- //
+server.registerTool(
+    "star_emails",
+    {
+        description: "Mark reviewed emails with a star and mark them as read in Gmail. " +
+            "Use this for all reviewed messages (Categories A, B, C, and D) " +
+            "to signal they have been processed. Specify which account the emails belong to.",
+        inputSchema: {
+            account: accountSchema,
+            messageIds: z
+                .array(z.string())
+                .describe("Array of Gmail message IDs to star and mark read"),
+        },
+    },
+    async ({ account, messageIds }) => {
+        try {
+            if (messageIds.length === 0) {
+                return { content: [{ type: "text" as const, text: "No message IDs provided." }] };
+            }
+
+            const gmail = getGmailClient(account);
+
+            // Batch modify allows updating up to 1000 messages in a single API call
+            await gmail.users.messages.batchModify({
+                userId: "me",
+                requestBody: {
+                    ids: messageIds,
+                    addLabelIds: ["STARRED"],
+                    removeLabelIds: ["UNREAD"]
+                }
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Successfully starred and marked read ${messageIds.length} email(s).`,
+                    },
+                ],
+            };
+        } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Error starring emails: ${errMsg}`,
+                    },
+                ],
+            };
+        }
     }
-  }
 );