borgmcp 4.1.0 → 4.2.1

package/dist/index.js

@@ -112,6 +112,17 @@ export function formatUpdatedRoleResult(role, advisory) {
     const tag = tags ? ` (${tags})` : '';
     return appendServerAdvisory(`Updated role **${role.name}**${tag} (id: ${role.id}).`, advisory);
 }
+// gh#496: the unread drain runs on every wake, so its structured payload must
+// stay proportional to the entries it returns. Rosters are deliberately NOT
+// included — entries already carry drone_label/role_name, and borg_roster
+// serves identity mapping when a consumer needs it.
+export function buildReadLogStructuredContent(input) {
+    return {
+        entries: input.entries,
+        behind_by: typeof input.behind_by === 'number' ? input.behind_by : null,
+        has_more: input.has_more === true,
+    };
+}
 export function formatPatchedRoleSectionResult(action, heading, role, advisory) {
     const verb = action === 'replace' ? 'Replaced' : action === 'insert' ? 'Inserted' : 'Deleted';
     return appendServerAdvisory(`${verb} section **${heading}** in role **${role.name}** (id: ${role.id}).`, advisory);
@@ -257,8 +268,15 @@ export async function main() {
                     isError: true,
                 };
             }
+            const described = {
+                name: def.name,
+                description: def.description,
+                inputSchema: def.inputSchema,
+                outputSchema: def.outputSchema ?? null,
+            };
             return {
-                content: [{ type: 'text', text: JSON.stringify({ name: def.name, description: def.description, inputSchema: def.inputSchema }, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify(described, null, 2) }],
+                structuredContent: described,
             };
         }
         // gh#899: borg_tool dispatcher — unwrap to the inner tool and fall through
@@ -306,6 +324,7 @@ export async function main() {
                                     text: 'Not connected to a cube. Use `borg_assimilate cube_name="<name>"` to join one.',
                                 },
                             ],
+                            structuredContent: { connected: false },
                         };
                     }
                     seedDisplayIdentity(active);
