assistme 0.8.12 → 0.9.0

package/PLAN.md

@@ -143,4 +143,4 @@ New page: `/agent` - Agent chat interface
 
 ### Phase 4: Edge Function
 
-1. Create agent-submit-task edge function for mobile clients
+1. Create main-agent-submit-task edge function for mobile clients

package/dist/{chunk-MP4E522X.js → chunk-E27P57PM.js}

@@ -8,7 +8,7 @@ import {
   readAuthStore,
   safeParse,
   writeAuthStore
-} from "./chunk-5ML5YMCM.js";
+} from "./chunk-RRMI6RDG.js";
 import {
   log,
   newCorrelationId,
@@ -2833,19 +2833,51 @@ var TaskPoller = class {
 // src/agent/memory/manager.ts
 var MemoryManager = class {
   /**
-   * Store a new memory. Called by the agent after completing tasks
-   * to remember important facts about the user.
+   * When set, all memory operations use this agent's users.id as the
+   * effective user, giving the agent its own memory space.
+   */
+  agentUserId = null;
+  /** The human owner's user ID — used to load owner memories as fallback. */
+  ownerUserId = null;
+  /**
+   * Configure agent-scoped memory.
+   * @param agentUserId  The agent's users.id — memories are stored/read here
+   * @param ownerUserId  The human owner's users.id — owner memories loaded as fallback
+   */
+  setAgentContext(agentUserId, ownerUserId) {
+    this.agentUserId = agentUserId;
+    this.ownerUserId = ownerUserId;
+  }
+  /** Clear agent context (revert to normal user-scoped mode). */
+  clearAgentContext() {
+    this.agentUserId = null;
+    this.ownerUserId = null;
+  }
+  /** Inject effective_user_id + owner_user_id into params. */
+  agentParams(extra = {}) {
+    const params = { ...extra };
+    if (this.agentUserId) {
+      params.effective_user_id = this.agentUserId;
+      if (this.ownerUserId) {
+        params.owner_user_id = this.ownerUserId;
+      }
+    }
+    return params;
+  }
+  /**
+   * Store a new memory. Called by the agent after completing tasks.
+   * When agent context is set, stores under the agent's user_id.
    */
   async remember(content, category = "general", options) {
     const expiresAt = options?.expiresInDays ? new Date(Date.now() + options.expiresInDays * 864e5).toISOString() : null;
-    const data = await callMcpHandler("memory.store", {
+    const data = await callMcpHandler("memory.store", this.agentParams({
       category,
       content,
       importance: options?.importance ?? 5,
       tags: options?.tags ?? [],
       source_message_id: options?.sourceMessageId ?? null,
       expires_at: expiresAt
-    });
+    }));
     log.debug(`Memory stored: [${category}] ${content.slice(0, 80)}...`);
     return data;
   }
@@ -2854,10 +2886,10 @@ var MemoryManager = class {
    */
   async search(query9, limit = 10) {
     try {
-      return await callMcpHandler("memory.search", {
+      return await callMcpHandler("memory.search", this.agentParams({
         query: query9,
         limit
-      });
+      }));
     } catch (err) {
       log.warn(`Memory search failed: ${err instanceof Error ? err.message : err}`);
       return [];
@@ -2865,13 +2897,13 @@ var MemoryManager = class {
   }
   /**
    * Get the most important/recent memories to include in context.
-   * Called before each task to build the agent's "working memory".
-   * Automatically filters out expired memories.
+   * When agent context is set, loads agent's memories first,
+   * then supplements with the owner's memories as fallback.
    */
   async getContext(maxItems = 20) {
-    const all = await callMcpHandler("memory.get_context", {
+    const all = await callMcpHandler("memory.get_context", this.agentParams({
       max_items: maxItems
-    });
+    }));
     const seen = /* @__PURE__ */ new Set();
     return (all || []).filter((m) => {
       if (seen.has(m.id)) return false;
@@ -2885,48 +2917,63 @@ var MemoryManager = class {
   async buildMemoryPrompt() {
     const memories = await this.getContext();
     if (memories.length === 0) return "";
-    const sections = {};
-    for (const m of memories) {
-      const key = m.category;
-      if (!sections[key]) sections[key] = [];
-      sections[key].push(`- ${m.content}`);
-    }
+    const hasOwnerFlag = memories.some((m) => m._from_owner);
+    const agentMemories = hasOwnerFlag ? memories.filter((m) => !m._from_owner) : memories;
+    const ownerMemories = hasOwnerFlag ? memories.filter((m) => m._from_owner) : [];
     const categoryLabels = {
       instruction: "Standing Instructions",
-      preference: "User Preferences",
+      preference: "Preferences",
       general: "Known Facts",
       context: "Context",
       skill_learned: "Learned Skills",
       fact: "Facts"
     };
-    let prompt = "\n\n## What You Know About The User\n";
-    for (const [cat, items] of Object.entries(sections)) {
-      prompt += `
+    function formatSection(mems) {
+      const sections = {};
+      for (const m of mems) {
+        const key = m.category;
+        if (!sections[key]) sections[key] = [];
+        sections[key].push(`- ${m.content}`);
+      }
+      let out = "";
+      for (const [cat, items] of Object.entries(sections)) {
+        out += `
 ### ${categoryLabels[cat] || cat}
 `;
-      prompt += `${items.join("\n")}
+        out += `${items.join("\n")}
 `;
+      }
+      return out;
+    }
+    let prompt = "";
+    if (agentMemories.length > 0) {
+      prompt += this.agentUserId ? "\n\n## Your Memories\n" : "\n\n## What You Know About The User\n";
+      prompt += formatSection(agentMemories);
+    }
+    if (ownerMemories.length > 0) {
+      prompt += "\n\n## Owner's Context\n";
+      prompt += formatSection(ownerMemories);
     }
     return prompt;
   }
   // ── CRUD for CLI ────────────────────────────────────────────
   async list(category, limit = 20) {
-    const data = await callMcpHandler("memory.list", {
+    const data = await callMcpHandler("memory.list", this.agentParams({
       category: category || null,
       limit
-    });
+    }));
     return data || [];
   }
   async add(content, category = "general", importance = 5, tags = []) {
     return this.remember(content, category, { importance, tags });
   }
   async remove(memoryId) {
-    await callMcpHandler("memory.remove", { memory_id: memoryId });
+    await callMcpHandler("memory.remove", this.agentParams({ memory_id: memoryId }));
   }
   async clear(category) {
-    const result = await callMcpHandler("memory.clear", {
+    const result = await callMcpHandler("memory.clear", this.agentParams({
       category: category || null
-    });
+    }));
     return result.count;
   }
 };
@@ -5528,7 +5575,7 @@ function createJobTools(sessionId, taskId) {
         const job = await runner.loadJob(args.job_name);
         if (!job) {
           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.";
+          const available = jobs.length > 0 ? `Available jobs: ${jobs.map((j) => `"${j.name}" (${j.skillCount} skills, ${j.agentCount} agents)`).join(", ")}` : "No jobs defined yet. Use skill_generate to create a job from a job description.";
           return textResponse(`Job "${args.job_name}" not found. ${available}`);
         }
         if (job.skills.length === 0) {
@@ -5569,11 +5616,38 @@ function createJobTools(sessionId, taskId) {
             }
           }
         }
-        const prompt = runner.buildJobPrompt(job, runId || "untracked");
+        const effectiveRunId = runId || "untracked";
+        const prompt = runner.buildJobPrompt(job, effectiveRunId);
+        const primaryAgentForFilter = job.agents.length > 0 ? job.agents.find((p) => p.role === "primary") || job.agents[0] : null;
+        const parallelAgents = job.agents.filter(
+          (a) => a.role === "parallel" && a.agentId !== primaryAgentForFilter?.agentId
+        );
+        let fullResponse = prompt;
+        if (parallelAgents.length > 0) {
+          fullResponse += `
+
+---
+
+## Parallel Agent Dispatch
+`;
+          fullResponse += `The following parallel agents are assigned to this job. `;
+          fullResponse += `After you complete your primary tasks, review their responsibilities and execute any that haven't been covered:
+
+`;
+          for (const pa of parallelAgents) {
+            fullResponse += `### ${pa.agentName} (@${pa.agentUsername})
+`;
+            if (pa.agentBio) fullResponse += `*${pa.agentBio}*
+`;
+            fullResponse += `**Instructions:** ${pa.agentPrompt}
+
+`;
+          }
+        }
         log.info(
-          `Job "${args.job_name}" started with ${job.skills.length} skills (run: ${runId?.slice(0, 8) || "untracked"})`
+          `Job "${args.job_name}" started with ${job.skills.length} skills, ${job.agents.length} agents (run: ${effectiveRunId.slice(0, 8)})`
         );
-        return textResponse(prompt);
+        return textResponse(fullResponse);
       })
     ),
     tool4(
@@ -5639,6 +5713,80 @@ function createJobTools(sessionId, taskId) {
         }
       )
     ),
+    tool4(
+      "job_assign_agent",
+      "Create or update an agent for a job. The agent is a user with a specific prompt and identity that will execute this job.",
+      {
+        job_name: z4.string().describe("Name of the job to assign the agent to"),
+        agent_name: z4.string().describe("Display name for the agent (e.g. 'Daily Reporter')"),
+        agent_prompt: z4.string().describe("The agent's system prompt that defines its behavior and personality"),
+        agent_bio: z4.string().optional().describe("Short bio describing the agent's role"),
+        role: z4.enum(["primary", "parallel"]).optional().describe("Agent role: 'primary' (default) or 'parallel' for concurrent execution")
+      },
+      typedHandler(
+        async (args) => {
+          try {
+            const result = await callMcpHandler("job.save_agent", {
+              job_name: args.job_name,
+              agent_name: args.agent_name,
+              agent_prompt: args.agent_prompt,
+              agent_bio: args.agent_bio || null,
+              role: args.role || "primary"
+            });
+            if (!result) {
+              return textResponse(`Failed to create agent for job "${args.job_name}".`);
+            }
+            log.info(
+              `Agent "${result.username}" assigned to job "${args.job_name}" (${args.role || "primary"})`
+            );
+            let response = `## Agent Assigned to Job: ${args.job_name}
+
+`;
+            response += `- **Agent:** ${args.agent_name} (@${result.username})
+`;
+            response += `- **Role:** ${args.role || "primary"}
+`;
+            if (args.agent_bio) {
+              response += `- **Bio:** ${args.agent_bio}
+`;
+            }
+            response += `
+The agent is now ready to execute this job.`;
+            return textResponse(response);
+          } catch (err) {
+            return textResponse(
+              `Failed to assign agent: ${err instanceof Error ? err.message : err}`
+            );
+          }
+        }
+      )
+    ),
+    tool4(
+      "job_remove_agent",
+      "Remove (deactivate) an agent from a job.",
+      {
+        job_name: z4.string().describe("Name of the job"),
+        agent_name: z4.string().describe("Display name of the agent to remove")
+      },
+      typedHandler(
+        async (args) => {
+          try {
+            await callMcpHandler("job.remove_agent", {
+              job_name: args.job_name,
+              agent_name: args.agent_name
+            });
+            log.info(`Agent "${args.agent_name}" removed from job "${args.job_name}"`);
+            return textResponse(
+              `Agent "${args.agent_name}" has been removed from job "${args.job_name}".`
+            );
+          } catch (err) {
+            return textResponse(
+              `Failed to remove agent: ${err instanceof Error ? err.message : err}`
+            );
+          }
+        }
+      )
+    ),
     tool4(
       "job_status",
       "Check the status and run history of a job.",
@@ -5657,7 +5805,7 @@ function createJobTools(sessionId, taskId) {
           }
           let response2 = "## Your Jobs\n\n";
           for (const job of jobs) {
-            response2 += `- **${job.name}** (${job.skillCount} skills): ${job.description.slice(0, 100)}
+            response2 += `- **${job.name}** (${job.skillCount} skills, ${job.agentCount} agents): ${job.description.slice(0, 100)}
 `;
           }
           response2 += "\nUse `job_run` to execute a job, or `job_schedule` to automate it.";
@@ -8420,6 +8568,11 @@ var TaskProcessor = class {
     resetEventSequence();
     newCorrelationId();
     log.info(`Processing task ${task.id.slice(0, 8)}...`);
+    const taskAgentId = task.metadata?.agent_id || (task.sender_id !== this.userId ? task.sender_id : null);
+    if (taskAgentId && this.memoryManager && this.userId) {
+      this.memoryManager.setAgentContext(taskAgentId, this.userId);
+      log.debug(`Memory context set to agent ${taskAgentId.slice(0, 8)}`);
+    }
     const toolCallRecords = [];
     const toolFailures = [];
     try {
@@ -8479,6 +8632,9 @@ var TaskProcessor = class {
       await emitEvent(task.id, "status_change", { status: "failed" });
     } finally {
       setCorrelationId(null);
+      if (taskAgentId && this.memoryManager) {
+        this.memoryManager.clearAgentContext();
+      }
       try {
         const browser = getBrowser();
         if (browser.isConnected()) {

package/dist/{chunk-5ML5YMCM.js → chunk-RRMI6RDG.js}

@@ -43,7 +43,7 @@ function getRawToken() {
 async function callMcpHandler(action, params = {}, overrideToken) {
   const config = getConfig();
   const token = overrideToken || getRawToken();
-  const url = `${config.supabaseUrl}/functions/v1/mcp-handler`;
+  const url = `${config.supabaseUrl}/functions/v1/main-mcp-handler`;
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -91,6 +91,14 @@ var SkillRowSchema = z.object({
   source_skill_id: z.string().optional().nullable(),
   invocation_count: z.number().optional().default(0)
 });
+var JobAgentSchema = z.object({
+  agent_id: z.string(),
+  agent_username: z.string(),
+  agent_name: z.string().optional().default(""),
+  agent_bio: z.string().optional().nullable(),
+  agent_prompt: z.string(),
+  role: z.string().optional().default("primary")
+});
 var JobRowSchema = z.object({
   job_id: z.string(),
   job_name: z.string(),
@@ -100,14 +108,16 @@ var JobRowSchema = z.object({
   skill_name: z.string().optional().nullable(),
   skill_description: z.string().optional().default(""),
   skill_emoji: z.string().optional().default(""),
-  skill_content: z.string().optional().default("")
+  skill_content: z.string().optional().default(""),
+  agents: z.array(JobAgentSchema).optional().default([])
 });
 var JobListRowSchema = z.object({
   id: z.string(),
   name: z.string(),
   description: z.string().optional().default(""),
   prompt: z.string().optional().nullable(),
-  skill_count: z.number().optional().default(0)
+  skill_count: z.number().optional().default(0),
+  agent_count: z.number().optional().default(0)
 });
 var JobRunRowSchema = z.object({
   run_id: z.string(),
@@ -193,6 +203,15 @@ var JobRunner = class {
       const rows = data.map((row) => safeParse(JobRowSchema, row)).filter((r) => r != null);
       if (rows.length === 0) return null;
       const first = rows[0];
+      const rawAgents = first.agents || [];
+      const agents = rawAgents.map((a) => safeParse(JobAgentSchema, a)).filter((a) => a != null).map((a) => ({
+        agentId: a.agent_id,
+        agentUsername: a.agent_username,
+        agentName: a.agent_name || "",
+        agentBio: a.agent_bio ?? null,
+        agentPrompt: a.agent_prompt,
+        role: a.role
+      }));
       return {
         jobId: first.job_id,
         jobName: first.job_name,
@@ -204,7 +223,8 @@ var JobRunner = class {
           skillDescription: row.skill_description,
           skillEmoji: row.skill_emoji,
           skillContent: row.skill_content
-        }))
+        })),
+        agents
       };
     } catch (err) {
       log.debug(`Failed to load job "${jobName}": ${errorMessage(err)}`);
@@ -221,7 +241,8 @@ var JobRunner = class {
         id: row.id,
         name: row.name,
         description: row.description,
-        skillCount: row.skill_count
+        skillCount: row.skill_count,
+        agentCount: row.agent_count
       }));
     } catch (err) {
       log.debug(`Failed to list jobs: ${errorMessage(err)}`);
@@ -313,6 +334,9 @@ var JobRunner = class {
 `;
     }
     prompt += `## Instructions
+
+`;
+    prompt += `### Step 1: Analyze and set up skills
 `;
     prompt += `For each capability the job needs:
 `;
@@ -326,8 +350,24 @@ var JobRunner = class {
 
 `;
     prompt += `Be practical \u2014 only create skills that would genuinely help automate this job.
+
+`;
+    prompt += `### Step 2: Create the job's agent
+`;
+    prompt += `After setting up skills, create an agent for this job using \`job_assign_agent\`.
+`;
+    prompt += `The agent is the identity that will execute this job. Design it with:
 `;
-    prompt += `When done, summarize what skills were created, updated, or already existed.
+    prompt += `- **agent_name**: A concise, role-based name (e.g. "Daily Reporter", "Code Reviewer")
+`;
+    prompt += `- **agent_prompt**: A system prompt that defines the agent's behavior, expertise, and personality. `;
+    prompt += `Include the job's goals, preferred approach, and any domain knowledge the agent should have. `;
+    prompt += `Reference the linked skills as capabilities the agent can use.
+`;
+    prompt += `- **agent_bio**: A one-line description of what this agent does.
+
+`;
+    prompt += `When done, summarize what skills were created/updated and the agent that was assigned.
 `;
     return prompt;
   }
@@ -340,6 +380,10 @@ var JobRunner = class {
    * chain them based on what it discovers at runtime.
    */
   buildJobPrompt(job, runId) {
+    const primaryAgent = job.agents.length > 0 ? job.agents.find((a) => a.role === "primary") || job.agents[0] : null;
+    const parallelAgents = job.agents.filter(
+      (a) => a.role === "parallel" && a.agentId !== primaryAgent?.agentId
+    );
     const effectiveDescription = job.jobPrompt || job.jobDescription;
     let prompt = `## Job: ${job.jobName}
 `;
@@ -349,10 +393,43 @@ var JobRunner = class {
     prompt += `**Run ID:** ${runId}
 
 `;
-    prompt += `You are now acting as "${job.jobName}". `;
-    prompt += `Your goal is to accomplish the objectives described above using the skills and tools available to you.
+    if (primaryAgent) {
+      prompt += `## Agent Identity
+`;
+      prompt += `You are **${primaryAgent.agentName}** (@${primaryAgent.agentUsername}).
+`;
+      if (primaryAgent.agentBio) {
+        prompt += `*${primaryAgent.agentBio}*
+`;
+      }
+      prompt += `
+### Agent Instructions
+`;
+      prompt += `${primaryAgent.agentPrompt}
+
+`;
+    } else {
+      prompt += `You are now acting as "${job.jobName}". `;
+      prompt += `Your goal is to accomplish the objectives described above using the skills and tools available to you.
+
+`;
+    }
+    if (parallelAgents.length > 0) {
+      prompt += `### Parallel Agents
+`;
+      prompt += `The following agents are running concurrently on this job. `;
+      prompt += `They handle their own tasks independently \u2014 coordinate to avoid duplicate work.
 
 `;
+      for (const pa of parallelAgents) {
+        prompt += `- **${pa.agentName}** (@${pa.agentUsername})`;
+        if (pa.agentBio) prompt += ` \u2014 ${pa.agentBio}`;
+        prompt += `
+`;
+      }
+      prompt += `
+`;
+    }
     prompt += `### Available Skills
 `;
     prompt += `These skills are your capabilities for this job. `;

package/dist/index.js

@@ -34,11 +34,11 @@ import {
   setSessionBusy,
   toggleScheduledTask,
   updateHeartbeat
-} from "./chunk-MP4E522X.js";
+} from "./chunk-E27P57PM.js";
 import {
   JobRunner,
   callMcpHandler
-} from "./chunk-5ML5YMCM.js";
+} from "./chunk-RRMI6RDG.js";
 import {
   log,
   setLogConversationId,
@@ -382,7 +382,7 @@ function registerJobCommands(program2) {
   jobCmd.command("list").description("List your defined jobs").action(async () => {
     try {
       await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-NA3KJCKA.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-4KTCVIQP.js");
       const runner = new JobRunner2();
       const jobs = await runner.listJobs();
       if (jobs.length === 0) {
@@ -406,7 +406,7 @@ function registerJobCommands(program2) {
   jobCmd.command("status [name]").description("Show run history for a job (or all jobs)").option("-l, --limit <number>", "Max runs to show (default: 5)").action(async (name, opts) => {
     try {
       await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-NA3KJCKA.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-4KTCVIQP.js");
       const runner = new JobRunner2();
       const runs = await runner.getRunHistory(name, parseInt(opts.limit || "5"));
       if (runs.length === 0) {
@@ -454,7 +454,7 @@ Job Run History${name ? ` \u2014 ${name}` : ""}:`));
         process.exit(1);
       }
       await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-NA3KJCKA.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-4KTCVIQP.js");
       const runner = new JobRunner2();
       const job = await runner.loadJob(name);
       if (!job) {
@@ -2002,7 +2002,31 @@ var Orchestrator = class {
     } catch (linkErr) {
       log.debug(`Failed to link session to job run: ${linkErr}`);
     }
-    const prompt = runner.buildJobPrompt(job, jobRun.id);
+    let prompt = runner.buildJobPrompt(job, jobRun.id);
+    const primaryAgent = job.agents.length > 0 ? job.agents.find((a) => a.role === "primary") || job.agents[0] : null;
+    const parallelAgents = job.agents.filter(
+      (a) => a.role === "parallel" && a.agentId !== primaryAgent?.agentId
+    );
+    if (parallelAgents.length > 0) {
+      prompt += `
+
+---
+
+## Parallel Agent Responsibilities
+`;
+      prompt += `The following agents are also assigned. Execute their responsibilities as part of this run:
+
+`;
+      for (const pa of parallelAgents) {
+        prompt += `### ${pa.agentName}
+`;
+        if (pa.agentBio) prompt += `*${pa.agentBio}*
+`;
+        prompt += `**Instructions:** ${pa.agentPrompt}
+
+`;
+      }
+    }
     try {
       await this.dispatchAndWait(`[JobRun: ${jobRun.job_name}] ${prompt}`);
       await runner.completeRun(jobRun.id, "completed", "Job executed via web trigger");

package/dist/{job-runner-NA3KJCKA.js → job-runner-4KTCVIQP.js}

@@ -1,6 +1,6 @@
 import {
   JobRunner
-} from "./chunk-5ML5YMCM.js";
+} from "./chunk-RRMI6RDG.js";
 import "./chunk-YHUARPU7.js";
 import "./chunk-ZUUASYPZ.js";
 export {

package/dist/workers/entry.js

@@ -2,8 +2,8 @@
 import {
   TaskProcessor,
   getBrowser
-} from "../chunk-MP4E522X.js";
-import "../chunk-5ML5YMCM.js";
+} from "../chunk-E27P57PM.js";
+import "../chunk-RRMI6RDG.js";
 import {
   setLogTransport
 } from "../chunk-YHUARPU7.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.8.12",
+  "version": "0.9.0",
   "description": "AssistMe CLI Agent - AI-powered agentic assistant for code, browser, and automation",
   "type": "module",
   "main": "dist/index.js",

package/src/agent/execution/processor.ts

@@ -194,6 +194,15 @@ export class TaskProcessor {
     newCorrelationId();
     log.info(`Processing task ${task.id.slice(0, 8)}...`);
 
+    // Set agent memory context if this task is from a job agent
+    const taskAgentId =
+      (task.metadata?.agent_id as string) ||
+      (task.sender_id !== this.userId ? task.sender_id : null);
+    if (taskAgentId && this.memoryManager && this.userId) {
+      this.memoryManager.setAgentContext(taskAgentId, this.userId);
+      log.debug(`Memory context set to agent ${taskAgentId.slice(0, 8)}`);
+    }
+
     const toolCallRecords: ToolCallRecord[] = [];
     const toolFailures: ToolFailureRecord[] = [];
 
@@ -266,6 +275,11 @@ export class TaskProcessor {
     } finally {
       setCorrelationId(null);
 
+      // Clear agent memory context so next task uses default user scope
+      if (taskAgentId && this.memoryManager) {
+        this.memoryManager.clearAgentContext();
+      }
+
       try {
         const browser = getBrowser();
         if (browser.isConnected()) {

package/src/agent/memory/manager.ts

@@ -21,14 +21,53 @@ export interface Memory {
   last_accessed_at: string | null;
   expires_at: string | null;
   created_at: string;
+  /** Set by the backend when this memory comes from the owner (human user)
+   *  rather than the agent itself. Only present in agent-scoped get_context. */
+  _from_owner?: boolean;
 }
 
 // ── Memory Manager ──────────────────────────────────────────────────
 
 export class MemoryManager {
   /**
-   * Store a new memory. Called by the agent after completing tasks
-   * to remember important facts about the user.
+   * When set, all memory operations use this agent's users.id as the
+   * effective user, giving the agent its own memory space.
+   */
+  private agentUserId: string | null = null;
+  /** The human owner's user ID — used to load owner memories as fallback. */
+  private ownerUserId: string | null = null;
+
+  /**
+   * Configure agent-scoped memory.
+   * @param agentUserId  The agent's users.id — memories are stored/read here
+   * @param ownerUserId  The human owner's users.id — owner memories loaded as fallback
+   */
+  setAgentContext(agentUserId: string, ownerUserId: string): void {
+    this.agentUserId = agentUserId;
+    this.ownerUserId = ownerUserId;
+  }
+
+  /** Clear agent context (revert to normal user-scoped mode). */
+  clearAgentContext(): void {
+    this.agentUserId = null;
+    this.ownerUserId = null;
+  }
+
+  /** Inject effective_user_id + owner_user_id into params. */
+  private agentParams(extra: Record<string, unknown> = {}): Record<string, unknown> {
+    const params: Record<string, unknown> = { ...extra };
+    if (this.agentUserId) {
+      params.effective_user_id = this.agentUserId;
+      if (this.ownerUserId) {
+        params.owner_user_id = this.ownerUserId;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * Store a new memory. Called by the agent after completing tasks.
+   * When agent context is set, stores under the agent's user_id.
    */
   async remember(
     content: string,
@@ -44,14 +83,14 @@ export class MemoryManager {
       ? new Date(Date.now() + options.expiresInDays * 86400_000).toISOString()
       : null;
 
-    const data = await callMcpHandler<Memory>("memory.store", {
+    const data = await callMcpHandler<Memory>("memory.store", this.agentParams({
       category,
       content,
       importance: options?.importance ?? 5,
       tags: options?.tags ?? [],
       source_message_id: options?.sourceMessageId ?? null,
       expires_at: expiresAt,
-    });
+    }));
 
     log.debug(`Memory stored: [${category}] ${content.slice(0, 80)}...`);
     return data;
@@ -62,10 +101,10 @@ export class MemoryManager {
    */
   async search(query: string, limit = 10): Promise<Memory[]> {
     try {
-      return await callMcpHandler<Memory[]>("memory.search", {
+      return await callMcpHandler<Memory[]>("memory.search", this.agentParams({
         query,
         limit,
-      });
+      }));
     } catch (err) {
       log.warn(`Memory search failed: ${err instanceof Error ? err.message : err}`);
       return [];
@@ -74,13 +113,13 @@ export class MemoryManager {
 
   /**
    * Get the most important/recent memories to include in context.
-   * Called before each task to build the agent's "working memory".
-   * Automatically filters out expired memories.
+   * When agent context is set, loads agent's memories first,
+   * then supplements with the owner's memories as fallback.
    */
   async getContext(maxItems = 20): Promise<Memory[]> {
-    const all = await callMcpHandler<Memory[]>("memory.get_context", {
+    const all = await callMcpHandler<Memory[]>("memory.get_context", this.agentParams({
       max_items: maxItems,
-    });
+    }));
 
     // Deduplicate by id
     const seen = new Set<string>();
@@ -98,39 +137,65 @@ export class MemoryManager {
     const memories = await this.getContext();
     if (memories.length === 0) return "";
 
-    const sections: Record<string, string[]> = {};
-
-    for (const m of memories) {
-      const key = m.category;
-      if (!sections[key]) sections[key] = [];
-      sections[key].push(`- ${m.content}`);
-    }
+    // Separate agent's own memories from owner's (only relevant in agent mode)
+    const hasOwnerFlag = memories.some((m) => m._from_owner);
+    const agentMemories = hasOwnerFlag
+      ? memories.filter((m) => !m._from_owner)
+      : memories;
+    const ownerMemories = hasOwnerFlag
+      ? memories.filter((m) => m._from_owner)
+      : [];
 
     const categoryLabels: Record<string, string> = {
       instruction: "Standing Instructions",
-      preference: "User Preferences",
+      preference: "Preferences",
       general: "Known Facts",
       context: "Context",
       skill_learned: "Learned Skills",
       fact: "Facts",
     };
 
-    let prompt = "\n\n## What You Know About The User\n";
-    for (const [cat, items] of Object.entries(sections)) {
-      prompt += `\n### ${categoryLabels[cat] || cat}\n`;
-      prompt += `${items.join("\n")  }\n`;
+    function formatSection(mems: Memory[]): string {
+      const sections: Record<string, string[]> = {};
+      for (const m of mems) {
+        const key = m.category;
+        if (!sections[key]) sections[key] = [];
+        sections[key].push(`- ${m.content}`);
+      }
+      let out = "";
+      for (const [cat, items] of Object.entries(sections)) {
+        out += `\n### ${categoryLabels[cat] || cat}\n`;
+        out += `${items.join("\n")}\n`;
+      }
+      return out;
+    }
+
+    let prompt = "";
+
+    if (agentMemories.length > 0) {
+      prompt += this.agentUserId
+        ? "\n\n## Your Memories\n"
+        : "\n\n## What You Know About The User\n";
+      prompt += formatSection(agentMemories);
     }
 
+    if (ownerMemories.length > 0) {
+      prompt += "\n\n## Owner's Context\n";
+      prompt += formatSection(ownerMemories);
+    }
+
+
+
     return prompt;
   }
 
   // ── CRUD for CLI ────────────────────────────────────────────
 
   async list(category?: MemoryCategory, limit = 20): Promise<Memory[]> {
-    const data = await callMcpHandler<Memory[]>("memory.list", {
+    const data = await callMcpHandler<Memory[]>("memory.list", this.agentParams({
       category: category || null,
       limit,
-    });
+    }));
     return data || [];
   }
 
@@ -144,13 +209,13 @@ export class MemoryManager {
   }
 
   async remove(memoryId: string): Promise<void> {
-    await callMcpHandler("memory.remove", { memory_id: memoryId });
+    await callMcpHandler("memory.remove", this.agentParams({ memory_id: memoryId }));
   }
 
   async clear(category?: MemoryCategory): Promise<number> {
-    const result = await callMcpHandler<{ count: number }>("memory.clear", {
+    const result = await callMcpHandler<{ count: number }>("memory.clear", this.agentParams({
       category: category || null,
-    });
+    }));
     return result.count;
   }
 

package/src/agent/scheduling/index.ts

@@ -2,7 +2,7 @@
  * Scheduling — orchestration, job lifecycle, task polling, and cron scheduling.
  */
 export { JobAnalysisPoller } from "./job-analysis-poller.js";
-export { type JobInfo, type JobRunInfo,JobRunner, type JobSkillInfo } from "./job-runner.js";
+export { type JobAgentInfo, type JobInfo, type JobRunInfo, JobRunner, type JobSkillInfo } from "./job-runner.js";
 export {
   createScheduledTask,
   deleteScheduledTask,

package/src/agent/scheduling/job-runner.ts

@@ -1,7 +1,7 @@
 import { callMcpHandler } from "../../db/api-client.js";
 import { errorMessage } from "../../utils/errors.js";
 import { log } from "../../utils/logger.js";
-import { JobListRowSchema, JobRowSchema, JobRunRowSchema, safeParse } from "../../utils/schemas.js";
+import { JobAgentSchema, JobListRowSchema, JobRowSchema, JobRunRowSchema, safeParse } from "../../utils/schemas.js";
 
 // ── Interfaces ─────────────────────────────────────────────────────
 
@@ -13,12 +13,22 @@ export interface JobSkillInfo {
   skillContent: string;
 }
 
+export interface JobAgentInfo {
+  agentId: string;
+  agentUsername: string;
+  agentName: string;
+  agentBio: string | null;
+  agentPrompt: string;
+  role: string;
+}
+
 export interface JobInfo {
   jobId: string;
   jobName: string;
   jobDescription: string;
   jobPrompt: string | null;
   skills: JobSkillInfo[];
+  agents: JobAgentInfo[];
 }
 
 export interface JobRunInfo {
@@ -55,6 +65,20 @@ export class JobRunner {
 
       const first = rows[0];
 
+      // Agents are attached to the first row only
+      const rawAgents = (first as Record<string, unknown>).agents as unknown[] || [];
+      const agents: JobAgentInfo[] = rawAgents
+        .map((a) => safeParse(JobAgentSchema, a))
+        .filter((a): a is NonNullable<typeof a> => a != null)
+        .map((a) => ({
+          agentId: a.agent_id,
+          agentUsername: a.agent_username,
+          agentName: a.agent_name || "",
+          agentBio: a.agent_bio ?? null,
+          agentPrompt: a.agent_prompt,
+          role: a.role,
+        }));
+
       return {
         jobId: first.job_id,
         jobName: first.job_name,
@@ -69,6 +93,7 @@ export class JobRunner {
             skillEmoji: row.skill_emoji,
             skillContent: row.skill_content,
           })),
+        agents,
       };
     } catch (err) {
       log.debug(`Failed to load job "${jobName}": ${errorMessage(err)}`);
@@ -80,7 +105,7 @@ export class JobRunner {
    * List all jobs for the user.
    */
   async listJobs(): Promise<
-    Array<{ id: string; name: string; description: string; skillCount: number }>
+    Array<{ id: string; name: string; description: string; skillCount: number; agentCount: number }>
   > {
     try {
       const data = await callMcpHandler<unknown[]>("job.list");
@@ -93,6 +118,7 @@ export class JobRunner {
           name: row.name,
           description: row.description,
           skillCount: row.skill_count,
+          agentCount: row.agent_count,
         }));
     } catch (err) {
       log.debug(`Failed to list jobs: ${errorMessage(err)}`);
@@ -190,14 +216,25 @@ export class JobRunner {
       prompt += `\n`;
     }
 
-    prompt += `## Instructions\n`;
+    prompt += `## Instructions\n\n`;
+    prompt += `### Step 1: Analyze and set up skills\n`;
     prompt += `For each capability the job needs:\n`;
     prompt += `1. Check if an existing skill covers it (use \`skill_search\` to check)\n`;
     prompt += `2. If no existing skill covers it, create a new one using \`skill_create\`\n`;
     prompt += `3. If an existing skill needs improvement, update it using \`skill_improve\`\n`;
     prompt += `4. Link all relevant skills to the job using \`skill_link_job\`\n\n`;
-    prompt += `Be practical — only create skills that would genuinely help automate this job.\n`;
-    prompt += `When done, summarize what skills were created, updated, or already existed.\n`;
+    prompt += `Be practical — only create skills that would genuinely help automate this job.\n\n`;
+
+    prompt += `### Step 2: Create the job's agent\n`;
+    prompt += `After setting up skills, create an agent for this job using \`job_assign_agent\`.\n`;
+    prompt += `The agent is the identity that will execute this job. Design it with:\n`;
+    prompt += `- **agent_name**: A concise, role-based name (e.g. "Daily Reporter", "Code Reviewer")\n`;
+    prompt += `- **agent_prompt**: A system prompt that defines the agent's behavior, expertise, and personality. `;
+    prompt += `Include the job's goals, preferred approach, and any domain knowledge the agent should have. `;
+    prompt += `Reference the linked skills as capabilities the agent can use.\n`;
+    prompt += `- **agent_bio**: A one-line description of what this agent does.\n\n`;
+
+    prompt += `When done, summarize what skills were created/updated and the agent that was assigned.\n`;
 
     return prompt;
   }
@@ -211,13 +248,41 @@ export class JobRunner {
    * chain them based on what it discovers at runtime.
    */
   buildJobPrompt(job: JobInfo, runId: string): string {
+    const primaryAgent = job.agents.length > 0
+      ? (job.agents.find((a) => a.role === "primary") || job.agents[0])
+      : null;
+    const parallelAgents = job.agents.filter(
+      (a) => a.role === "parallel" && a.agentId !== primaryAgent?.agentId,
+    );
     const effectiveDescription = job.jobPrompt || job.jobDescription;
     let prompt = `## Job: ${job.jobName}\n`;
     prompt += `*${effectiveDescription}*\n\n`;
     prompt += `**Run ID:** ${runId}\n\n`;
 
-    prompt += `You are now acting as "${job.jobName}". `;
-    prompt += `Your goal is to accomplish the objectives described above using the skills and tools available to you.\n\n`;
+    if (primaryAgent) {
+      prompt += `## Agent Identity\n`;
+      prompt += `You are **${primaryAgent.agentName}** (@${primaryAgent.agentUsername}).\n`;
+      if (primaryAgent.agentBio) {
+        prompt += `*${primaryAgent.agentBio}*\n`;
+      }
+      prompt += `\n### Agent Instructions\n`;
+      prompt += `${primaryAgent.agentPrompt}\n\n`;
+    } else {
+      prompt += `You are now acting as "${job.jobName}". `;
+      prompt += `Your goal is to accomplish the objectives described above using the skills and tools available to you.\n\n`;
+    }
+
+    if (parallelAgents.length > 0) {
+      prompt += `### Parallel Agents\n`;
+      prompt += `The following agents are running concurrently on this job. `;
+      prompt += `They handle their own tasks independently — coordinate to avoid duplicate work.\n\n`;
+      for (const pa of parallelAgents) {
+        prompt += `- **${pa.agentName}** (@${pa.agentUsername})`;
+        if (pa.agentBio) prompt += ` — ${pa.agentBio}`;
+        prompt += `\n`;
+      }
+      prompt += `\n`;
+    }
 
     prompt += `### Available Skills\n`;
     prompt += `These skills are your capabilities for this job. `;

package/src/db/api-client.ts

@@ -17,7 +17,7 @@ export async function callMcpHandler<T = unknown>(
 ): Promise<T> {
   const config = getConfig();
   const token = overrideToken || getRawToken();
-  const url = `${config.supabaseUrl}/functions/v1/mcp-handler`;
+  const url = `${config.supabaseUrl}/functions/v1/main-mcp-handler`;
 
   const response = await fetch(url, {
     method: "POST",

package/src/mcp/tools/job-tools.ts

@@ -26,7 +26,7 @@ export function createJobTools(sessionId?: string, taskId?: string) {
           const jobs = await runner.listJobs();
           const available =
             jobs.length > 0
-              ? `Available jobs: ${jobs.map((j) => `"${j.name}" (${j.skillCount} skills)`).join(", ")}`
+              ? `Available jobs: ${jobs.map((j) => `"${j.name}" (${j.skillCount} skills, ${j.agentCount} agents)`).join(", ")}`
               : "No jobs defined yet. Use skill_generate to create a job from a job description.";
           return textResponse(`Job "${args.job_name}" not found. ${available}`);
         }
@@ -72,13 +72,34 @@ export function createJobTools(sessionId?: string, taskId?: string) {
           }
         }
 
-        const prompt = runner.buildJobPrompt(job, runId || "untracked");
+        const effectiveRunId = runId || "untracked";
+        const prompt = runner.buildJobPrompt(job, effectiveRunId);
+
+        // Build parallel agent prompts if any
+        const primaryAgentForFilter = job.agents.length > 0
+          ? (job.agents.find((p) => p.role === "primary") || job.agents[0])
+          : null;
+        const parallelAgents = job.agents.filter(
+          (a) => a.role === "parallel" && a.agentId !== primaryAgentForFilter?.agentId,
+        );
+
+        let fullResponse = prompt;
+        if (parallelAgents.length > 0) {
+          fullResponse += `\n\n---\n\n## Parallel Agent Dispatch\n`;
+          fullResponse += `The following parallel agents are assigned to this job. `;
+          fullResponse += `After you complete your primary tasks, review their responsibilities and execute any that haven't been covered:\n\n`;
+          for (const pa of parallelAgents) {
+            fullResponse += `### ${pa.agentName} (@${pa.agentUsername})\n`;
+            if (pa.agentBio) fullResponse += `*${pa.agentBio}*\n`;
+            fullResponse += `**Instructions:** ${pa.agentPrompt}\n\n`;
+          }
+        }
 
         log.info(
-          `Job "${args.job_name}" started with ${job.skills.length} skills (run: ${runId?.slice(0, 8) || "untracked"})`
+          `Job "${args.job_name}" started with ${job.skills.length} skills, ${job.agents.length} agents (run: ${effectiveRunId.slice(0, 8)})`
         );
 
-        return textResponse(prompt);
+        return textResponse(fullResponse);
       })
     ),
     tool(
@@ -151,6 +172,89 @@ export function createJobTools(sessionId?: string, taskId?: string) {
         }
       )
     ),
+    tool(
+      "job_assign_agent",
+      "Create or update an agent for a job. The agent is a user with a specific prompt and identity that will execute this job.",
+      {
+        job_name: z.string().describe("Name of the job to assign the agent to"),
+        agent_name: z.string().describe("Display name for the agent (e.g. 'Daily Reporter')"),
+        agent_prompt: z.string().describe("The agent's system prompt that defines its behavior and personality"),
+        agent_bio: z.string().optional().describe("Short bio describing the agent's role"),
+        role: z.enum(["primary", "parallel"]).optional().describe("Agent role: 'primary' (default) or 'parallel' for concurrent execution"),
+      },
+      typedHandler(
+        async (args: {
+          job_name: string;
+          agent_name: string;
+          agent_prompt: string;
+          agent_bio?: string;
+          role?: string;
+        }) => {
+          try {
+            const result = await callMcpHandler<{
+              agent_id: string;
+              username: string;
+              job_id: string;
+            }>("job.save_agent", {
+              job_name: args.job_name,
+              agent_name: args.agent_name,
+              agent_prompt: args.agent_prompt,
+              agent_bio: args.agent_bio || null,
+              role: args.role || "primary",
+            });
+
+            if (!result) {
+              return textResponse(`Failed to create agent for job "${args.job_name}".`);
+            }
+
+            log.info(
+              `Agent "${result.username}" assigned to job "${args.job_name}" (${args.role || "primary"})`
+            );
+
+            let response = `## Agent Assigned to Job: ${args.job_name}\n\n`;
+            response += `- **Agent:** ${args.agent_name} (@${result.username})\n`;
+            response += `- **Role:** ${args.role || "primary"}\n`;
+            if (args.agent_bio) {
+              response += `- **Bio:** ${args.agent_bio}\n`;
+            }
+            response += `\nThe agent is now ready to execute this job.`;
+
+            return textResponse(response);
+          } catch (err) {
+            return textResponse(
+              `Failed to assign agent: ${err instanceof Error ? err.message : err}`
+            );
+          }
+        }
+      )
+    ),
+    tool(
+      "job_remove_agent",
+      "Remove (deactivate) an agent from a job.",
+      {
+        job_name: z.string().describe("Name of the job"),
+        agent_name: z.string().describe("Display name of the agent to remove"),
+      },
+      typedHandler(
+        async (args: { job_name: string; agent_name: string }) => {
+          try {
+            await callMcpHandler("job.remove_agent", {
+              job_name: args.job_name,
+              agent_name: args.agent_name,
+            });
+
+            log.info(`Agent "${args.agent_name}" removed from job "${args.job_name}"`);
+            return textResponse(
+              `Agent "${args.agent_name}" has been removed from job "${args.job_name}".`
+            );
+          } catch (err) {
+            return textResponse(
+              `Failed to remove agent: ${err instanceof Error ? err.message : err}`
+            );
+          }
+        }
+      )
+    ),
     tool(
       "job_status",
       "Check the status and run history of a job.",
@@ -171,7 +275,7 @@ export function createJobTools(sessionId?: string, taskId?: string) {
 
           let response = "## Your Jobs\n\n";
           for (const job of jobs) {
-            response += `- **${job.name}** (${job.skillCount} skills): ${job.description.slice(0, 100)}\n`;
+            response += `- **${job.name}** (${job.skillCount} skills, ${job.agentCount} agents): ${job.description.slice(0, 100)}\n`;
           }
           response += "\nUse `job_run` to execute a job, or `job_schedule` to automate it.";
           return textResponse(response);

package/src/orchestrator.ts

@@ -219,7 +219,24 @@ export class Orchestrator {
       log.debug(`Failed to link session to job run: ${linkErr}`);
     }
 
-    const prompt = runner.buildJobPrompt(job, jobRun.id);
+    let prompt = runner.buildJobPrompt(job, jobRun.id);
+
+    // Append parallel agent instructions so the primary agent covers all responsibilities
+    const primaryAgent = job.agents.length > 0
+      ? (job.agents.find((a) => a.role === "primary") || job.agents[0])
+      : null;
+    const parallelAgents = job.agents.filter(
+      (a) => a.role === "parallel" && a.agentId !== primaryAgent?.agentId,
+    );
+    if (parallelAgents.length > 0) {
+      prompt += `\n\n---\n\n## Parallel Agent Responsibilities\n`;
+      prompt += `The following agents are also assigned. Execute their responsibilities as part of this run:\n\n`;
+      for (const pa of parallelAgents) {
+        prompt += `### ${pa.agentName}\n`;
+        if (pa.agentBio) prompt += `*${pa.agentBio}*\n`;
+        prompt += `**Instructions:** ${pa.agentPrompt}\n\n`;
+      }
+    }
 
     try {
       await this.dispatchAndWait(`[JobRun: ${jobRun.job_name}] ${prompt}`);

package/src/utils/schemas.ts

@@ -49,6 +49,15 @@ export const SkillRowSchema = z.object({
 
 export type SkillRow = z.infer<typeof SkillRowSchema>;
 
+export const JobAgentSchema = z.object({
+  agent_id: z.string(),
+  agent_username: z.string(),
+  agent_name: z.string().optional().default(""),
+  agent_bio: z.string().optional().nullable(),
+  agent_prompt: z.string(),
+  role: z.string().optional().default("primary"),
+});
+
 export const JobRowSchema = z.object({
   job_id: z.string(),
   job_name: z.string(),
@@ -59,6 +68,7 @@ export const JobRowSchema = z.object({
   skill_description: z.string().optional().default(""),
   skill_emoji: z.string().optional().default(""),
   skill_content: z.string().optional().default(""),
+  agents: z.array(JobAgentSchema).optional().default([]),
 });
 
 export const JobListRowSchema = z.object({
@@ -67,6 +77,7 @@ export const JobListRowSchema = z.object({
   description: z.string().optional().default(""),
   prompt: z.string().optional().nullable(),
   skill_count: z.number().optional().default(0),
+  agent_count: z.number().optional().default(0),
 });
 
 export const JobRunRowSchema = z.object({

package/tests/agent/processor.test.ts

@@ -79,6 +79,8 @@ vi.mock("../../src/agent/memory/manager.js", () => ({
   MemoryManager: class MockMemoryManager {
     buildMemoryPrompt = vi.fn().mockResolvedValue("");
     remember = mockRemember;
+    setAgentContext = vi.fn();
+    clearAgentContext = vi.fn();
   },
 }));