assistme 0.3.0 → 0.3.2

package/src/mcp/agent-tools-server.ts

@@ -0,0 +1,1047 @@
+import {
+  createSdkMcpServer,
+  tool,
+  type McpSdkServerConfigWithInstance,
+} from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod/v4";
+import { log } from "../utils/logger.js";
+import type { MemoryManager, MemoryCategory } from "../agent/memory.js";
+import type { SkillManager } from "../agent/skills.js";
+import {
+  substituteArguments,
+  preprocessDynamicContext,
+  validateSkillName,
+} from "../agent/skills.js";
+import { emitEvent, setActionRequest, pollActionResponse } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
+import { JobRunner } from "../agent/job-runner.js";
+import { createScheduledTask, getNextRunTime } from "../agent/scheduler.js";
+import { getCredentialStore, type CredentialType } from "../credentials/index.js";
+
+// ── Agent Tools MCP Server (memory, skills) ─────────────────────────
+
+export interface AgentToolsDeps {
+  memoryManager: MemoryManager | null;
+  skillManager: SkillManager;
+  taskId: string;
+  sessionId?: string;
+}
+
+export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfigWithInstance {
+  const { memoryManager, skillManager, taskId, sessionId } = deps;
+
+  return createSdkMcpServer({
+    name: "assistme-agent",
+    version: "1.0.0",
+    tools: [
+      tool(
+        "memory_store",
+        "Store a memory about the user that persists across conversations. Use when you learn preferences, habits, or standing instructions.",
+        {
+          content: z.string().describe("What to remember (concise, factual statement)"),
+          category: z
+            .string()
+            .optional()
+            .describe("Category: general, preference, instruction, context, skill_learned, fact"),
+          importance: z
+            .number()
+            .optional()
+            .describe("Importance 1-10 (default: 5). Use 8+ for instructions"),
+          tags: z.array(z.string()).optional().describe("Optional tags for searchability"),
+        },
+        async (args) => {
+          if (!memoryManager) {
+            return {
+              content: [{ type: "text", text: "Memory manager not available." }],
+            };
+          }
+          const mem = await memoryManager.remember(
+            args.content,
+            (args.category as MemoryCategory) || "general",
+            {
+              importance: args.importance || 5,
+              tags: args.tags || [],
+              sourceMessageId: taskId,
+            }
+          );
+          const result = `Memory stored: "${mem.content}" [${mem.category}, importance: ${mem.importance}]`;
+          return { content: [{ type: "text", text: result }] };
+        }
+      ),
+      tool(
+        "skill_create",
+        "Create a new skill and add it to the user's collection. Returns the skill ID on success.",
+        {
+          name: z.string().describe("Skill name in kebab-case, e.g. 'flight-booking'"),
+          description: z.string().describe("One-line description of what this skill does"),
+          instructions: z.string().describe("Markdown step-by-step instructions"),
+          emoji: z.string().optional().describe("Single emoji representing this skill"),
+        },
+        async (args) => {
+          // Validate skill name format
+          const nameError = validateSkillName(args.name);
+          if (nameError) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Invalid skill name: ${nameError}. Use lowercase kebab-case like "flight-booking".`,
+                },
+              ],
+            };
+          }
+
+          // Check for duplicates in user's collection
+          const existing = skillManager.findSimilar(args.name);
+          if (existing) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `A similar skill "${existing.name}" already exists in your collection. Use skill_improve to update it instead.`,
+                },
+              ],
+            };
+          }
+
+          // Create in skills table (repository)
+          const result = await skillManager.create(args.name, args.description, args.instructions, {
+            source: "manual",
+            emoji: args.emoji,
+          });
+
+          if (!result) {
+            return {
+              content: [{ type: "text", text: `Failed to create skill "${args.name}".` }],
+            };
+          }
+
+          // Auto-add to user's collection via upsert_agent_skill RPC
+          await skillManager.syncToAgentSkills(
+            args.name,
+            args.description,
+            args.instructions,
+            "1.0.0",
+            {
+              source: "manual",
+              emoji: args.emoji,
+              sourceSkillId: result.id,
+            }
+          );
+
+          log.success(`Skill "${args.name}" created and added to collection`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill "${args.name}" created and added to your collection (ID: ${result.id}).`,
+              },
+            ],
+          };
+        }
+      ),
+      tool(
+        "skill_improve",
+        "Improve an existing skill with better instructions based on what you just learned. Version auto-bumped.",
+        {
+          name: z.string().describe("Name of the existing skill to improve"),
+          improved_instructions: z
+            .string()
+            .describe("Full updated markdown instructions (not a diff)"),
+          description: z.string().optional().describe("Updated description (optional)"),
+        },
+        async (args) => {
+          const existing = skillManager.get(args.name);
+          if (!existing) {
+            const available = skillManager
+              .getAll()
+              .map((s) => s.name)
+              .join(", ");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" not found. Available skills: ${available}`,
+                },
+              ],
+            };
+          }
+
+          const updated = skillManager.update(
+            args.name,
+            args.improved_instructions,
+            args.description
+          );
+          if (updated) {
+            log.success(`Self-improvement: improved skill "${args.name}"`);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" improved and version bumped.`,
+                },
+              ],
+            };
+          }
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Failed to update skill "${args.name}".`,
+              },
+            ],
+          };
+        }
+      ),
+      tool(
+        "skill_invoke",
+        "Load a skill's full instructions when relevant to the current task. " +
+          "Call this when you determine a skill from the Available Skills list matches the user's request.",
+        {
+          name: z.string().describe("Skill name from the Available Skills list"),
+          arguments: z
+            .string()
+            .optional()
+            .describe("Arguments to pass to the skill (replaces $ARGUMENTS placeholders)"),
+        },
+        async (args) => {
+          const skill = skillManager.get(args.name);
+          if (!skill) {
+            const available = skillManager
+              .getAll()
+              .map((s) => s.name)
+              .join(", ");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Skill "${args.name}" not found. Available skills: ${available}`,
+                },
+              ],
+            };
+          }
+
+          let content = skill.content;
+
+          // Substitute $ARGUMENTS placeholders
+          if (args.arguments) {
+            content = substituteArguments(content, args.arguments);
+          }
+
+          // Preprocess dynamic context (!`command` syntax)
+          content = preprocessDynamicContext(content);
+
+          // Build response with skill content
+          let response = `## Skill: ${skill.name}\n`;
+          if (skill.description) {
+            response += `*${skill.description}*\n`;
+          }
+          response += `\n${content}`;
+
+          // Note allowed tools restriction if specified
+          if (skill.allowedTools.length > 0) {
+            response += `\n\n**Allowed tools for this skill:** ${skill.allowedTools.join(", ")}\n`;
+          }
+
+          // Check required credentials and inject available ones
+          const credReqs = skill.metadata.credentials;
+          if (credReqs && credReqs.length > 0) {
+            const store = getCredentialStore();
+            const missing: string[] = [];
+
+            for (const req of credReqs) {
+              const cred = store.getByName(req.name);
+              if (cred) {
+                response += `\n\n**Credential: ${req.name}** (${req.type})\n`;
+                response += `\`\`\`json\n${JSON.stringify(cred.data, null, 2)}\n\`\`\`\n`;
+              } else if (req.required) {
+                missing.push(`${req.name} (${req.description})`);
+              }
+            }
+
+            if (missing.length > 0) {
+              response += `\n\n**Missing required credentials:**\n`;
+              for (const m of missing) {
+                response += `- ${m}\n`;
+              }
+              response += `\nUse \`ask_user\` to request these from the user, or create them yourself (e.g. register an account), then store with \`credential_set\`.\n`;
+            }
+          }
+
+          log.info(`Skill invoked: "${args.name}"`);
+
+          // Log invocation to DB (fire-and-forget)
+          skillManager
+            .logInvocation(args.name, {
+              messageId: taskId,
+              sessionId,
+              arguments: args.arguments,
+            })
+            .catch(() => {});
+
+          return {
+            content: [{ type: "text", text: response }],
+          };
+        }
+      ),
+      tool(
+        "skill_search",
+        "Search for skills by keyword. Uses full-text search across skill names, descriptions, and content. " +
+          "Use this to discover relevant skills when the Available Skills list doesn't have an obvious match.",
+        {
+          query: z.string().describe("Search query (keywords, topic, or task description)"),
+          limit: z.number().optional().describe("Max results (default: 5)"),
+        },
+        async (args) => {
+          const results = await skillManager.searchDb(args.query, args.limit || 5);
+
+          if (results.length === 0) {
+            return {
+              content: [{ type: "text", text: `No skills found for "${args.query}".` }],
+            };
+          }
+
+          let response = `## Skills matching "${args.query}"\n\n`;
+          for (const r of results) {
+            const emoji = r.emoji ? `${r.emoji} ` : "";
+            const usage = r.invocationCount > 0 ? ` (used ${r.invocationCount}x)` : "";
+            response += `- **${emoji}${r.name}**${usage}: ${r.description}\n`;
+          }
+          response += "\nUse skill_invoke to load any of these skills.";
+
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool(
+        "skill_generate",
+        "Prepare context for generating skills from a job description. Returns existing skills and job info " +
+          "so you can analyze the job and create skills using skill_create (which auto-adds to user's collection). " +
+          "After creating all skills, call skill_link_job to link them to the job and mark it as analyzed.",
+        {
+          job_name: z
+            .string()
+            .describe(
+              "Short name for this job/role. Example: '电商运营', 'Frontend Dev', 'Data Analyst'"
+            ),
+          job_description: z
+            .string()
+            .describe(
+              "Description of the user's job, role, and daily tasks. Can be in any language. " +
+                "Example: '我是电商运营，每天要看竞品价格、写商品文案、回复客户评论'"
+            ),
+        },
+        async (args) => {
+          const existingNames = skillManager.getAll().map((s) => s.name);
+
+          let response = `## Job: ${args.job_name}\n`;
+          response += `**Description:** ${args.job_description}\n\n`;
+
+          if (existingNames.length > 0) {
+            response += `**Existing skills (do NOT duplicate):** ${existingNames.join(", ")}\n\n`;
+          }
+
+          response += `**Your task:** Analyze this job description and decompose it into 4-10 automatable skills.\n\n`;
+          response += `**IMPORTANT — You MUST use ask_user before creating skills:**\n`;
+          response += `1. Analyze the job and draft a list of proposed skills (name, emoji, one-line description for each).\n`;
+          response += `2. Call \`ask_user\` with the formatted skill list as "question" and these options:\n`;
+          response += `   - options: [{label: "Approve All", action_key: "approve_all", description: "Create all proposed skills"}, {label: "Cancel", action_key: "cancel", description: "Do not create any skills"}]\n`;
+          response += `3. WAIT for the response. If action_key is "approve_all", create all skills using \`skill_create\`. If "cancel", stop.\n`;
+          response += `4. Do NOT ask for confirmation in text. Do NOT create skills without calling ask_user first.\n\n`;
+          response += `For each skill, call \`skill_create\` with:\n`;
+          response += `- name: kebab-case name (e.g. "slack-message-check")\n`;
+          response += `- description: one-line description\n`;
+          response += `- instructions: detailed step-by-step markdown instructions the agent can follow\n`;
+          response += `- emoji: a single emoji representing the skill\n\n`;
+          response += `skill_create automatically adds the skill to the user's collection — no need to call skill_add.\n\n`;
+          response += `After ALL skills are created, call \`skill_link_job\` with job_name="${args.job_name}" and the list of created skill names to link them and mark the job as analyzed.\n\n`;
+          response += `**Guidelines for skill instructions:**\n`;
+          response += `- Write clear, actionable markdown steps\n`;
+          response += `- Reference browser tools (browser_navigate, browser_click, browser_read_page, etc.) for web tasks\n`;
+          response += `- Include error handling steps\n`;
+          response += `- Use placeholders like {query}, {date} for variable inputs\n`;
+          response += `- Each skill should be a single, well-defined workflow (10-25 steps)\n`;
+
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool(
+        "skill_link_job",
+        "Link created skills to a job and mark it as analyzed. Call this after creating all skills for a job via skill_create + skill_add.",
+        {
+          job_name: z.string().describe("Name of the job to link skills to"),
+          job_description: z.string().describe("Job description (used if job doesn't exist yet)"),
+          skill_names: z.array(z.string()).describe("Names of skills to link to this job"),
+        },
+        async (args) => {
+          try {
+            await saveJobToDb(args.job_name, args.job_description, args.skill_names);
+            log.success(
+              `Job "${args.job_name}": linked ${args.skill_names.length} skills and marked as analyzed`
+            );
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Job "${args.job_name}" linked with ${args.skill_names.length} skills and marked as analyzed.`,
+                },
+              ],
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to link job: ${err instanceof Error ? err.message : err}`,
+                },
+              ],
+            };
+          }
+        }
+      ),
+      tool(
+        "skill_browse",
+        "Browse the skill marketplace to discover skills published by the community. " +
+          "Search by keyword, filter by category, and sort by popularity or rating.",
+        {
+          query: z.string().optional().describe("Search keywords"),
+          category: z
+            .string()
+            .optional()
+            .describe("Filter by category (e.g. 'productivity', 'ecommerce', 'dev-tools')"),
+          sort: z
+            .enum(["popular", "recent", "rating"])
+            .optional()
+            .describe("Sort order (default: popular)"),
+          limit: z.number().optional().describe("Max results (default: 10)"),
+        },
+        async (args) => {
+          const results = await skillManager.browse({
+            query: args.query,
+            category: args.category,
+            sort: args.sort,
+            limit: args.limit || 10,
+          });
+
+          if (results.length === 0) {
+            const hint = args.query ? ` for "${args.query}"` : "";
+            return {
+              content: [{ type: "text", text: `No skills found in marketplace${hint}.` }],
+            };
+          }
+
+          let response = "## Skill Marketplace\n\n";
+          for (const s of results) {
+            const emoji = s.emoji ? `${s.emoji} ` : "";
+            const rating = s.avgRating ? ` ★${s.avgRating}` : "";
+            const installs = s.installCount > 0 ? ` (${s.installCount} installs)` : "";
+            const author = s.authorName ? ` by ${s.authorName}` : "";
+            response += `- **${emoji}${s.name}** v${s.version}${author}${installs}${rating}\n`;
+            response += `  ${s.description}\n`;
+            response += `  ID: \`${s.id}\`\n\n`;
+          }
+          response += "Use `skill_add` with the skill ID to add any of these to your collection.";
+
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool(
+        "skill_add",
+        "Add a skill to your personal collection. Works for both marketplace skills and newly created drafts. " +
+          "This is the approval step — after adding, the skill becomes available for use via skill_invoke.",
+        {
+          skill_id: z
+            .string()
+            .describe("The skill UUID (from skill_browse or skill_create results)"),
+        },
+        async (args) => {
+          const added = await skillManager.addSkill(args.skill_id);
+          if (!added) {
+            return {
+              content: [
+                { type: "text", text: `Failed to add skill. Check that the ID is correct.` },
+              ],
+            };
+          }
+
+          const emoji = added.metadata.emoji ? `${added.metadata.emoji} ` : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Added **${emoji}${added.name}** v${added.version} to your collection. It's now available for use via skill_invoke.`,
+              },
+            ],
+          };
+        }
+      ),
+      tool(
+        "skill_publish",
+        "Publish one of your skills to the marketplace so others can discover and install it.",
+        {
+          name: z.string().describe("Name of your skill to publish"),
+          category: z
+            .string()
+            .optional()
+            .describe("Category (e.g. 'productivity', 'ecommerce', 'dev-tools')"),
+          author_name: z.string().optional().describe("Your display name as the author"),
+        },
+        async (args) => {
+          const skill = skillManager.get(args.name);
+          if (!skill) {
+            return {
+              content: [
+                { type: "text", text: `Skill "${args.name}" not found in your collection.` },
+              ],
+            };
+          }
+
+          if (skill.source === "external") {
+            return {
+              content: [{ type: "text", text: `Cannot publish external skills.` }],
+            };
+          }
+
+          const result = await skillManager.publish(args.name, {
+            category: args.category,
+            authorName: args.author_name,
+          });
+
+          if (!result) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to publish "${args.name}". The name may already be taken by another author.`,
+                },
+              ],
+            };
+          }
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill "${args.name}" published to the marketplace! Others can now find and install it.`,
+              },
+            ],
+          };
+        }
+      ),
+
+      // ── User Interaction Tool ───────────────────────────────────
+
+      tool(
+        "ask_user",
+        "Ask the user a question via the web UI and wait for their response. " +
+          "Shows a message with optional predefined option buttons PLUS a free-text input field — " +
+          "the user can either click a suggested option or type a custom answer. " +
+          "ALWAYS provide options when you can suggest likely answers. " +
+          "Do NOT use this for information you can discover yourself (git remote, file contents, etc.).",
+        {
+          question: z
+            .string()
+            .describe(
+              "The question to ask (supports markdown). Be specific about what you need and why."
+            ),
+          options: z
+            .array(
+              z.object({
+                label: z.string().describe("Button label shown to user"),
+                action_key: z.string().describe("Machine-readable key returned when selected"),
+                description: z.string().optional().describe("Tooltip/description for this option"),
+              })
+            )
+            .optional()
+            .describe(
+              "Suggested options shown as buttons. The user can always type a custom answer instead."
+            ),
+          placeholder: z
+            .string()
+            .optional()
+            .describe("Placeholder text for the free-text input field"),
+          timeout_seconds: z
+            .number()
+            .optional()
+            .describe("How long to wait for response (default: 300)"),
+        },
+        async (args) => {
+          const actionId = `ask_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const timeout = (args.timeout_seconds || 300) * 1000;
+
+          const actionData = {
+            id: actionId,
+            type: "ask_user",
+            message: args.question,
+            options: args.options || [],
+            placeholder: args.placeholder || "",
+            created_at: new Date().toISOString(),
+          };
+
+          try {
+            await setActionRequest(taskId, actionData);
+            log.info(`Ask user ${actionId}: "${args.question.slice(0, 80)}..."`);
+
+            emitEvent(taskId, "user_action_request", actionData).catch(() => {});
+            // Emit waiting_for_user status so the web UI can show a waiting indicator
+            emitEvent(taskId, "status_change", {
+              status: "waiting_for_user",
+              message: args.question,
+            }).catch(() => {});
+
+            const startTime = Date.now();
+            const pollInterval = 2000;
+
+            while (Date.now() - startTime < timeout) {
+              const response = await pollActionResponse(taskId);
+              if (response && (!response.action_id || response.action_id === actionId)) {
+                // Response can be either an option click or free-text input
+                const actionKey = (response.action_key || "") as string;
+                const text = (response.text || "") as string;
+                const label = (response.label || actionKey || text) as string;
+                log.info(`User responded: "${label}"`);
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: JSON.stringify({
+                        status: "responded",
+                        action_key: actionKey || "custom_input",
+                        label,
+                        text: text || label,
+                      }),
+                    },
+                  ],
+                };
+              }
+
+              await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            }
+
+            log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    status: "timeout",
+                    message: "User did not respond within the timeout period.",
+                  }),
+                },
+              ],
+            };
+          } catch (err) {
+            log.error(`ask_user failed: ${err}`);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to ask user: ${err instanceof Error ? err.message : err}`,
+                },
+              ],
+            };
+          }
+        }
+      ),
+
+      // ── Job Automation Tools ──────────────────────────────────────
+
+      tool(
+        "job_run",
+        "Run a job by loading its goal and available skills as capabilities. " +
+          "You then decide dynamically which skills to use, in what order, and how to chain them based on what you discover. " +
+          "Use this when the user asks to run their job, or when a scheduled job fires.",
+        {
+          job_name: z
+            .string()
+            .describe("Name of the job to run (e.g. 'software-engineer', 'Frontend Dev')"),
+        },
+        async (args) => {
+          const runner = new JobRunner();
+          const job = await runner.loadJob(args.job_name);
+
+          if (!job) {
+            // Try to list available jobs
+            const jobs = await runner.listJobs();
+            const available =
+              jobs.length > 0
+                ? `Available jobs: ${jobs.map((j) => `"${j.name}" (${j.skillCount} skills)`).join(", ")}`
+                : "No jobs defined yet. Use skill_generate to create a job from a job description.";
+            return {
+              content: [{ type: "text", text: `Job "${args.job_name}" not found. ${available}` }],
+            };
+          }
+
+          if (job.skills.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Job "${args.job_name}" has no linked skills. Use skill_generate to add skills to this job.`,
+                },
+              ],
+            };
+          }
+
+          // Create a job run record (execution trace lives in conversation transcript)
+          const runId = await runner.createRun(job.jobId, {
+            sessionId: sessionId,
+            messageId: taskId,
+            triggerType: "manual",
+          });
+
+          if (!runId) {
+            // Still return the prompt even if tracking fails
+            log.debug("Failed to create job run record, proceeding without tracking");
+          }
+
+          // Build the structured prompt
+          const prompt = runner.buildJobPrompt(job, runId || "untracked");
+
+          log.info(
+            `Job "${args.job_name}" started with ${job.skills.length} skills (run: ${runId?.slice(0, 8) || "untracked"})`
+          );
+
+          return {
+            content: [{ type: "text", text: prompt }],
+          };
+        }
+      ),
+      tool(
+        "job_schedule",
+        "Schedule a job to run automatically on a recurring basis using a cron expression. " +
+          "For example, schedule your 'software-engineer' job to run every morning at 9am.",
+        {
+          job_name: z.string().describe("Name of the job to schedule"),
+          cron: z
+            .string()
+            .describe(
+              "Cron expression: 'minute hour day-of-month month day-of-week'. " +
+                "Examples: '0 9 * * *' (daily 9am), '0 9 * * 1-5' (weekdays 9am), '0 */2 * * *' (every 2 hours)"
+            ),
+          timezone: z
+            .string()
+            .optional()
+            .describe("Timezone (default: UTC). Examples: 'UTC', 'America/New_York'"),
+          schedule_name: z
+            .string()
+            .optional()
+            .describe("Custom name for this schedule (default: 'Job: <job_name>')"),
+        },
+        async (args) => {
+          const runner = new JobRunner();
+          const job = await runner.loadJob(args.job_name);
+
+          if (!job) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Job "${args.job_name}" not found. Create it first with skill_generate.`,
+                },
+              ],
+            };
+          }
+
+          // Validate cron expression
+          try {
+            getNextRunTime(args.cron, args.timezone || "UTC");
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Invalid cron expression: "${args.cron}". Use format: "minute hour day-of-month month day-of-week"`,
+                },
+              ],
+            };
+          }
+
+          // Create the scheduled task with a job-run prompt
+          const name = args.schedule_name || `Job: ${args.job_name}`;
+          const prompt = `[JobRun: ${args.job_name}] Run the "${args.job_name}" job. Use job_run to execute it.`;
+          const tz = args.timezone || "UTC";
+
+          try {
+            const task = await createScheduledTask(name, prompt, args.cron, tz);
+
+            // Link the job_id to the scheduled task
+            await callMcpHandler("schedule.link_job", {
+              task_id: task.id,
+              job_id: job.jobId,
+            });
+
+            const nextRun = task.next_run_at
+              ? new Date(task.next_run_at).toLocaleString()
+              : "calculating...";
+
+            let response = `## Job Scheduled: ${args.job_name}\n\n`;
+            response += `- **Schedule:** ${args.cron} (${tz})\n`;
+            response += `- **Next run:** ${nextRun}\n`;
+            response += `- **Skills:** ${job.skills.length}\n\n`;
+            response += `The job "${args.job_name}" will automatically run on this schedule. `;
+            response += `Each run will execute ${job.skills.length} skills in sequence:\n`;
+            for (const skill of job.skills) {
+              const emoji = skill.skillEmoji ? `${skill.skillEmoji} ` : "";
+              response += `  - ${emoji}${skill.skillName}\n`;
+            }
+
+            log.success(`Job "${args.job_name}" scheduled: ${args.cron}`);
+            return { content: [{ type: "text", text: response }] };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to schedule job: ${err instanceof Error ? err.message : err}`,
+                },
+              ],
+            };
+          }
+        }
+      ),
+      tool(
+        "job_status",
+        "Check the status and run history of a job. Shows recent executions, success rates, and details.",
+        {
+          job_name: z.string().optional().describe("Job name to check (omit for all jobs)"),
+          limit: z.number().optional().describe("Max number of runs to show (default: 5)"),
+        },
+        async (args) => {
+          const runner = new JobRunner();
+
+          // If no job specified, list all jobs
+          if (!args.job_name) {
+            const jobs = await runner.listJobs();
+            if (jobs.length === 0) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: "No jobs defined. Use skill_generate to create a job from your job description.",
+                  },
+                ],
+              };
+            }
+
+            let response = "## Your Jobs\n\n";
+            for (const job of jobs) {
+              response += `- **${job.name}** (${job.skillCount} skills): ${job.description.slice(0, 100)}\n`;
+            }
+            response += "\nUse `job_run` to execute a job, or `job_schedule` to automate it.";
+            return { content: [{ type: "text", text: response }] };
+          }
+
+          // Show run history for specific job
+          const runs = await runner.getRunHistory(args.job_name, args.limit || 5);
+
+          if (runs.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No runs found for job "${args.job_name}". Use job_run to execute it.`,
+                },
+              ],
+            };
+          }
+
+          let response = `## Job Status: ${args.job_name}\n\n`;
+          response += `### Recent Runs\n\n`;
+
+          for (const run of runs) {
+            const statusIcon =
+              run.status === "completed"
+                ? "+"
+                : run.status === "failed"
+                  ? "x"
+                  : run.status === "running"
+                    ? "~"
+                    : "-";
+            const date = new Date(run.startedAt).toLocaleString();
+            const duration = run.completedAt
+              ? `${Math.round((new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime()) / 1000)}s`
+              : "in progress";
+
+            response += `[${statusIcon}] ${date} | ${run.triggerType} | ${duration}\n`;
+            if (run.summary) {
+              response += `    ${run.summary.slice(0, 100)}\n`;
+            }
+          }
+
+          // Stats
+          const total = runs.length;
+          const completed = runs.filter((r) => r.status === "completed").length;
+          const failed = runs.filter((r) => r.status === "failed").length;
+          response += `\n**Stats:** ${completed}/${total} successful`;
+          if (failed > 0) response += `, ${failed} failed`;
+          response += "\n";
+
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+
+      // ── Credential Tools ──────────────────────────────────────────
+
+      tool(
+        "credential_get",
+        "Retrieve a locally stored credential by name. Returns the secret data (API keys, tokens, etc.) " +
+          "stored on the user's machine. Use this when a skill needs authentication or API access.",
+        {
+          name: z.string().describe("Credential name (e.g. 'amazon-login', 'openai-api-key')"),
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          const credential = store.getByName(args.name);
+          if (!credential) {
+            const all = store.list();
+            const available =
+              all.length > 0
+                ? `Available credentials: ${all.map((m) => m.name).join(", ")}`
+                : "No credentials stored yet.";
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Credential "${args.name}" not found. ${available}\nUse ask_user to request it from the user, or create it yourself (e.g. register an account), then store with credential_set.`,
+                },
+              ],
+            };
+          }
+
+          log.info(`Credential accessed: "${args.name}" (${credential.meta.type})`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  name: credential.meta.name,
+                  type: credential.meta.type,
+                  data: credential.data,
+                  skill: credential.meta.skillName || null,
+                }),
+              },
+            ],
+          };
+        }
+      ),
+      tool(
+        "credential_set",
+        "Store a credential locally on the user's machine. The credential is encrypted at rest and " +
+          "never sent to any remote server. IMPORTANT: Always use this to persist credentials — both when " +
+          "receiving them from the user via ask_user AND when you generate new credentials yourself " +
+          "(e.g. registering an account, creating an API key, generating a token). This ensures credentials " +
+          "survive across sessions and don't need to be recreated.",
+        {
+          name: z.string().describe("Credential name (lowercase kebab-case, e.g. 'amazon-login')"),
+          type: z
+            .enum(["api_key", "oauth_token", "login", "secret", "custom"])
+            .describe("Credential type"),
+          data: z
+            .record(z.string(), z.string())
+            .describe(
+              'Key-value pairs (e.g. { "username": "...", "password": "..." } or { "api_key": "..." })'
+            ),
+          skill_name: z.string().optional().describe("Associate with a specific skill"),
+          tags: z.array(z.string()).optional().describe("Tags for searchability"),
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          const meta = store.save(args.name, args.type as CredentialType, args.data, {
+            skillName: args.skill_name,
+            tags: args.tags,
+          });
+
+          log.info(`Credential stored: "${args.name}" (${args.type})`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Credential "${meta.name}" stored locally (type: ${meta.type}, id: ${meta.id}). It is encrypted and will persist across app restarts.`,
+              },
+            ],
+          };
+        }
+      ),
+      tool(
+        "credential_list",
+        "List all locally stored credentials (metadata only, no secrets). " +
+          "Use this to check what credentials are available before executing a skill.",
+        {
+          skill_name: z.string().optional().describe("Filter by skill name"),
+          type: z.string().optional().describe("Filter by credential type"),
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          let results = store.list();
+
+          if (args.skill_name) {
+            results = results.filter((m) => m.skillName === args.skill_name);
+          }
+          if (args.type) {
+            results = results.filter((m) => m.type === args.type);
+          }
+
+          if (results.length === 0) {
+            const filter = args.skill_name ? ` for skill "${args.skill_name}"` : "";
+            return {
+              content: [{ type: "text", text: `No credentials found${filter}.` }],
+            };
+          }
+
+          let response = "## Stored Credentials\n\n";
+          for (const m of results) {
+            const skill = m.skillName ? ` [${m.skillName}]` : "";
+            const tags = m.tags.length > 0 ? ` (${m.tags.join(", ")})` : "";
+            response += `- **${m.name}** (${m.type})${skill}${tags}\n`;
+          }
+          return { content: [{ type: "text", text: response }] };
+        }
+      ),
+      tool(
+        "credential_remove",
+        "Remove a locally stored credential by name.",
+        {
+          name: z.string().describe("Credential name to remove"),
+        },
+        async (args) => {
+          const store = getCredentialStore();
+          const removed = store.removeByName(args.name);
+          if (!removed) {
+            return {
+              content: [{ type: "text", text: `Credential "${args.name}" not found.` }],
+            };
+          }
+          log.info(`Credential removed: "${args.name}"`);
+          return {
+            content: [
+              { type: "text", text: `Credential "${args.name}" removed from local storage.` },
+            ],
+          };
+        }
+      ),
+    ],
+  });
+}
+
+// ── Helper: persist job and link skills ────────────────────────────
+
+async function saveJobToDb(
+  jobName: string,
+  jobDescription: string,
+  createdSkillNames: string[]
+): Promise<void> {
+  try {
+    const data = await callMcpHandler("job.save_with_skills", {
+      job_name: jobName,
+      job_description: jobDescription,
+      skill_names: createdSkillNames,
+    });
+
+    log.debug(
+      `Job "${jobName}" saved via edge function (id: ${data}), ${createdSkillNames.length} skill(s) linked`
+    );
+  } catch (err) {
+    log.debug(`saveJobToDb error: ${err}`);
+  }
+}