@@ -358,10 +377,12 @@ export async function main() {
                         : '';
                     // gh#285: version-mismatch nudge when on-disk package is newer.
                     let versionHeader = '';
+                    let onDiskVersion = null;
                     try {
                         const running = getPackageVersion();
                         const onDisk = getOnDiskVersion();
                         if (running !== 'unknown' && onDisk !== 'unknown' && onDisk !== running) {
+                            onDiskVersion = onDisk;
                             const [rMaj, rMin, rPat] = running.split('.').map(Number);
                             const [dMaj, dMin, dPat] = onDisk.split('.').map(Number);
                             const onDiskNewer = dMaj > rMaj || (dMaj === rMaj && dMin > rMin) || (dMaj === rMaj && dMin === rMin && dPat > rPat);
@@ -371,7 +392,21 @@ export async function main() {
                         }
                     }
                     catch { /* never break regen */ }
-                    return { content: [{ type: 'text', text: versionHeader + prefix + formatRegenMarkdown(displayedResult, { mode }) }] };
+                    return {
+                        content: [{ type: 'text', text: versionHeader + prefix + formatRegenMarkdown(displayedResult, { mode }) }],
+                        structuredContent: {
+                            connected: true,
+                            mode,
+                            cube: displayedResult.cube,
+                            drone: displayedResult.drone,
+                            role: displayedResult.role,
+                            behind_by: typeof displayedResult.behind_by === 'number' ? displayedResult.behind_by : null,
+                            decision_topics: (displayedResult.decisions ?? []).map((d) => d.topic),
+                            running_version: getPackageVersion(),
+                            on_disk_version: onDiskVersion,
+                            wake_path_healthy: inboxMonitorHealthy,
+                        },
+                    };
                 }
                 case 'borg_assimilate': {
                     const cubeName = args?.cube_name;
@@ -417,6 +452,11 @@ export async function main() {
                         ].join('\n');
                         return {
                             content: [{ type: 'text', text: header + formatRegenMarkdown(displayedResult, { mode: 'full' }) }],
+                            structuredContent: {
+                                reattached: true,
+                                cube_name: displayIdentity.cubeName,
+                                drone_label: displayIdentity.droneLabel,
+                            },
                         };
                     }
                     catch (err) {
@@ -426,7 +466,10 @@ export async function main() {
                     }
                 }
                 case 'borg_version': {
-                    return { content: [{ type: 'text', text: `borgmcp ${getPackageVersion()}` }] };
+                    return {
+                        content: [{ type: 'text', text: `borgmcp ${getPackageVersion()}` }],
+                        structuredContent: { version: getPackageVersion() },
+                    };
                 }
                 case 'borg_playbook': {
                     // gh#912: serve the on-demand operating-playbook chapter (static
@@ -446,7 +489,14 @@ export async function main() {
                         : topic
                             ? `No exact match for "${topic}". Full Borg MCP docs index — WebFetch the URL you need:`
                             : `Borg MCP docs index — WebFetch the URL of the section you need:`;
-                    return { content: [{ type: 'text', text: `${header}\n\n${formatDocsIndex(sections)}` }] };
+                    return {
+                        content: [{ type: 'text', text: `${header}\n\n${formatDocsIndex(sections)}` }],
+                        structuredContent: {
+                            topic: topic || null,
+                            matched: matched.length > 0,
+                            sections: sections.map((s) => ({ slug: s.slug, title: s.title, url: s.url, summary: s.summary })),
+                        },
+                    };
                 }
                 case 'borg_whoami': {
                     const active = await requireActiveCube();
@@ -476,7 +526,10 @@ export async function main() {
                         // The invocation-local server truth remains authoritative even if
                         // the display-only persistence refresh cannot be written.
                     }
-                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        structuredContent: { ...result },
+                    };
                 }
                 case 'borg_cube': {
                     // No-cache invariant (T1.2 — 0.7.0): both `getCubeInfo` and
@@ -529,7 +582,10 @@ export async function main() {
                     }
                     lines.push('');
                     lines.push(getDronePlaybook());
-                    return { content: [{ type: 'text', text: lines.join('\n') }] };
+                    return {
+                        content: [{ type: 'text', text: lines.join('\n') }],
+                        structuredContent: { cube, roles },
+                    };
                 }
                 case 'borg_role': {
                     // No-cache invariant (T1.2 — 0.7.0): role reads MUST fetch
@@ -544,7 +600,7 @@ export async function main() {
                             ``,
                             role.detailed_description || '_(no detailed description set)_',
                         ].join('\n');
-                        return { content: [{ type: 'text', text }] };
+                        return { content: [{ type: 'text', text }], structuredContent: { role } };
                     }
                     const { role } = await getRoleInfo(active.sessionToken, active.apiUrl, active.serverTrustIdentity);
                     const text = [
@@ -552,7 +608,7 @@ export async function main() {
                         ``,
                         role.detailed_description || '_(no detailed description set)_',
                     ].join('\n');
-                    return { content: [{ type: 'text', text }] };
+                    return { content: [{ type: 'text', text }], structuredContent: { role } };
                 }
                 case 'borg_role-rationale': {
                     const active = await requireActiveCube();
@@ -564,7 +620,10 @@ export async function main() {
                         '',
                         result.body || '_(empty)_',
                     ].join('\n');
-                    return { content: [{ type: 'text', text }] };
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: { role: result.role, section: result.section, body: result.body },
+                    };
                 }
                 case 'borg_roster': {
                     const active = await requireActiveCube();
@@ -577,7 +636,10 @@ export async function main() {
                         resolvedSince: resolvedSince ?? null,
                         humanAgo,
                     });
-                    return { content: [{ type: 'text', text }] };
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: { cube_name: active.name, drones, roles, since: resolvedSince ?? null },
+                    };
                 }
                 case 'borg_stream-status': {
                     // Probe the in-process SSE consumer state. Does NOT require
@@ -616,7 +678,18 @@ export async function main() {
                         cubeName: active?.name ?? null,
                         humanAgo,
                     });
