@shipers-dev/multi 0.6.8 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.6.8",
+  "version": "0.8.0",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"

package/src/client.ts

@@ -38,9 +38,9 @@ async function request<T>(url: string, options?: RequestInit): Promise<ApiRespon
 
 export const apiClient = {
   get: <T = unknown>(url: string) => request<T>(url),
-  post: <T = unknown>(url: string, body: unknown) =>
-    request<T>(url, { method: 'POST', body: JSON.stringify(body) }),
-  patch: <T = unknown>(url: string, body: unknown) =>
-    request<T>(url, { method: 'PATCH', body: JSON.stringify(body) }),
+  post: <T = unknown>(url: string, body: unknown, opts?: { headers?: Record<string, string> }) =>
+    request<T>(url, { method: 'POST', body: JSON.stringify(body), headers: opts?.headers }),
+  patch: <T = unknown>(url: string, body: unknown, opts?: { headers?: Record<string, string> }) =>
+    request<T>(url, { method: 'PATCH', body: JSON.stringify(body), headers: opts?.headers }),
   delete: <T = unknown>(url: string) => request<T>(url, { method: 'DELETE' }),
 };

package/src/index.ts

@@ -17,7 +17,7 @@ const LOG_PATH = join(MULTI_DIR, 'logs', 'agent.log');
 const SKILLS_DIR = join(MULTI_DIR, 'skills');
 const STOP_PATH = join(MULTI_DIR, 'stop.flag');
 const TASKS_DB_PATH = join(MULTI_DIR, 'tasks.db');
