macro-agent 0.1.10 → 0.1.11

package/src/map/coordination-handler.ts

@@ -75,12 +75,24 @@ export function setupCoordinationHandlers(
     if (!p?.title) return;
 
     try {
-      // Create task in opentasks
+      // Extract tags and metadata from OpenHive context
+      const context = p.context ?? {};
+      const tags = Array.isArray(context.tags) ? context.tags as string[] : undefined;
+      const metadata: Record<string, unknown> = {
+        ...context,
+        ...(p.assigned_by ? { assigned_by: p.assigned_by } : {}),
+        ...(p.deadline ? { deadline: p.deadline } : {}),
+      };
+      // Remove tags from metadata (already a top-level field)
+      delete metadata.tags;
+
       const taskId = await tasksAdapter.createTask({
         title: p.title,
         content: p.description,
         assignee: p.assigned_to,
+        tags,
         priority: p.priority === "critical" ? 1 : p.priority === "high" ? 2 : p.priority === "low" ? 4 : 3,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
       });
 
       // Optionally spawn an agent to work on the task

package/src/map/server.ts

@@ -74,6 +74,14 @@ export function createMAPServerInstance(
   const clientWebSockets = new Map<string, WebSocket>(); // participant/agent ID → WebSocket
   // Track subscription IDs by client agent ID for ACP response delivery
   const clientSubscriptions = new Map<string, string[]>(); // agent ID → subscription IDs
+  /**
+   * Per-subscription monotonic event counter. The MAP SDK's Subscription
+   * checks `sequenceNumber !== lastSequenceNumber + 1` and warns on gaps —
+   * using `Date.now()` (millisecond timestamp) breaks that assumption since
+   * each event becomes a "gap". Track a per-subscription counter starting
+   * at 1 and increment per event.
+   */
+  const subscriptionSequence = new Map<string, number>(); // subscription ID → next sequence number
   // Track original ws.send for each WebSocket (before interception)
   const originalSends = new Map<WebSocket, Function>();
 
@@ -90,11 +98,21 @@ export function createMAPServerInstance(
 
     // ── Agent extensions ──────────────────────────────────────────
     handlers["_macro/spawnAgent"] = async (params, ctx) => {
+      // Forward the full SpawnAgentOptions surface so callers can set
+      // permission mode, agent type, custom prompt, model config, etc.
+      // Previously this handler dropped everything except role/cwd/task,
+      // making _macro/spawnAgent useless for any non-default agent.
       const spawned = await agentManager.spawn({
         task: params.task ?? "Spawned via MAP",
         parent: params.parent ?? null,
         cwd: params.cwd,
         role: params.role ?? "worker",
+        permissionMode: params.permissionMode,
+        agentType: params.agentType,
+        customPrompt: params.customPrompt,
+        topics: params.topics,
+        config: params.config,
+        taskRef: params.taskRef,
       });
 
       // Ensure agent is registered in MAPServer's registry.
@@ -145,6 +163,128 @@ export function createMAPServerInstance(
       return { agent: { id: spawned.id } };
     };
 
+    /**
+     * Resume an agent session with full routing + session info returned.
+     *
+     * Session-first resolution: given a Claude Code `providerSessionId` (the
+     * session UUID persisted on the session record), reverse-look-up the
+     * owning agent. Falls back to `agentId` (either the MAP ULID or the
+     * local store id) when no providerSessionId is given or the reverse
+     * lookup misses.
+     *
+     * Behavior:
+     *   1. Resolve the local agent id.
+     *   2. Call `agentManager.resume(localId)` — idempotent; the manager
+     *      re-spawns the coordinator/head-manager if its process isn't live,
+     *      otherwise returns the existing handle.
+     *   3. Ensure the agent is registered in the MAPServer's registry so
+     *      ACP streams can target it via the returned peerMapId.
+     *   4. Return `{ agent: { id: peerMapId, localId, name }, acpSessionId,
+     *      providerSessionId }` — the caller needs peerMapId to open the
+     *      ACP stream and providerSessionId to pass into `session/load` so
+     *      Claude Code replays its on-disk transcript.
+     *
+     * Used by OpenHive's POST /sessions/:id/resume to revive a session whose
+     * swarm has been offline for longer than the hub's stale-grace window.
+     */
+    handlers["_macro/resumeAgent"] = async (params, ctx) => {
+      const providerSessionIdParam = params.providerSessionId as string | undefined;
+      const agentIdParam = params.agentId as string | undefined;
+
+      let localId: string | undefined;
+      let providerSessionId: string | undefined;
+
+      if (providerSessionIdParam) {
+        const session = agentStore.findSessionByProviderSessionId(providerSessionIdParam);
+        if (session) {
+          localId = session.agent_id;
+          providerSessionId = session.provider_session_id;
+        }
+      }
+
+      if (!localId && agentIdParam) {
+        localId = mapIdToLocalId.get(agentIdParam) ?? agentIdParam;
+        const session = agentStore.getSession(localId);
+        providerSessionId = session?.provider_session_id;
+      }
+
+      if (!localId) {
+        return {
+          success: false,
+          error: "providerSessionId or agentId required",
+        };
+      }
+
+      const agentRec = agentStore.getAgent(localId);
+      if (!agentRec) {
+        return { success: false, error: `Agent not found: ${localId}` };
+      }
+
+      // Already-running case: skip resume() (which rejects with ALREADY_RUNNING)
+      // and return the live agent's session info straight from the store.
+      // This makes the call idempotent — callers don't need to pre-check.
+      let resumedId: string;
+      let resumedSessionId: string;
+      let resumedName: string | undefined;
+      if (agentManager.hasActiveSession(localId as any)) {
+        resumedId = localId;
+        resumedName = agentRec.name;
+        const liveSession = agentStore.getSession(localId);
+        if (!liveSession) {
+          return {
+            success: false,
+            error: `Agent ${localId} is active but has no session record`,
+          };
+        }
+        resumedSessionId = liveSession.session_id;
+      } else {
+        try {
+          const resumed = await agentManager.resume(localId as any);
+          resumedId = resumed.id;
+          resumedSessionId = resumed.session_id;
+          resumedName = (resumed as any).name;
+        } catch (err) {
+          return { success: false, error: (err as Error).message };
+        }
+      }
+
+      // Ensure agent is registered in MAPServer's registry. resume() fires
+      // the spawned lifecycle event, which the lifecycle bridge handles —
+      // but we also register here for subscription routing context on the
+      // current MAP session (mirrors _macro/spawnAgent).
+      if (mapServer && !localIdToMapId.has(resumedId)) {
+        try {
+          const registered = mapServer.agents.register({
+            name: resumedName ?? resumedId,
+            role: agentRec.role,
+            state: "idle",
+            sessionId: ctx?.session?.id,
+            metadata: { peerAgentId: resumedId },
+          });
+          if (registered?.id) {
+            mapIdToLocalId.set(registered.id, resumedId);
+            localIdToMapId.set(resumedId, registered.id);
+          }
+        } catch {
+          // Best effort; lifecycle bridge will register on spawned event
+        }
+      }
+
+      const peerMapId = localIdToMapId.get(resumedId) ?? resumedId;
+
+      return {
+        success: true,
+        agent: {
+          id: peerMapId,
+          localId: resumedId,
+          name: resumedName,
+          role: agentRec.role,
+        },
+        acpSessionId: resumedSessionId,
+        providerSessionId,
+      };
+    };
+
     /**
      * Terminate a running agent. Accepts either the agent's local ID or the
      * MAP-assigned ULID (we resolve back to local via mapIdToLocalId).
@@ -288,15 +428,21 @@ export function createMAPServerInstance(
 
             // Send as subscription event notification (what ACPStreamConnection expects).
             // The _pushEvent method expects: { subscriptionId, sequenceNumber, eventId, timestamp, event }
+            //
+            // sequenceNumber must be a per-subscription monotonic counter that
+            // increments by exactly 1 — the SDK warns on any gap. Don't use
+            // Date.now() here (breaks the contract on every event).
             for (const subId of subIds) {
               const event = rawEvent.params?.event ?? rawEvent;
               const eventId = event.id ?? `acp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+              const nextSeq = (subscriptionSequence.get(subId) ?? 0) + 1;
+              subscriptionSequence.set(subId, nextSeq);
               const notification = JSON.stringify({
                 jsonrpc: "2.0",
                 method: "map/event",
                 params: {
                   subscriptionId: subId,
-                  sequenceNumber: Date.now(),
+                  sequenceNumber: nextSeq,
                   eventId,
                   timestamp: Date.now(),
                   event,
@@ -413,6 +559,32 @@ export function createMAPServerInstance(
           return originalSend(data, ...args);
         } as any;
 
+        // Observe incoming messages so we drop subscription IDs from our
+        // routing array when the client unsubscribes. Without this, closed
+        // ACP streams keep receiving events ("MAP: Event for unknown
+        // subscription" warnings on the client). We don't intercept the
+        // SDK's processing — this listener runs alongside it.
+        ws.on("message", (data: any) => {
+          try {
+            const text = typeof data === "string"
+              ? data
+              : Buffer.isBuffer(data)
+                ? data.toString("utf-8")
+                : String(data);
+            const msg = JSON.parse(text);
+            if (msg?.method === "map/unsubscribe") {
+              const subId = msg?.params?.subscriptionId;
+              if (typeof subId === "string") {
+                const idx = subscriptionIds.indexOf(subId);
+                if (idx >= 0) subscriptionIds.splice(idx, 1);
+                subscriptionSequence.delete(subId);
+              }
+            }
+          } catch {
+            // Non-JSON or parse failure — ignore
+          }
+        });
+
         const stream = websocketStream(ws as unknown as globalThis.WebSocket);
         const router = mapServer.accept(stream, {
           role: "client",
@@ -422,6 +594,11 @@ export function createMAPServerInstance(
 
         ws.on("close", () => {
           connectionCount--;
+          // Clear sequence counters for any subscriptions belonging to this
+          // connection. Use a copy of subscriptionIds since we don't mutate it.
+          for (const subId of subscriptionIds) {
+            subscriptionSequence.delete(subId);
+          }
           if (clientAgentId) {
             clientWebSockets.delete(clientAgentId);
             clientSubscriptions.delete(clientAgentId);

package/src/map/sidecar.ts

@@ -294,11 +294,19 @@ export function createMAPSidecar(
       trajectoryReporter,
     });
 
-    // 5. Cascade Bridge (optional — only when a GitCascadeAdapter is available)
+    // 5. Cascade Bridge + Action Handler (optional — only when a GitCascadeAdapter is available)
     if (gitCascadeAdapter) {
       const { createCascadeBridge } = await import("./cascade-bridge.js");
       const cascadeBridge = createCascadeBridge(connection, gitCascadeAdapter);
-      cascadeBridgeCleanup = cascadeBridge.dispose;
+
+      // 5b. Inbound action handler — receives x-cascade/request.* from hub
+      const { setupCascadeActionHandlers } = await import("./cascade-action-handler.js");
+      const actionCleanup = setupCascadeActionHandlers(connection, gitCascadeAdapter);
+
+      cascadeBridgeCleanup = () => {
+        cascadeBridge.dispose();
+        actionCleanup();
+      };
     }
   }
 
@@ -346,5 +354,14 @@ export function createMAPSidecar(
       if (!trajectoryReporter) return null;
       return trajectoryReporter.reportCheckpoint(checkpoint);
     },
+
+    async emitEvent(event: Record<string, unknown>): Promise<void> {
+      if (!connection || !isConnected) return;
+      try {
+        await connection.send({ scope }, { ...event, _origin: "macro-agent" });
+      } catch {
+        // Best effort — MAP hub may be temporarily unavailable
+      }
+    },
   };
 }

package/src/map/types.ts

@@ -103,6 +103,9 @@ export interface MAPSidecar {
   reportCheckpoint(
     checkpoint: TrajectoryCheckpointPayload,
   ): Promise<TrajectoryCheckpointResult | null>;
+
+  /** Emit a custom event to the MAP hub scope (best-effort, no-op if disconnected) */
+  emitEvent?(event: Record<string, unknown>): Promise<void>;
 }
 
 // =============================================================================

package/src/workspace/__tests__/land-dispatch.test.ts

@@ -0,0 +1,214 @@
+/**
+ * WorkspaceManager.land() dispatcher tests (A2 follow-up).
+ *
+ * Closes the gap where `registerLandingStrategy` existed but no caller
+ * invoked `.land(ctx)` at `done()` time. Verifies the dispatcher:
+ *   - resolves strategy by name (internal or YAML form)
+ *   - respects `strategyName: 'none'` (short-circuits to success)
+ *   - errors out on unknown names
+ *   - fills in `ctx.workspaceManager` before invoking the strategy
+ *   - rejects when `canLand` returns false
+ *
+ * Unit-only — doesn't spin up git. The end-to-end path (strategy fires
+ * tracker events → hub projects) is covered by OpenHive's
+ * live-emission-e2e.test.ts.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import type { GitCascadeAdapter } from '../git-cascade-adapter.js';
+import { DefaultWorkspaceManager, resolveLandingStrategyName } from '../workspace-manager.js';
+import type { LandingStrategy, LandingContext } from '../types-v3.js';
+
+// A no-op adapter stub that satisfies the DefaultWorkspaceManager constructor
+// without touching git. Every method the dispatcher path might hit throws so
+// accidental delegation is loud.
+function stubAdapter(): GitCascadeAdapter {
+  const throwing = (name: string) => () => {
+    throw new Error(`stub adapter: ${name} should not be called in this test`);
+  };
+  return {
+    close: vi.fn(),
+    reconcile: throwing('reconcile'),
+    listWorktrees: vi.fn(() => []),
+    getWorktree: vi.fn(() => null),
+  } as unknown as GitCascadeAdapter;
+}
+
+function makeTestStrategy(
+  name: string,
+  impl: (ctx: LandingContext) => ReturnType<LandingStrategy['land']>,
+  canLand?: (ctx: LandingContext) => boolean,
+): LandingStrategy {
+  return { name, land: impl, canLand };
+}
+
+describe('WorkspaceManager.land() dispatcher', () => {
+  it('dispatches to an internal-named strategy', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: true, newHead: 'abc' } as never));
+    wm.registerLandingStrategy(makeTestStrategy('merge-to-parent', land));
+
+    const result = await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      strategyName: 'merge-to-parent',
+      workspaceManager: wm,
+    });
+
+    expect(result.success).toBe(true);
+    expect(land).toHaveBeenCalledOnce();
+  });
+
+  it('accepts YAML-style strategy names and maps them', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: true } as never));
+    wm.registerLandingStrategy(makeTestStrategy('queue-to-branch', land));
+
+    await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      strategyName: 'queue_to_branch', // YAML form
+      workspaceManager: wm,
+    });
+
+    expect(land).toHaveBeenCalledOnce();
+  });
+
+  it('defaults to merge-to-parent when strategyName is unset', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: true } as never));
+    wm.registerLandingStrategy(makeTestStrategy('merge-to-parent', land));
+
+    await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      workspaceManager: wm,
+    });
+
+    expect(land).toHaveBeenCalledOnce();
+  });
+
+  it('short-circuits on strategyName: "none" without invoking any strategy', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: false } as never));
+    wm.registerLandingStrategy(makeTestStrategy('merge-to-parent', land));
+
+    const result = await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      strategyName: 'none',
+      workspaceManager: wm,
+    });
+
+    expect(result.success).toBe(true);
+    expect(land).not.toHaveBeenCalled();
+  });
+
+  it('throws on an unknown strategy name', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    await expect(
+      wm.land({
+        agentId: 'a1',
+        streamId: 's1',
+        sourceWorktree: '/tmp/wt',
+        strategyName: 'nonexistent-strategy',
+        workspaceManager: wm,
+      }),
+    ).rejects.toThrow(/No landing strategy registered/);
+  });
+
+  it('fills ctx.workspaceManager with the dispatcher instance', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    let seenManager: unknown = null;
+    wm.registerLandingStrategy(
+      makeTestStrategy('merge-to-parent', async (ctx) => {
+        seenManager = ctx.workspaceManager;
+        return { success: true } as never;
+      }),
+    );
+
+    await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      // Deliberately pass a non-matching value to prove the dispatcher overrides.
+      workspaceManager: { bogus: true },
+    });
+
+    expect(seenManager).toBe(wm);
+  });
+
+  it('rejects when strategy.canLand(ctx) returns false', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    wm.registerLandingStrategy(
+      makeTestStrategy(
+        'merge-to-parent',
+        async () => ({ success: true } as never),
+        () => false,
+      ),
+    );
+
+    await expect(
+      wm.land({
+        agentId: 'a1',
+        streamId: 's1',
+        sourceWorktree: '/tmp/wt',
+        workspaceManager: wm,
+      }),
+    ).rejects.toThrow(/rejected context/);
+  });
+
+  it('propagates strategy return values including conflicts', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    wm.registerLandingStrategy(
+      makeTestStrategy(
+        'merge-to-parent',
+        async () => ({
+          success: false,
+          conflicts: ['foo.ts'],
+        } as never),
+      ),
+    );
+
+    const result = await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      workspaceManager: wm,
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as { conflicts?: string[] }).conflicts).toEqual(['foo.ts']);
+  });
+});
+
+describe('resolveLandingStrategyName()', () => {
+  it('maps every YAML name to its internal counterpart', () => {
+    expect(resolveLandingStrategyName('merge_to_parent_stream')).toBe('merge-to-parent');
+    expect(resolveLandingStrategyName('queue_to_branch')).toBe('queue-to-branch');
+    expect(resolveLandingStrategyName('direct_push')).toBe('direct-push');
+    expect(resolveLandingStrategyName('optimistic_push')).toBe('optimistic-push');
+    expect(resolveLandingStrategyName('cherry_pick_stack')).toBe('cherry-pick-stack');
+  });
+
+  it('passes internal names through unchanged', () => {
+    expect(resolveLandingStrategyName('merge-to-parent')).toBe('merge-to-parent');
+    expect(resolveLandingStrategyName('queue-to-branch')).toBe('queue-to-branch');
+  });
+
+  it('passes unknown names through (lets the dispatcher throw with a useful message)', () => {
+    expect(resolveLandingStrategyName('my-custom-strategy')).toBe('my-custom-strategy');
+  });
+
+  it('defaults to merge-to-parent on undefined', () => {
+    expect(resolveLandingStrategyName(undefined)).toBe('merge-to-parent');
+  });
+
+  it('preserves "none" so the dispatcher can short-circuit', () => {
+    expect(resolveLandingStrategyName('none')).toBe('none');
+  });
+});

package/src/workspace/git-cascade-adapter.ts

@@ -79,8 +79,9 @@ export type GitCascadeEventType =
   | 'stream:merged'         // mapped from git-cascade stream.merged
   | 'stream:conflicted'     // mapped from git-cascade stream.conflicted
   | 'stream:abandoned'      // mapped from git-cascade stream.abandoned
-  | 'stream:paused'         // local (pauseStream)
-  | 'stream:resumed'        // local (resumeStream)
+  | 'stream:paused'         // local (pauseStream) + cascade emit
+  | 'stream:resumed'        // local (resumeStream) + cascade emit
+  | 'stream:rolled_back'    // cascade emit (rollbackN, rollbackToOperation, rollbackToForkPoint)
   | 'worktree:created'
   | 'worktree:deallocated'
   | 'task:created'
@@ -250,7 +251,11 @@ export class GitCascadeAdapter {
     const suffix = matchCascadeSuffix(method);
     if (!suffix) return;
 
-    switch (suffix) {
+    // Widen to `string` so case labels for suffixes not yet in the installed
+    // git-cascade version (e.g. `stream.paused`, `stream.resumed`,
+    // `stream.rolled_back` — added after 0.0.7) still compile. The runtime
+    // value is always a string either way; this is a version-skew shim.
+    switch (suffix as string) {
       case 'stream.opened': {
         const p = params as StreamOpenedParams;
         this.emit('stream:created', {
@@ -394,6 +399,28 @@ export class GitCascadeAdapter {
         });
         break;
       }
+      case 'stream.paused': {
+        // Tracker fires stream.paused after pauseStream. The adapter also
+        // emits stream:paused locally in its pauseStream() wrapper — the
+        // bridge uses the local event (not this cascade-forwarded one) for
+        // the MAP translation, so this case is mainly to keep the switch
+        // exhaustive. No double-emit: the bridge deduplicates by event type.
+        break;
+      }
+      case 'stream.resumed': {
+        // Same as stream.paused — adapter.resumeStream() fires the local event.
+        break;
+      }
+      case 'stream.rolled_back': {
+        const p = params as { stream_id: string; strategy?: string; target?: string | number; new_head?: string };
+        this.emit('stream:rolled_back', {
+          streamId: p.stream_id,
+          strategy: p.strategy,
+          target: p.target,
+          newHead: p.new_head,
+        });
+        break;
+      }
     }
   }
 

package/src/workspace/landing/__tests__/strategies.test.ts

@@ -75,6 +75,48 @@ describe('landing strategies', () => {
         expect.objectContaining({ targetStreamId: 'target-1' })
       );
     });
+
+    it('threads ctx.taskRef into mergeStream metadata when present', async () => {
+      const strategy = new MergeToParentStrategy();
+      const ws = {
+        listStreams: vi.fn(() => []),
+        mergeStream: vi.fn(() => ({ success: true, newHead: 'aaa' })),
+      } as unknown as WorkspaceManager;
+
+      const taskRef = { resource_id: 'res-a1', node_id: 'task-a1' };
+      await strategy.land({
+        agentId: 'agent-1',
+        streamId: 'src-1',
+        sourceWorktree: '/tmp/wt',
+        targetStreamId: 'target-1',
+        taskRef,
+        workspaceManager: ws,
+      });
+
+      expect(ws.mergeStream).toHaveBeenCalledWith(
+        expect.objectContaining({ metadata: { task_ref: taskRef } })
+      );
+    });
+
+    it('omits metadata when ctx.taskRef is absent', async () => {
+      const strategy = new MergeToParentStrategy();
+      const ws = {
+        listStreams: vi.fn(() => []),
+        mergeStream: vi.fn(() => ({ success: true, newHead: 'bbb' })),
+      } as unknown as WorkspaceManager;
+
+      await strategy.land({
+        agentId: 'agent-1',
+        streamId: 'src-1',
+        sourceWorktree: '/tmp/wt',
+        targetStreamId: 'target-1',
+        workspaceManager: ws,
+      });
+
+      expect(ws.mergeStream).toHaveBeenCalledWith(
+        expect.objectContaining({ metadata: undefined })
+      );
+    });
   });
 
   describe('QueueToBranchStrategy', () => {

package/src/workspace/landing/merge-to-parent.ts

@@ -81,6 +81,7 @@ export class MergeToParentStrategy implements LandingStrategy {
         targetStreamId,
         agentId: ctx.agentId,
         worktree: mergeWorktree.path,
+        metadata: ctx.taskRef ? { task_ref: ctx.taskRef } : undefined,
       });
 
       // Cascade rebase on dependents if requested.

package/src/workspace/recovery/spawn-resolver.ts

@@ -70,7 +70,8 @@ export class SpawnResolverStrategy implements ConflictRecoveryStrategy {
       };
     }
 
-    // Spawn the resolver
+    // Spawn the resolver. Injects MACRO_RECOVERY_STRATEGY + MACRO_CONFLICT_ID
+    // so the resolve_conflict MCP tool can tag the resolution correctly.
     let resolverAgentId: string;
     try {
       const spawnOpts: SpawnAgentOptions = {
@@ -78,6 +79,12 @@ export class SpawnResolverStrategy implements ConflictRecoveryStrategy {
         task: `Resolve conflict ${ctx.conflictId} on stream ${ctx.streamId}`,
         parent: ctx.landingAgentId,
         capabilities: ['workspace.commit', 'workspace.resolve', 'workspace.read'],
+        config: {
+          env: {
+            MACRO_RECOVERY_STRATEGY: 'spawn-resolver',
+            MACRO_CONFLICT_ID: ctx.conflictId,
+          },
+        },
       };
       const spawned = await this.opts.agentManager.spawn(spawnOpts);
       resolverAgentId = spawned.id;

package/src/workspace/types-v3.ts

@@ -124,6 +124,13 @@ export interface LandingContext {
   streamId: StreamId;
   sourceWorktree: string;
   targetStreamId?: StreamId;
+  /**
+   * Strategy selector. Accepts either an internal strategy name
+   * (`merge-to-parent`, `queue-to-branch`, …) or the YAML form
+   * (`merge_to_parent_stream`, `queue_to_branch`, …). `WorkspaceManager.land`
+   * normalizes. When undefined, `merge-to-parent` is used.
+   */
+  strategyName?: string;
   strategyConfig?: Record<string, unknown>;
   /** Reference to the manager; strategies call back for merge/cascade. */
   workspaceManager: unknown; // WorkspaceManager — circular; narrowed at callsite