-                    return { content: [{ type: 'text', text: silentInertWarning + text }] };
+                    return {
+                        content: [{ type: 'text', text: silentInertWarning + text }],
+                        structuredContent: {
+                            status,
+                            wake_path: wakePath,
+                            inbox_monitor_healthy: inboxMonitorHealthy,
+                            inbox_path: inboxPath,
+                            monitor_state_root: monitorStateRoot,
+                            drone_label: active?.droneLabel ?? null,
+                            cube_name: active?.name ?? null,
+                        },
+                    };
                 }
                 case 'borg_read-log': {
                     const active = await requireActiveCube();
@@ -658,7 +731,10 @@ export async function main() {
                         lines.push('');
                         lines.push(`⚠ behind_by: ${behind_by} more unread ${behind_by === 1 ? 'entry' : 'entries'} addressed to you — call \`borg_read-log unread_only=true\` again until behind_by=0 so you don't skip messages.`);
                     }
-                    return { content: [{ type: 'text', text: lines.join('\n') }] };
+                    return {
+                        content: [{ type: 'text', text: lines.join('\n') }],
+                        structuredContent: buildReadLogStructuredContent({ entries, behind_by, has_more }),
+                    };
                 }
                 case 'borg_read-entry': {
                     const active = await requireActiveCube();
@@ -670,17 +746,26 @@ export async function main() {
                         '',
                         formatLogEntryMarkdown(entry, droneById, roleById),
                     ].join('\n');
-                    return { content: [{ type: 'text', text }] };
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: { entry, drones, roles },
+                    };
                 }
                 case 'borg_put-document': {
                     const active = await requireActiveCube();
                     const result = await putDocument(active.sessionToken, active.apiUrl, args ?? {}, active.serverTrustIdentity);
-                    return { content: [{ type: 'text', text: `Created cube document.\n\n${formatDocument(result.document)}` }] };
+                    return {
+                        content: [{ type: 'text', text: `Created cube document.\n\n${formatDocument(result.document)}` }],
+                        structuredContent: { document: result.document },
+                    };
                 }
                 case 'borg_get-document': {
                     const active = await requireActiveCube();
                     const result = await getDocument(active.sessionToken, active.apiUrl, args ?? {}, active.serverTrustIdentity);
-                    return { content: [{ type: 'text', text: formatDocument(result.document) }] };
+                    return {
+                        content: [{ type: 'text', text: formatDocument(result.document) }],
+                        structuredContent: { document: result.document },
+                    };
                 }
                 case 'borg_list-documents': {
                     const active = await requireActiveCube();
@@ -688,12 +773,18 @@ export async function main() {
                     const text = result.documents.length === 0
                         ? `No active or superseded documents in cube "${active.name}".`
                         : result.documents.map(formatDocumentMetadata).join('\n\n');
-                    return { content: [{ type: 'text', text }] };
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: { documents: result.documents },
+                    };
                 }
                 case 'borg_remove-document': {
                     const active = await requireActiveCube();
                     const result = await removeDocument(active.sessionToken, active.apiUrl, args ?? {}, active.serverTrustIdentity);
-                    return { content: [{ type: 'text', text: `Removed cube document.\n\n${formatDocumentMetadata(result.document)}` }] };
+                    return {
+                        content: [{ type: 'text', text: `Removed cube document.\n\n${formatDocumentMetadata(result.document)}` }],
+                        structuredContent: { document: result.document },
+                    };
                 }
                 case 'borg_log': {
                     const message = args?.message;
@@ -719,6 +810,13 @@ export async function main() {
                                         text: `Suppressed duplicate ${decision.signal?.toUpperCase()} lifecycle log for ${displayIdentity.droneLabel}; recent cube log already contains this signal.`,
                                     },
                                 ],
+                                structuredContent: {
+                                    suppressed: true,
+                                    entry: null,
+                                    recipients: [],
+                                    unreachable_recipients: [],
+                                    advisory: null,
+                                },
                             };
                         }
                     }
@@ -765,7 +863,16 @@ export async function main() {
                         ? `\nAdvisory: this message exceeded ${result.advisory.threshold_bytes} UTF-8 bytes. Store durable detail with borg_put-document, then cite its full id in borg_log.documents with an explicit borg_log.to audience.`
                         : '';
                     const text = `Logged to cube "${displayIdentity.cubeName}" as ${displayIdentity.droneLabel}. (entry id: ${result.entry.id})${routed}${unreachable}${citations}${advisory}`;
-                    return { content: [{ type: 'text', text }] };
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: {
+                            suppressed: false,
+                            entry: result.entry,
+                            recipients: routedRecipients,
+                            unreachable_recipients: result.unreachableRecipients ?? [],
+                            advisory: result.advisory ?? null,
+                        },
+                    };
                 }
                 case 'borg_ack': {
                     const entryId = args?.entry_id;
@@ -787,12 +894,16 @@ export async function main() {
                                     : `Acked entry ${entryId} in cube "${active.name}".`,
                             },
                         ],
