macro-agent 0.1.5 → 0.1.7

package/src/map/sidecar.ts

@@ -64,6 +64,12 @@ export function createMAPSidecar(
     if (config.token) {
       parsed.searchParams.set("token", config.token);
     }
+    // Include swarm_id for stable identity across reconnections.
+    // When set, the hub reuses the pre-registered swarm record instead
+    // of auto-generating a new one on each connection.
+    if (config.swarmId) {
+      parsed.searchParams.set("swarm_id", config.swarmId);
+    }
     return parsed.toString();
   }
 
@@ -107,6 +113,10 @@ export function createMAPSidecar(
         role: "sidecar",
         scopes: [scope],
         capabilities: {
+          messaging: { canSend: true, canReceive: true },
+          mail: { canCreate: true, canJoin: true, canViewHistory: true },
+          protocols: ['acp'],
+          acp: { version: '2024-10-07' },
           trajectory: { canReport: true, canServeContent: false },
           tasks: {
             canCreate: true,
@@ -253,31 +263,14 @@ export function createMAPSidecar(
     const { createTrajectoryReporter } = await import("./trajectory-reporter.js");
     trajectoryReporter = createTrajectoryReporter(connection, config);
 
-    // 4. Workspace Handler (for x-workspace/task.execute)
-    const { MacroAgentBackend } = await import("../cognitive/macro-agent-backend.js");
-    const { handleWorkspaceExecute, isWorkspaceExecuteMessage } = await import("../cognitive/workspace-handler.js");
-    const workspaceBackend = new MacroAgentBackend(agentManager, {});
-    const sendToHub = (msg: { method?: string; params?: unknown }) => {
-      if (msg.method && msg.params) {
-        connection.sendNotification(msg.method, msg.params as Record<string, unknown>);
-      }
-    };
-    const workspaceHandler = {
-      handleWorkspaceExecute: (params: unknown) =>
-        handleWorkspaceExecute(
-          { backend: workspaceBackend, sendToHub },
-          params as import("agent-workspace").WorkspaceExecuteParams,
-        ),
-      isWorkspaceExecuteMessage,
-    };
-
-    // 5. Coordination Handler
+    // 4. Coordination Handler
     const { setupCoordinationHandlers } = await import("./coordination-handler.js");
     coordinationCleanup = setupCoordinationHandlers({
       connection,
+      agentManager,
       inboxAdapter,
       tasksAdapter,
-      workspaceHandler,
+      trajectoryReporter,
     });
   }
 

package/src/map/trajectory-reporter.ts

@@ -2,10 +2,8 @@
  * Trajectory Reporter — builds and reports trajectory checkpoints to the MAP hub.
  *
  * Sends checkpoints via the `trajectory/checkpoint` JSON-RPC extension.
- * Handles inbound `trajectory/content.request` notifications by serving
- * session transcripts via sessionlog's SessionStore and CheckpointStore.
- * Supports all agent types (Claude Code, Codex, Gemini, etc.) through
- * sessionlog's adapter system.
+ * Also handles inbound `trajectory/content.request` notifications by serving
+ * session transcript data.
  *
  * @module map/trajectory-reporter
  */
@@ -36,173 +34,37 @@ export interface TrajectoryConnection {
   get isConnected(): boolean;
 }
 
-/**
- * Resolve transcript content for a checkpoint ID using sessionlog.
- *
- * Two-source strategy (matching cc-swarm):
- * 1. Live session — use sessionlog's SessionStore to find a session
- *    matching the checkpoint ID, then read its transcript from disk.
- * 2. Committed checkpoint — use sessionlog's CheckpointStore to read
- *    content from the git history.
- *
- * Returns null if no content is found or sessionlog is unavailable.
- */
-async function resolveContent(
-  checkpointId: string,
-  sessionDirs: string[],
-): Promise<{
-  transcript: string;
-  metadata: Record<string, unknown>;
-  prompts: string;
-  context: string;
-} | null> {
-  let sessionlog: typeof import("sessionlog") | null = null;
-  try {
-    sessionlog = await import("sessionlog");
-  } catch {
-    return null; // sessionlog not available
-  }
-
-  const { readFileSync, existsSync } = await import("node:fs");
-
-  // Derive the session ID from checkpoint ID (e.g., "sess-abc-step3" → "sess-abc")
-  const sessionId = checkpointId.replace(/-step\d+$/, "");
-
-  // ── 1. Live session lookup via SessionStore ────────────────────────────
-  for (const sessionsDir of sessionDirs) {
-    if (!existsSync(sessionsDir)) continue;
-
-    try {
-      const store = sessionlog.createSessionStore(undefined, sessionsDir);
-      // Try loading by derived session ID first, then by raw checkpoint ID
-      let state = await store.load(sessionId);
-      if (!state) state = await store.load(checkpointId);
-
-      // If not found by ID, scan all sessions for checkpoint match
-      if (!state) {
-        const allSessions = await store.list();
-        state = allSessions.find((s) =>
-          s.lastCheckpointID === checkpointId ||
-          (s.turnCheckpointIDs || []).includes(checkpointId),
-        ) ?? null;
-      }
-
-      if (!state?.transcriptPath || !existsSync(state.transcriptPath)) continue;
-
-      const transcript = readFileSync(state.transcriptPath, "utf-8");
-
-      // Use sessionlog's prompt extraction if the agent has a TranscriptAnalyzer,
-      // otherwise fall back to the prompts stored in state
-      let prompts = "";
-      if (state.firstPrompt) {
-        // Collect from promptAttributions if available, otherwise use firstPrompt
-        const attrs = state.promptAttributions;
-        if (attrs && attrs.length > 0) {
-          prompts = attrs.map((a) => a.prompt).join("\n---\n");
-        } else {
-          prompts = state.firstPrompt;
-        }
-      }
-
-      return {
-        transcript,
-        prompts,
-        metadata: {
-          sessionID: state.sessionID,
-          phase: state.phase,
-          agentType: state.agentType,
-          stepCount: state.stepCount || 0,
-          filesTouched: state.filesTouched || [],
-          tokenUsage: state.tokenUsage || {},
-          startedAt: state.startedAt,
-          endedAt: state.endedAt,
-          source: "live",
-        },
-        context: `Session ${state.sessionID} (${state.phase})`,
-      };
-    } catch {
-      continue;
-    }
-  }
-
-  // ── 2. Committed checkpoint via CheckpointStore ────────────────────────
-  try {
-    if (sessionlog.createCheckpointStore) {
-      const store = sessionlog.createCheckpointStore();
-      const content = await store.readSessionContent(checkpointId, 0);
-      if (content) {
-        return {
-          transcript: content.transcript,
-          prompts: content.prompts,
-          metadata: { ...content.metadata, source: "committed" },
-          context: content.context,
-        };
-      }
-    }
-  } catch {
-    // Checkpoint not found or store unavailable
-  }
-
-  return null;
-}
-
 /**
  * Create a trajectory reporter that sends checkpoints to the MAP hub
- * and serves session transcript content on demand via sessionlog.
+ * and serves content on demand.
  */
 export function createTrajectoryReporter(
   connection: TrajectoryConnection,
-  config: Pick<MAPSidecarConfig, "trajectorySyncLevel"> & {
-    /** Additional session directories to search for transcripts */
-    sessionDirs?: string[];
-  },
+  config: Pick<MAPSidecarConfig, "trajectorySyncLevel">,
 ): TrajectoryReporter {
   // Cache the resource_id from the first checkpoint response
   // so subsequent calls reuse it (avoids creating duplicate session resources)
   let cachedResourceId: string | undefined;
 
-  // Build session directory search list
-  const defaultDirs: string[] = [];
-  try {
-    const cwd = process.cwd();
-    defaultDirs.push(
-      `${cwd}/.git/sessionlog-sessions`,
-      `${cwd}/.swarm/sessionlog/sessions`,
-    );
-  } catch {
-    // Can't resolve paths — will use config dirs only
-  }
-  const sessionDirs = [...(config.sessionDirs ?? []), ...defaultDirs];
-
   // Handler for inbound content requests
   const contentHandler = async (params: unknown): Promise<void> => {
     const req = params as TrajectoryContentRequest;
     if (!req?.request_id) return;
 
     try {
-      const content = await resolveContent(
-        req.checkpoint_id,
-        sessionDirs,
-      );
-
-      if (content) {
-        await connection.sendNotification("trajectory/content.response", {
-          request_id: req.request_id,
-          transcript: content.transcript,
-          metadata: content.metadata,
-          prompts: content.prompts,
-          context: content.context,
-        });
-      } else {
-        await connection.sendNotification("trajectory/content.response", {
-          request_id: req.request_id,
-          transcript: "",
-          metadata: { source: "macro-agent" },
-          prompts: "",
-          context: "",
-        });
-      }
+      // Respond with what we have — macro-agent doesn't store full transcripts
+      // like sessionlog does, so we send a minimal response.
+      // Future: integrate with ACP session history for richer content.
+      await connection.sendNotification("trajectory/content.response", {
+        request_id: req.request_id,
+        transcript: null,
+        metadata: {
+          source: "macro-agent",
+          note: "Full transcript serving not yet implemented",
+        },
+      });
     } catch {
+      // Best effort
       try {
         await connection.sendNotification("trajectory/content.response", {
           request_id: req.request_id,

package/src/map/types.ts

@@ -35,6 +35,9 @@ export interface MAPSidecarConfig {
   /** Agent name for MAP registration (default: "macro-agent-sidecar") */
   agentName?: string;
 
+  /** Swarm ID for stable identity across reconnections */
+  swarmId?: string;
+
   /** Trajectory sync level */
   trajectorySyncLevel?: "off" | "lifecycle" | "metrics" | "full";
 
@@ -145,8 +148,46 @@ export interface TrajectoryContentRequest {
 // Coordination Wire Format
 // =============================================================================
 
-// Coordination uses generic MAP scope messages — see coordination-handler.ts.
-// Wire format types are inlined there; no custom types needed here.
+/** Inbound task assignment from hub */
+export interface CoordinationTaskAssign {
+  title: string;
+  description?: string;
+  assigned_to?: string;
+  assigned_by: string;
+  priority?: string;
+  context?: Record<string, unknown>;
+  deadline?: string;
+}
+
+/** Inbound task status update from hub */
+export interface CoordinationTaskStatus {
+  task_id: string;
+  status: string;
+  progress?: number;
+  result?: unknown;
+  error?: string;
+}
+
+/** Inbound context share from hub */
+export interface CoordinationContextShare {
+  hive_id?: string;
+  source_swarm_id: string;
+  context_type: string;
+  data: unknown;
+  target_swarm_ids?: string[];
+  ttl_seconds?: number;
+}
+
+/** Inbound message from hub */
+export interface CoordinationMessage {
+  hive_id?: string;
+  from_swarm_id: string;
+  to_swarm_id: string;
+  content_type: string;
+  content: unknown;
+  reply_to?: string;
+  metadata?: Record<string, unknown>;
+}
 
 // =============================================================================
 // Internal Bridge Types