-const VERSION = '0.6.7';
+const VERSION = '0.8.0';
 
 const COMMANDS = {
   setup: 'Register this device with a workspace',
@@ -257,6 +257,7 @@ async function cmdConnect(apiUrl: string, config: Config) {
   let workerWake: (() => void) | null = null;
   const notifyWorker = () => { try { workerWake?.(); workerWake = null; } catch {} };
 
+
   // Local HTTP server on a free port
   const port = await pickFreePort();
   const expectedAuth = `Bearer ${config.dispatchSecret}`;
@@ -328,7 +329,7 @@ async function cmdConnect(apiUrl: string, config: Config) {
       db.run("UPDATE tasks SET status = 'running', started_at = unixepoch(), attempts = attempts + 1 WHERE id = ?", [row.id]);
       try {
         const task = JSON.parse(row.payload);
-        await handleRunTask(apiUrl, config.deviceId!, task, detected);
+        await handleRunTask(apiUrl, config.deviceId!, task, detected, {});
         db.run("UPDATE tasks SET status = 'done', finished_at = unixepoch() WHERE id = ?", [row.id]);
       } catch (e) {
         log(`task ${row.id} error: ${String(e)}`);
@@ -406,7 +407,11 @@ async function parseTunnelUrl(stream: ReadableStream<Uint8Array>): Promise<strin
   return null;
 }
 
-async function handleRunTask(apiUrl: string, deviceId: string, task: any, detected: { type: string; path: string }[]) {
+interface RuntimeCtx {
+  // Reserved for future runtime-scoped helpers.
+}
+
+async function handleRunTask(apiUrl: string, deviceId: string, task: any, detected: { type: string; path: string }[], ctx?: RuntimeCtx) {
   const issueId = task.issue_id;
   const isFollowup = !!task.followup;
   const workingDir = task.working_dir && existsSync(task.working_dir) ? task.working_dir : undefined;
@@ -622,13 +627,13 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
 
   try {
     if (useAcp) {
-      const base = `${task.title}\n\n${task.description || ''}`.trim();
+      const issueContext = `## Issue ${task.key}: ${task.title}${task.description ? `\n\n${task.description}` : ''}`;
       let userPart: string;
       if (task.followup) {
         const cleanFollowup = stripSelfMention(task.followup, preferType);
-        userPart = `# New user message — THIS is the current request\n\n${cleanFollowup}\n\n---\n*Earlier thread (${task.key} "${task.title}") is only background context. Do not re-address the original task unless the new message explicitly refers back to it.*`;
+        userPart = `${issueContext}\n\n---\n\n## New user message — current request\n\n${cleanFollowup}`;
       } else {
-        userPart = stripSelfMention(base || task.title, preferType);
+        userPart = stripSelfMention(issueContext, preferType);
       }
       if (attachmentRefs.length) {
         const lines = attachmentRefs.map(a => `- ${a.filename}: ${a.path}`).join('\n');
@@ -658,6 +663,8 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
         log(`preamble fetch failed: ${String(e)}`);
       }
 
+      preamble += await buildPlanningPreamble(apiUrl, task);
+
       const prompt = preamble ? `${preamble}\n---\n\n${userPart}` : userPart;
 
       // Pick adapter for the agent's declared type if we have it, else first ACP-capable
@@ -699,13 +706,14 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
           }
         }
       } catch {}
-      const base = `${task.title}\n\n${task.description || ''}`.trim();
+      preamble += await buildPlanningPreamble(apiUrl, task);
+      const issueContext = `## Issue ${task.key}: ${task.title}${task.description ? `\n\n${task.description}` : ''}`;
       let userPart: string;
       if (task.followup) {
         const cleanFollowup = stripSelfMention(task.followup, preferType);
-        userPart = `# New user message — THIS is the current request\n\n${cleanFollowup}\n\n---\n*Earlier thread (${task.key} "${task.title}") is only background context. Do not re-address the original task unless the new message explicitly refers back to it.*`;
+        userPart = `${issueContext}\n\n---\n\n## New user message — current request\n\n${cleanFollowup}`;
       } else {
-        userPart = stripSelfMention(base || task.title, preferType);
+        userPart = stripSelfMention(issueContext, preferType);
       }
       if (attachmentRefs.length) {
         const lines = attachmentRefs.map(a => `- ${a.filename}: ${a.path}`).join('\n');
@@ -733,6 +741,18 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
       if (n > 0) log(`  📎 uploaded ${n} output file(s)`);
     }
 
+    // Post-turn: scan agent text for `multi-plan` fenced blocks and execute mutations.
+    if (ctx) {
+      const fullText = turn.blocks.filter(b => b.kind === 'text').map(b => (b as any).text).join('\n');
+      const actions = extractPlanActions(fullText);
+      if (actions.length) {
+        const summary = await executePlanActions(apiUrl, task, actions, ctx);
+        if (summary) {
+          try { await apiClient.post(`${apiUrl}/api/issues/${issueId}/comments`, { author_type: 'agent', author_id: task.agent_id, author_name: 'agent', body: summary }); } catch {}
+        }
+      }
+    }
+
     // Visible fallback: agent ran but emitted nothing user-facing
     if (!hasAssistantText && !hadError) {
       const stopReason = turn.result?.stopReason || 'unknown';
@@ -750,6 +770,147 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
   }
 }
 
+// Appended to agent prompt. Teaches the agent how to emit planning actions the
+// daemon will execute after the turn: create sub-issues, update any issue in
+// the project, or delegate to other agents.
+async function buildPlanningPreamble(apiUrl: string, task: any): Promise<string> {
+  const depth = typeof task.planning_depth === 'number' ? task.planning_depth : 0;
+  if (depth >= 1) {
+    return `# Planning (sub-task context)
+
+You are acting on a sub-issue spawned by another agent. You MAY emit a \`multi-plan\` block to update your own issue's status (e.g. mark done/failed) but CANNOT create child issues or delegate further.
+
+\`\`\`multi-plan
+{"actions":[{"type":"update","id":"<this issue id>","status":"done"}]}
+\`\`\`
+
+`;
+  }
+  let projectId = '';
+  let agentsBlock = '';
+  try {
+    const issueRes = await apiClient.get<any>(`${apiUrl}/api/issues/${task.issue_id}`);
+    projectId = issueRes.data?.project_id || '';
+    const agentRes = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
+    const workspaceId = agentRes.data?.workspace_id;
+    if (workspaceId) {
+      const ag = await apiClient.get<any[]>(`${apiUrl}/api/agents?workspace_id=${workspaceId}`);
+      const list = Array.isArray(ag.data) ? ag.data : [];
+      const others = list.filter(a => a.id !== task.agent_id);
+      if (others.length) {
+        agentsBlock = others.map(a => `- \`${a.id}\` (${a.name}${a.type ? `, ${a.type}` : ''})`).join('\n');
+      }
+    }
+  } catch {}
+
+  return `# Planning & delegation
+
+After finishing your reply, you may append ONE fenced block to create child issues, update any issue in this project, or delegate to another agent. The daemon parses this block and executes the actions after your turn.
+
+Syntax:
+
+\`\`\`multi-plan
+{"actions":[
+  {"type":"create","title":"...","description":"...","assignee_type":"agent","assignee_id":"<agent id>"},
+  {"type":"update","id":"<issue id>","status":"done"},
+  {"type":"delegate","id":"<issue id>","assignee_id":"<agent id>"}
+]}
+\`\`\`
+
+Rules:
+- Omit the block entirely if no actions are needed.
+- Max 10 actions per turn; additional actions are dropped.
+- Sub-issues spawned from your plan run one-shot: they cannot themselves spawn further children (only \`update\` allowed there).
+- \`create\` defaults \`project_id\` to the current project and \`parent_id\` to the current issue.
+- \`update\` may change title, description, status (todo/in_progress/done/failed), priority, assignee_type, assignee_id.
+- \`delegate\` is shorthand for reassigning and resetting status to todo.
+- Only target issues in the current project (${projectId || 'this project'}).
+
+${agentsBlock ? `Available agents you can delegate to:\n${agentsBlock}\n` : ''}`;
+}
+
+type PlanAction =
+  | { type: 'create'; project_id?: string; title: string; description?: string; priority?: string; assignee_type?: string; assignee_id?: string; parent_id?: string }
+  | { type: 'update'; id: string; title?: string; description?: string; status?: string; priority?: string; assignee_type?: string; assignee_id?: string }
+  | { type: 'delegate'; id: string; assignee_id: string };
+
+// Extract JSON action blocks fenced as ```multi-plan ... ```
+function extractPlanActions(text: string): PlanAction[] {
+  const out: PlanAction[] = [];
+  if (!text) return out;
+  const re = /```multi-plan\s*\n([\s\S]*?)\n```/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text)) !== null) {
+    try {
+      const parsed = JSON.parse(m[1]);
+      const actions = Array.isArray(parsed?.actions) ? parsed.actions : Array.isArray(parsed) ? parsed : [parsed];
+      for (const a of actions) if (a && typeof a === 'object' && typeof a.type === 'string') out.push(a as PlanAction);
+    } catch {}
+  }
+  return out;
+}
+
+const PLAN_ACTION_LIMIT = 10;
+
+async function executePlanActions(apiUrl: string, parentTask: any, actions: PlanAction[], _ctx: RuntimeCtx): Promise<string> {
+  const lines: string[] = [];
+  let truncated = false;
+  if (actions.length > PLAN_ACTION_LIMIT) {
+    truncated = true;
+    actions = actions.slice(0, PLAN_ACTION_LIMIT);
+  }
+  // Prevent agent recursion: a child turn's plan cannot itself spawn more children.
+  // `planning_depth` is carried on each dispatched task (set server-side from issue row).
+  const depth = typeof parentTask.planning_depth === 'number' ? parentTask.planning_depth : 0;
+  if (depth >= 1) {
+    const blocked = actions.filter(a => a.type === 'create' || a.type === 'delegate').length;
+    actions = actions.filter(a => a.type === 'update');
+    if (blocked) lines.push(`- ⚠ ${blocked} create/delegate action(s) blocked (planning depth limit)`);
+  }
+  const parentId = parentTask.issue_id;
+  const parentProjectId = await (async () => {
+    try {
+      const r = await apiClient.get<any>(`${apiUrl}/api/issues/${parentId}`);
+      return r.data?.project_id;
+    } catch { return null; }
+  })();
+  const headers = { 'x-agent-id': parentTask.agent_id };
+
+  // Refresh the set of agents linked to this device once per plan execution.
+  await ctx.refreshLocalAgents();
+
+  for (const a of actions) {
+    try {
+      if (a.type === 'create') {
+        const body = {
+          action: 'create' as const,
+          project_id: a.project_id || parentProjectId,
+          title: a.title, description: a.description,
+          priority: a.priority, assignee_type: a.assignee_type, assignee_id: a.assignee_id,
+          parent_id: a.parent_id || parentId,
+        };
+        const res = await apiClient.post<any>(`${apiUrl}/api/issues/agent/mutate`, body, { headers });
+        if (!res.success) { lines.push(`- ❌ create "${a.title}": ${res.error || res.status}`); continue; }
+        const created = res.data;
+        lines.push(`- ✓ created **${created.key}** — ${created.title}${created.assignee_id ? ` → @${created.assignee_id}` : ''} (autonomy=${created.autonomy_level || 'ask'})`);
+      } else if (a.type === 'update') {
+        const res = await apiClient.post<any>(`${apiUrl}/api/issues/agent/mutate`, { action: 'update', ...a }, { headers });
+        if (!res.success) { lines.push(`- ❌ update ${a.id}: ${res.error || res.status}`); continue; }
+        lines.push(`- ✓ updated ${res.data.key}`);
+      } else if (a.type === 'delegate') {
+        const res = await apiClient.post<any>(`${apiUrl}/api/issues/agent/mutate`, { action: 'update', id: a.id, assignee_type: 'agent', assignee_id: a.assignee_id, status: 'todo' }, { headers });
+        if (!res.success) { lines.push(`- ❌ delegate ${a.id}: ${res.error || res.status}`); continue; }
+        lines.push(`- ✓ delegated ${res.data.key} → ${a.assignee_id}`);
+      }
+    } catch (e) {
+      lines.push(`- ❌ ${a.type} failed: ${String(e)}`);
+    }
+  }
+  if (truncated) lines.push(`- ⚠ action list truncated at ${PLAN_ACTION_LIMIT}`);
+  if (!lines.length) return '';
+  return `**Planning actions**\n\n${lines.join('\n')}`;
+}
+
 function stripMd(s: string): string {
   return s.replace(/[`*_]/g, '').trim();
 }