+                        structuredContent: { entry_id: entryId, kind, cube_name: active.name },
                     };
                 }
                 case 'borg_ack-status': {
                     const active = await requireActiveCube();
                     const result = await getAckStatus(active.sessionToken, active.apiUrl, args ?? {}, active.serverTrustIdentity);
-                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        structuredContent: { ...result },
+                    };
                 }
                 case 'borg_decide': {
                     const topic = args?.topic;
@@ -816,6 +927,7 @@ export async function main() {
                                 text: `Recorded ratified decision on "${topic}" in cube "${active.name}"${superseded}. Cite it via borg_decisions; it surfaces in borg_regen.`,
                             },
                         ],
+                        structuredContent: { decision: row, superseded: Boolean(row?.supersedes), cube_name: active.name },
                     };
                 }
                 case 'borg_decisions': {
@@ -829,7 +941,10 @@ export async function main() {
                         : decisions
                             .map((d) => `**${d.topic}:** ${d.decision}${d.rationale ? ` — ${d.rationale}` : ''}`)
                             .join('\n');
-                    return { content: [{ type: 'text', text }] };
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: { decisions },
+                    };
                 }
                 case 'borg_remove-decision': {
                     const topic = typeof args?.topic === 'string' ? args.topic : undefined;
@@ -845,15 +960,22 @@ export async function main() {
                                 type: 'text',
                                 text: `Removed the active ratified decision on "${decision.topic}" from cube "${active.name}".`,
                             }],
