assistme 0.8.12 → 0.9.1

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-O5K33FBW.js}

@@ -8,7 +8,7 @@ import {
   readAuthStore,
   safeParse,
   writeAuthStore
-} from "./chunk-5ML5YMCM.js";
+} from "./chunk-RRMI6RDG.js";
 import {
   log,
   newCorrelationId,
@@ -318,6 +318,7 @@ var CDP_SETTLE_MS = 300;
 var PAGE_TRANSITION_MS = 500;
 var MAX_WAIT_MS = 5e3;
 var SCREENSHOT_QUALITY = 80;
+var SCREENSHOT_MAX_DIM_PX = 1568;
 function delay(ms) {
   return new Promise((r) => {
     setTimeout(r, ms);
@@ -809,6 +810,56 @@ async function tryDismissOverlay(conn) {
   }
 }
 
+// src/browser/screenshot.ts
+async function getViewportMetrics(conn) {
+  try {
+    const result = await conn.send("Runtime.evaluate", {
+      expression: `JSON.stringify({ width: window.innerWidth, height: window.innerHeight, dpr: window.devicePixelRatio || 1 })`,
+      returnByValue: true
+    });
+    const value = result.result?.value;
+    if (value) {
+      const parsed = JSON.parse(value);
+      const width = Number(parsed.width) || 0;
+      const height = Number(parsed.height) || 0;
+      const dpr = Number(parsed.dpr) || 1;
+      if (width > 0 && height > 0) {
+        return { width, height, dpr };
+      }
+    }
+  } catch {
+  }
+  return { width: 0, height: 0, dpr: 1 };
+}
+async function captureBoundedScreenshot(conn, maxDim = SCREENSHOT_MAX_DIM_PX) {
+  const { width, height, dpr } = await getViewportMetrics(conn);
+  if (width === 0 || height === 0) {
+    const result2 = await conn.send("Page.captureScreenshot", {
+      format: "png",
+      quality: SCREENSHOT_QUALITY,
+      captureBeyondViewport: false
+    });
+    return result2.data || "";
+  }
+  const naturalMax = Math.max(width, height) * dpr;
+  if (naturalMax <= maxDim) {
+    const result2 = await conn.send("Page.captureScreenshot", {
+      format: "png",
+      quality: SCREENSHOT_QUALITY,
+      captureBeyondViewport: false
+    });
+    return result2.data || "";
+  }
+  const scale = Math.min(dpr, maxDim / Math.max(width, height));
+  const result = await conn.send("Page.captureScreenshot", {
+    format: "png",
+    quality: SCREENSHOT_QUALITY,
+    captureBeyondViewport: false,
+    clip: { x: 0, y: 0, width, height, scale }
+  });
+  return result.data || "";
+}
+
 // src/browser/actions.ts
 var Actions = class {
   constructor(conn, snapshotEngine) {
@@ -1004,12 +1055,7 @@ var Actions = class {
     let screenshot;
     if (takeScreenshot) {
       await delay(CDP_SETTLE_MS);
-      const screenshotResult = await this.conn.send("Page.captureScreenshot", {
-        format: "png",
-        quality: SCREENSHOT_QUALITY,
-        captureBeyondViewport: false
-      });
-      screenshot = screenshotResult.data || "";
+      screenshot = await captureBoundedScreenshot(this.conn);
     }
     return { results, screenshot };
   }
@@ -1378,12 +1424,7 @@ URL: ${info.url}`;
   }
   async screenshot() {
     this.conn.ensureConnected();
-    const result = await this.conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false
-    });
-    return result.data || "";
+    return captureBoundedScreenshot(this.conn);
   }
   async detectLoginPage() {
     try {
@@ -1833,12 +1874,7 @@ var SnapshotEngine = class {
         expression: buildAnnotationOverlayJS(refsJson)
       });
     }
-    const screenshotResult = await this.conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false
-    });
-    const image = screenshotResult.data || "";
+    const image = await captureBoundedScreenshot(this.conn);
     if (annotate) {
       await this.conn.send("Runtime.evaluate", {
         expression: `(function() { var el = document.getElementById('__assistme_refs__'); if (el) el.remove(); })()`
@@ -2833,19 +2869,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 +2922,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 +2933,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 +2953,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 +5611,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 +5652,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 +5749,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 +5841,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 +8604,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 +8668,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-O5K33FBW.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");