+                        structuredContent: { decision, cube_name: active.name },
                     };
                 }
                 case 'borg_list-cubes': {
                     const { cubes } = await listCubes();
                     if (!cubes.length) {
-                        return { content: [{ type: 'text', text: 'No cubes yet. Use borg_create-cube to make your first one.' }] };
+                        return {
+                            content: [{ type: 'text', text: 'No cubes yet. Use borg_create-cube to make your first one.' }],
+                            structuredContent: { cubes: [] },
+                        };
                     }
                     const lines = cubes.map((c) => `- **${c.name}** (id: ${c.id})\n  ${(c.cube_directive || '_(no directive set)_').split('\n')[0].slice(0, 120)}`);
-                    return { content: [{ type: 'text', text: `Your cubes (${cubes.length}):\n\n${lines.join('\n\n')}` }] };
+                    return {
+                        content: [{ type: 'text', text: `Your cubes (${cubes.length}):\n\n${lines.join('\n\n')}` }],
+                        structuredContent: { cubes },
+                    };
                 }
                 case 'borg_create-cube': {
                     const name = args?.name;
@@ -892,10 +1014,21 @@ export async function main() {
                             ? ' Template cube directive applied (operator passed empty).'
                             : '';
                         const text = `Created cube **${cube.name}** (id: ${cube.id}) with template **${templateName}** applied — ${summary.created} role(s) created, ${summary.updated} updated.${cubeDirectiveNote} Use borg_assimilate ${cube.name} to join as a drone.`;
-                        return { content: [{ type: 'text', text }] };
+                        return {
+                            content: [{ type: 'text', text }],
+                            structuredContent: {
+                                cube,
+                                template: templateName,
+                                roles_created: summary.created,
+                                roles_updated: summary.updated,
+                            },
+                        };
                     }
                     const text = `Created cube **${cube.name}** (id: ${cube.id}). A default "Drone" role was seeded — rename or replace it via borg_update-role / borg_create-role / borg_delete-role. Use borg_assimilate ${cube.name} to join as a drone.`;
-                    return { content: [{ type: 'text', text }] };
+                    return {
+                        content: [{ type: 'text', text }],
+                        structuredContent: { cube, template: null, roles_created: null, roles_updated: null },
+                    };
                 }
                 case 'borg_update-cube': {
                     const cubeId = args?.cube_id;
@@ -911,7 +1044,10 @@ export async function main() {
                     if (Object.keys(updates).length === 0)
                         throw new Error('Pass at least one of: cube_directive, message_taxonomy.');
                     const { cube, advisory } = await updateCube(cubeId, updates);
-                    return { content: [{ type: 'text', text: formatUpdatedCubeResult(cube, advisory) }] };
+                    return {
+                        content: [{ type: 'text', text: formatUpdatedCubeResult(cube, advisory) }],
+                        structuredContent: { cube, advisory: advisory ?? null },
+                    };
                 }
                 case 'borg_patch-taxonomy-class': {
                     const cubeId = args?.cube_id;
@@ -939,7 +1075,10 @@ export async function main() {
                         label = String(classDef.class ?? '');
                     }
                     const verb = action === 'add' ? 'Added' : action === 'replace' ? 'Replaced' : 'Removed';
-                    return { content: [{ type: 'text', text: `${verb} taxonomy class **${label}** in cube **${cube.name}** (id: ${cube.id}).` }] };
+                    return {
+                        content: [{ type: 'text', text: `${verb} taxonomy class **${label}** in cube **${cube.name}** (id: ${cube.id}).` }],
+                        structuredContent: { action, class: label, cube },
+                    };
                 }
                 case 'borg_delete-cube': {
                     const cubeId = args?.cube_id;
@@ -950,7 +1089,10 @@ export async function main() {
                         throw new CubeDeletionConfirmationError(cubeId, confirmCubeId);
                     }
                     await deleteCube(cubeId, confirmCubeId);
-                    return { content: [{ type: 'text', text: `Deleted cube ${cubeId} (and all its roles, drones, log entries).` }] };
+                    return {
+                        content: [{ type: 'text', text: `Deleted cube ${cubeId} (and all its roles, drones, log entries).` }],
+                        structuredContent: { cube_id: cubeId, deleted: true },
+                    };
                 }
                 case 'borg_create-role': {
                     const cubeId = args?.cube_id;
@@ -988,7 +1130,10 @@ export async function main() {
                         role.is_mandatory ? 'mandatory' : null,
                     ].filter(Boolean).join(', ');
                     const tag = tags ? ` (${tags})` : '';
-                    return { content: [{ type: 'text', text: `Created role **${role.name}**${tag} (id: ${role.id}) in cube ${cubeId}.` }] };
+                    return {
+                        content: [{ type: 'text', text: `Created role **${role.name}**${tag} (id: ${role.id}) in cube ${cubeId}.` }],
+                        structuredContent: { role, cube_id: cubeId },
+                    };
                 }
                 case 'borg_update-role': {
                     const roleId = args?.role_id;
@@ -1016,7 +1161,10 @@ export async function main() {
                     if (Object.keys(updates).length === 0)
                         throw new Error('Pass at least one of: name, short_description, detailed_description, is_default, is_mandatory, is_human_seat, can_broadcast, receives_all_direct.');
                     const { role, advisory } = await updateRole(roleId, updates);
-                    return { content: [{ type: 'text', text: formatUpdatedRoleResult(role, advisory) }] };
+                    return {
+                        content: [{ type: 'text', text: formatUpdatedRoleResult(role, advisory) }],
+                        structuredContent: { role, advisory: advisory ?? null },
+                    };
                 }
                 case 'borg_patch-role-section': {
                     const roleId = args?.role_id;
@@ -1047,26 +1195,45 @@ export async function main() {
                             ({ role, advisory } = await patchRoleSection(roleId, { action, heading, body }));
                         }
                     }
-                    return { content: [{ type: 'text', text: formatPatchedRoleSectionResult(action, heading, role, advisory) }] };
+                    return {
+                        content: [{ type: 'text', text: formatPatchedRoleSectionResult(action, heading, role, advisory) }],
+                        structuredContent: { action, heading, role, advisory: advisory ?? null },
+                    };
                 }
                 case 'borg_delete-role': {
                     const roleId = args?.role_id;
                     if (!roleId)
                         throw new Error('role_id is required');
                     await deleteRole(roleId);
-                    return { content: [{ type: 'text', text: `Deleted role ${roleId}.` }] };
+                    return {
+                        content: [{ type: 'text', text: `Deleted role ${roleId}.` }],
+                        structuredContent: { role_id: roleId, deleted: true },
+                    };
                 }
                 case 'borg_reassign-drone': {
+                    const reassigned = await runReassignDroneTool({
+                        droneId: args?.drone_id,
+                        roleId: args?.role_id,
+                    });
                     return {
-                        content: [{ type: 'text', text: await runReassignDroneTool({
-                                    droneId: args?.drone_id,
-                                    roleId: args?.role_id,
-                                }) }],
+                        content: [{ type: 'text', text: reassigned.text }],
+                        structuredContent: {
+                            drone: reassigned.drone,
+                            role_name: reassigned.roleName,
+                            cube_name: reassigned.cubeName,
+                        },
                     };
                 }
                 case 'borg_evict-drone': {
+                    const evicted = await runEvictDroneTool(args);
                     return {
-                        content: [{ type: 'text', text: await runEvictDroneTool(args) }],
+                        content: [{ type: 'text', text: evicted.text }],
+                        structuredContent: {
+                            drone_id: evicted.droneId,
+                            label: evicted.label,
+                            cube_name: evicted.cubeName,
+                            evicted: true,
+                        },
                     };
                 }
                 case 'borg_list-drones': {
@@ -1075,7 +1242,10 @@ export async function main() {
                         throw new Error('cube_id is required');
                     const { drones, roles } = await getCube(cubeId);
                     if (!drones.length) {
-                        return { content: [{ type: 'text', text: 'No drones in this cube yet.' }] };
+                        return {
+                            content: [{ type: 'text', text: 'No drones in this cube yet.' }],
+                            structuredContent: { cube_id: cubeId, drones: [], roles },
+                        };
                     }
                     const rolesById = new Map(roles.map((r) => [r.id, r]));
                     const lines = drones.map((d) => {
@@ -1088,7 +1258,10 @@ export async function main() {
                             ...renderRuntimeMetadataLines(d),
                         ].join('\n');
                     });
-                    return { content: [{ type: 'text', text: `Drones in cube ${cubeId} (${drones.length}):\n\n_${RUNTIME_METADATA_ADVISORY}_\n\n${lines.join('\n')}` }] };
+                    return {
+                        content: [{ type: 'text', text: `Drones in cube ${cubeId} (${drones.length}):\n\n_${RUNTIME_METADATA_ADVISORY}_\n\n${lines.join('\n')}` }],
+                        structuredContent: { cube_id: cubeId, drones, roles },
+                    };
                 }
                 case 'borg_list-roles': {
                     // Sprint 6 / gh#153: surface role IDs to Coordinator-class drones
@@ -1103,7 +1276,10 @@ export async function main() {
                     if (!cubeId)
                         throw new Error('cube_id is required');
                     const roles = await listRoles(cubeId);
-                    return { content: [{ type: 'text', text: renderRoleList(roles, cubeId) }] };
+                    return {
+                        content: [{ type: 'text', text: renderRoleList(roles, cubeId) }],
+                        structuredContent: { cube_id: cubeId, roles },
+                    };
                 }
                 case 'borg_list-templates': {
                     const names = listTemplateNames();
@@ -1111,7 +1287,12 @@ export async function main() {
                         const t = getTemplate(n);
                         return `- **${n}**: ${t.description}`;
                     });
-                    return { content: [{ type: 'text', text: `Available templates:\n\n${lines.join('\n')}` }] };
+                    return {
+                        content: [{ type: 'text', text: `Available templates:\n\n${lines.join('\n')}` }],
+                        structuredContent: {
+                            templates: names.map((n) => ({ name: n, description: getTemplate(n).description })),
+                        },
+                    };
                 }
                 case 'borg_sync-roles': {
                     const cubeId = args?.cube_id;
@@ -1127,7 +1308,10 @@ export async function main() {
                     if (!cubeId)
                         throw new Error('cube_id is required');
                     const result = await syncRoles(cubeId, templateName, apply, decisions);
-                    return { content: [{ type: 'text', text: renderSyncRolesResult(result, templateName) }] };
+                    return {
+                        content: [{ type: 'text', text: renderSyncRolesResult(result, templateName) }],
+                        structuredContent: { cube_id: cubeId, template: templateName, apply, result },
+                    };
                 }
                 case 'borg_apply-template': {
                     const cubeId = args?.cube_id;
@@ -1147,7 +1331,16 @@ export async function main() {
                         noMutation: 'No template fragments were changed.',
                     });
                     const { summary, cubeDirectiveNote } = await runApplyTemplateTool(cubeId, template, authority);
-                    return { content: [{ type: 'text', text: `Applied template **${templateName}** to cube ${cubeId} — ${summary.created} role(s) created, ${summary.updated} updated.${cubeDirectiveNote}` }] };
+                    return {
+                        content: [{ type: 'text', text: `Applied template **${templateName}** to cube ${cubeId} — ${summary.created} role(s) created, ${summary.updated} updated.${cubeDirectiveNote}` }],
+                        structuredContent: {
+                            cube_id: cubeId,
+                            template: templateName,
+                            roles_created: summary.created,
+                            roles_updated: summary.updated,
+                            cube_directive_applied: cubeDirectiveNote !== '',
+                        },
+                    };
                 }
                 default:
                     throw new Error(`Unknown tool: ${name}`);