@vectorplane/ctrl-cli 0.1.12 → 0.1.13

package/README.md

@@ -21,11 +21,15 @@ vp sync
 vp task templates
 vp task run --title "Entrega X" --intention "Implementar fluxo Y"
 vp task run --template code-review --title "Review auth" --intention "Revisar risco e cobertura do fluxo de auth"
+vp task watch <task-id>
 vp task claim --capability qa.test
 vp task execute <task-id> --step <step-id>
 vp task daemon --capability qa.test
 vp context --search "decisões sobre autenticação"
 vp context --delivery --search "fluxo de login" --type decisions
+vp context --diff --from latest-1 --to latest
+vp workspace webhook list
+vp workspace webhook create --name approvals --url https://example.com/hooks/vectorplane --secret supersecret123 --events task.approval_required,task.blocked
 vp context --workspace <workspace> --delivery
 vp session check-in --workspace <workspace> --agent codex --type codex --client openai-codex --feature feature-key --task task-key --owning-path "src/core,src/ui" --need "api-contract" --provide "implementation" --status "starting implementation"
 vp draft create --type progress --title "Entrega concluída" --content "Resumo da mudança"
@@ -74,6 +78,7 @@ vp draft create --type progress --title "Entrega concluída" --content "Resumo d
 - lista templates disponíveis com `vp task templates`
 - aceita `--template <slug>` para herdar capabilities e paths padrão do backend
 - lista e inspeciona tasks existentes
+- acompanha uma task em tempo real com `vp task watch <taskId>`
 - faz claim explícito de steps `pending_claim` atribuídos a agentes CLI
 - executa steps locais via `metadata.execution.command`
 - suporta loop controlado com `vp task daemon --capability ...`
@@ -111,12 +116,14 @@ vp draft create --type progress --title "Entrega concluída" --content "Resumo d
   - inclui `vp config privacy` e `vp config policy`
 - `vp workspace`
   - gerencia o workspace atual
+  - suporta `vp workspace webhook list|create|delete` para integrações externas por workspace
 - `vp session`
   - gerencia sessões de agente
 - `vp context`
   - carrega contexto remoto do workspace
   - suporta `--search "QUERY"` para busca semântica na memória
   - com `--delivery --search`, retorna delivery context com fragmentos semânticos relevantes
+  - suporta `--diff --from latest-1 --to latest` para comparar snapshots do workspace
 - `vp bootstrap`
   - obtém instruções de setup do workspace
 - `vp event send`

package/dist/commands/context.js

@@ -12,6 +12,7 @@ export async function runContextCommand(cliVersion, args) {
     const parsed = parseArgs(args);
     const delivery = getBooleanOption(parsed, "delivery");
     const snapshot = getBooleanOption(parsed, "snapshot");
+    const diff = getBooleanOption(parsed, "diff");
     const search = getStringOption(parsed, "search")?.trim();
     const runtime = await loadRuntimeStatus();
     const session = await ensureSessionAvailable(runtime.profile.name);
@@ -38,6 +39,9 @@ export async function runContextCommand(cliVersion, args) {
         throw new ValidationError("Nenhum workspace resolvido para carregar contexto.");
     }
     await ensureRuntimeAgentSetup({ rootPath, workspace, git, session: freshSession, apiClient, logger: runtime.logger });
+    if (diff && (delivery || snapshot || search)) {
+        throw new ValidationError("`--diff` não pode ser combinado com `--delivery`, `--snapshot` ou `--search`.");
+    }
     const payload = search
         ? (delivery
             ? await apiClient.getWorkspaceDeliveryContextSemantic(freshSession.accessToken, workspace, {
@@ -52,11 +56,16 @@ export async function runContextCommand(cliVersion, args) {
                 authority: getStringOption(parsed, "authority")?.trim(),
                 limit: Number(getStringOption(parsed, "limit") ?? "0") || undefined,
             }))
-        : delivery
-            ? await apiClient.getWorkspaceDeliveryContext(freshSession.accessToken, workspace)
-            : snapshot
-                ? await apiClient.getWorkspaceSnapshot(freshSession.accessToken, workspace)
-                : await apiClient.getWorkspaceContext(freshSession.accessToken, workspace);
+        : diff
+            ? await apiClient.getWorkspaceSnapshotDiff(freshSession.accessToken, workspace, {
+                from: getStringOption(parsed, "from")?.trim() || "latest-1",
+                to: getStringOption(parsed, "to")?.trim() || "latest",
+            })
+            : delivery
+                ? await apiClient.getWorkspaceDeliveryContext(freshSession.accessToken, workspace)
+                : snapshot
+                    ? await apiClient.getWorkspaceSnapshot(freshSession.accessToken, workspace)
+                    : await apiClient.getWorkspaceContext(freshSession.accessToken, workspace);
     process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
     return 0;
 }

package/dist/commands/task.js

@@ -157,6 +157,12 @@ function printObservability(payload) {
     process.stdout.write(`Delegadas: ${String(payload.delegatedTasks ?? 0)}\n`);
     process.stdout.write(`Success rate: ${String(payload.successRate ?? 0)}\n`);
 }
+function printWatchEvent(event) {
+    const scope = event.taskId ? `task=${event.taskId}` : `workspace=${event.workspaceId}`;
+    const step = event.stepId ? ` step=${event.stepId}` : "";
+    const summary = event.summary ? ` ${JSON.stringify(event.summary)}` : "";
+    process.stdout.write(`[${event.timestamp}] ${event.type} ${scope}${step}${summary}\n`);
+}
 async function runTaskList(cliVersion, args) {
     const { parsed, apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
     const tasks = await apiClient.listTasks(freshSession.accessToken, workspace);
@@ -433,6 +439,40 @@ async function runTaskObservability(cliVersion, args) {
     }
     return 0;
 }
+async function runTaskWatch(cliVersion, args) {
+    const { apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
+    const parsed = parseArgs(args);
+    const taskId = requirePositional(parsed, 0, "Uso: vp task watch <taskId> [--json]");
+    const task = await apiClient.getTask(freshSession.accessToken, workspace, taskId);
+    if (printJsonIfRequested(parsed, task)) {
+        return 0;
+    }
+    printTask(task);
+    const controller = new AbortController();
+    let exitCode = 0;
+    await apiClient.streamWorkspaceEvents(freshSession.accessToken, workspace, {
+        taskId,
+        signal: controller.signal,
+        onEvent: (event) => {
+            if (event.type === "ready" || event.type === "heartbeat") {
+                return;
+            }
+            printWatchEvent(event);
+            if (event.type === "task.failed" || event.type === "task.blocked") {
+                exitCode = 1;
+            }
+            if (event.type === "task.completed" || event.type === "task.failed" || event.type === "task.blocked") {
+                controller.abort();
+            }
+        },
+    }).catch((error) => {
+        if (controller.signal.aborted) {
+            return;
+        }
+        throw error;
+    });
+    return exitCode;
+}
 async function runTaskHealth(cliVersion, args) {
     const { apiClient, freshSession, workspace } = await resolveAuthenticatedWorkspace(cliVersion, args);
     const parsed = parseArgs(args);
@@ -465,7 +505,7 @@ async function runTaskApproval(cliVersion, args, approved) {
 }
 export async function runTaskCommand(cliVersion, args) {
     const parsed = parseArgs(args);
-    const subcommand = requirePositional(parsed, 0, "Uso: vp task <run|templates|list|inspect|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health> [...]");
+    const subcommand = requirePositional(parsed, 0, "Uso: vp task <run|templates|list|inspect|watch|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health> [...]");
     switch (subcommand) {
         case "run":
             return runTaskRun(cliVersion, args.slice(1));
@@ -475,6 +515,8 @@ export async function runTaskCommand(cliVersion, args) {
             return runTaskList(cliVersion, args.slice(1));
         case "inspect":
             return runTaskInspect(cliVersion, args.slice(1));
+        case "watch":
+            return runTaskWatch(cliVersion, args.slice(1));
         case "claim":
             return runTaskClaim(cliVersion, args.slice(1));
         case "execute":
@@ -496,7 +538,7 @@ export async function runTaskCommand(cliVersion, args) {
         case "health":
             return runTaskHealth(cliVersion, args.slice(1));
         default:
-            throw new ValidationError("Uso: vp task <run|templates|list|inspect|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health> [...]");
+            throw new ValidationError("Uso: vp task <run|templates|list|inspect|watch|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health> [...]");
     }
 }
 //# sourceMappingURL=task.js.map

package/dist/commands/workspace.js

@@ -39,6 +39,20 @@ function printPolicyRule(rule) {
         process.stdout.write(`Required capabilities: ${rule.conditions.requiredCapabilities.join(", ")}\n`);
     }
 }
+function printWebhook(hook) {
+    process.stdout.write(`Webhook: ${hook.id}\n`);
+    process.stdout.write(`Nome: ${hook.name}\n`);
+    process.stdout.write(`URL: ${hook.targetUrl}\n`);
+    process.stdout.write(`Enabled: ${hook.enabled ? "true" : "false"}\n`);
+    process.stdout.write(`Secret: ${hook.secretPreview}\n`);
+    process.stdout.write(`Eventos: ${hook.events.join(", ")}\n`);
+    if (hook.lastDeliveryStatus) {
+        process.stdout.write(`Última entrega: ${hook.lastDeliveryStatus}${hook.lastDeliveryAt ? ` em ${hook.lastDeliveryAt}` : ""}\n`);
+    }
+    if (hook.lastError) {
+        process.stdout.write(`Erro: ${hook.lastError}\n`);
+    }
+}
 function resolvePolicyConditions(parsed) {
     const archetypes = getStringListOption(parsed, "archetypes");
     const requiredCapabilities = getStringListOption(parsed, "required-capabilities");
@@ -155,6 +169,54 @@ async function runWorkspacePolicyCommand(args) {
     }
     throw new ValidationError("Subcomando de workspace policy não suportado.");
 }
+async function runWorkspaceWebhookCommand(args) {
+    const parsed = parseArgs(args);
+    const [subcommand] = parsed.positionals.slice(1);
+    const { session, apiClient, workspace } = await resolveWorkspaceApiContext();
+    if (!subcommand || subcommand === "list") {
+        const hooks = await apiClient.listWorkspaceWebhooks(session.accessToken, workspace);
+        if (printJsonIfRequested(parsed, hooks)) {
+            return 0;
+        }
+        if (hooks.length === 0) {
+            process.stdout.write("VectorPlane: nenhum webhook encontrado.\n");
+            return 0;
+        }
+        for (const hook of hooks) {
+            process.stdout.write(`${hook.id} | ${hook.enabled ? "enabled" : "disabled"} | ${hook.name} | ${hook.targetUrl}\n`);
+        }
+        return 0;
+    }
+    if (subcommand === "create") {
+        const name = getStringOption(parsed, "name")?.trim();
+        const targetUrl = getStringOption(parsed, "url")?.trim();
+        const secret = getStringOption(parsed, "secret")?.trim();
+        const events = getStringListOption(parsed, "events");
+        if (!name || !targetUrl || !secret || events.length === 0) {
+            throw new ValidationError("Informe `--name`, `--url`, `--secret` e `--events`.");
+        }
+        const hook = await apiClient.createWorkspaceWebhook(session.accessToken, workspace, {
+            name,
+            targetUrl,
+            secret,
+            events,
+            enabled: parsed.options.enabled === undefined ? true : getBooleanOption(parsed, "enabled"),
+        });
+        if (!printJsonIfRequested(parsed, hook)) {
+            printWebhook(hook);
+        }
+        return 0;
+    }
+    if (subcommand === "delete") {
+        const webhookId = requirePositional(parsed, 2, "Informe o identificador do webhook.");
+        const result = await apiClient.deleteWorkspaceWebhook(session.accessToken, workspace, webhookId);
+        if (!printJsonIfRequested(parsed, result)) {
+            process.stdout.write(`Webhook removido: ${result.webhookId}\n`);
+        }
+        return 0;
+    }
+    throw new ValidationError("Subcomando de workspace webhook não suportado.");
+}
 export async function runWorkspaceCommand(args) {
     const parsed = parseArgs(args);
     const [subcommand] = parsed.positionals;
@@ -214,6 +276,9 @@ export async function runWorkspaceCommand(args) {
     if (subcommand === "policy") {
         return runWorkspacePolicyCommand(args);
     }
+    if (subcommand === "webhook") {
+        return runWorkspaceWebhookCommand(args);
+    }
     throw new ValidationError("Subcomando de workspace não suportado.");
 }
 //# sourceMappingURL=workspace.js.map

package/dist/core/api.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "./logger.js";
 import type { CurrentUserResponse, AuthCodeExchangeRequest, AuthTokenExchangeResponse, CreateLoginAttemptRequest, CreateLoginAttemptResponse, LoginAttemptStatusResponse, RefreshTokenRequest } from "../types/auth.js";
-import type { AgentCheckoutRequest, AgentHeartbeatRequest, AgentSessionRequest, AgentSessionResponse, EventRequest, MemoryDraftCreateRequest, MemoryDraftRecord, MemoryDraftStatus, MemorySearchRecord, ClaimableTaskStepRecord, ClaimedTaskStepResponse, TaskCreateRequest, TaskHandoffRecord, TaskObservabilityRecord, TaskRecord, ResolveWorkspaceRequest, ResolveWorkspaceResponse, SyncRequest, SyncResponse, WorkspaceAgentSetup, WorkspacePolicyRuleRecord, AgentRegistryRecord, TaskTemplateRecord } from "../types/api.js";
+import type { AgentCheckoutRequest, AgentHeartbeatRequest, AgentSessionRequest, AgentSessionResponse, EventRequest, MemoryDraftCreateRequest, MemoryDraftRecord, MemoryDraftStatus, MemorySearchRecord, ClaimableTaskStepRecord, ClaimedTaskStepResponse, TaskCreateRequest, TaskHandoffRecord, TaskObservabilityRecord, TaskRecord, ResolveWorkspaceRequest, ResolveWorkspaceResponse, SyncRequest, SyncResponse, WorkspaceAgentSetup, WorkspaceSnapshotDiffRecord, WorkspacePolicyRuleRecord, WorkspaceWebhookRecord, AgentRegistryRecord, TaskTemplateRecord, WorkspaceStreamEventRecord } from "../types/api.js";
 export declare class VectorPlaneApiClient {
     private readonly apiBaseUrl;
     private readonly timeoutMs;
@@ -20,6 +20,10 @@ export declare class VectorPlaneApiClient {
     resolveWorkspaceByRepo(accessToken: string, payload: ResolveWorkspaceRequest): Promise<ResolveWorkspaceResponse>;
     getWorkspaceContext(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
     getWorkspaceSnapshot(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
+    getWorkspaceSnapshotDiff(accessToken: string, workspaceId: string, params: {
+        from?: string;
+        to?: string;
+    }): Promise<WorkspaceSnapshotDiffRecord>;
     getWorkspaceDeliveryContext(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
     getWorkspaceDeliveryContextSemantic(accessToken: string, workspaceId: string, params: {
         query: string;
@@ -49,6 +53,18 @@ export declare class VectorPlaneApiClient {
         approvalRole?: string | null;
         enabled?: boolean;
     }): Promise<WorkspacePolicyRuleRecord>;
+    listWorkspaceWebhooks(accessToken: string, workspaceRef: string): Promise<WorkspaceWebhookRecord[]>;
+    createWorkspaceWebhook(accessToken: string, workspaceRef: string, payload: {
+        name: string;
+        targetUrl: string;
+        secret: string;
+        events: WorkspaceWebhookRecord["events"];
+        enabled?: boolean;
+    }): Promise<WorkspaceWebhookRecord>;
+    deleteWorkspaceWebhook(accessToken: string, workspaceRef: string, webhookId: string): Promise<{
+        deleted: boolean;
+        webhookId: string;
+    }>;
     listMemoryDrafts(accessToken: string, workspaceRef: string, status?: MemoryDraftStatus): Promise<MemoryDraftRecord[]>;
     createMemoryDraft(accessToken: string, workspaceRef: string, payload: MemoryDraftCreateRequest): Promise<MemoryDraftRecord>;
     searchWorkspaceMemory(accessToken: string, workspaceRef: string, params: {
@@ -119,4 +135,10 @@ export declare class VectorPlaneApiClient {
     checkOutAgent(accessToken: string, payload: AgentCheckoutRequest): Promise<AgentSessionResponse>;
     getHealth(): Promise<Record<string, unknown>>;
     getReady(): Promise<Record<string, unknown>>;
+    streamWorkspaceEvents(accessToken: string, workspaceRef: string, params: {
+        taskId?: string;
+        types?: string[];
+        signal?: AbortSignal;
+        onEvent: (event: WorkspaceStreamEventRecord) => void;
+    }): Promise<void>;
 }

package/dist/core/api.js

@@ -144,6 +144,21 @@ export class VectorPlaneApiClient {
             },
         }, this.timeoutMs, this.logger);
     }
+    async getWorkspaceSnapshotDiff(accessToken, workspaceId, params) {
+        const url = new URL(`${this.apiBaseUrl}/workspace/${workspaceId}/snapshot/diff`);
+        if (params.from) {
+            url.searchParams.set("from", params.from);
+        }
+        if (params.to) {
+            url.searchParams.set("to", params.to);
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async getWorkspaceDeliveryContext(accessToken, workspaceId) {
         return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/delivery-context`, {
             method: "GET",
@@ -202,6 +217,29 @@ export class VectorPlaneApiClient {
             body: JSON.stringify(payload),
         }, this.timeoutMs, this.logger);
     }
+    async listWorkspaceWebhooks(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createWorkspaceWebhook(accessToken, workspaceRef, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async deleteWorkspaceWebhook(accessToken, workspaceRef, webhookId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks/${webhookId}`, {
+            method: "DELETE",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async listMemoryDrafts(accessToken, workspaceRef, status) {
         const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/memory-drafts`);
         if (status) {
@@ -421,5 +459,79 @@ export class VectorPlaneApiClient {
             method: "GET",
         }, this.timeoutMs, this.logger);
     }
+    async streamWorkspaceEvents(accessToken, workspaceRef, params) {
+        const url = new URL(`${this.apiBaseUrl}/workspace/${workspaceRef}/events/stream`);
+        if (params.taskId) {
+            url.searchParams.set("task_id", params.taskId);
+        }
+        if (params.types && params.types.length > 0) {
+            url.searchParams.set("types", params.types.join(","));
+        }
+        this.logger.debug("http_stream_open", { url: url.toString() });
+        const response = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+                "Accept": "text/event-stream",
+            },
+            signal: params.signal,
+        });
+        if (!response.ok || !response.body) {
+            const body = await parseBody(response);
+            const message = typeof body === "string" ? body : `HTTP ${response.status}`;
+            throw new ApiError(message, response.status, body);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const emitFrame = (frame) => {
+            const lines = frame.split("\n");
+            let eventName = "message";
+            const dataLines = [];
+            for (const line of lines) {
+                if (line.startsWith("event:")) {
+                    eventName = line.slice(6).trim();
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trim());
+                }
+            }
+            if (dataLines.length === 0) {
+                return;
+            }
+            try {
+                const payload = JSON.parse(dataLines.join("\n"));
+                params.onEvent({
+                    type: eventName,
+                    workspaceId: payload.workspaceId,
+                    taskId: payload.taskId ?? null,
+                    stepId: payload.stepId ?? null,
+                    timestamp: payload.timestamp,
+                    summary: payload.summary ?? null,
+                });
+            }
+            catch (error) {
+                this.logger.debug("http_stream_frame_ignored", {
+                    reason: error instanceof Error ? error.message : "invalid_json",
+                    eventName,
+                });
+            }
+        };
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let separatorIndex = buffer.indexOf("\n\n");
+            while (separatorIndex >= 0) {
+                const frame = buffer.slice(0, separatorIndex);
+                buffer = buffer.slice(separatorIndex + 2);
+                emitFrame(frame);
+                separatorIndex = buffer.indexOf("\n\n");
+            }
+        }
+    }
 }
 //# sourceMappingURL=api.js.map

package/dist/index.js

@@ -35,13 +35,13 @@ function printHelp() {
     process.stdout.write("  logout\n");
     process.stdout.write("  sync [--force]\n");
     process.stdout.write("  status\n");
-    process.stdout.write("  task <run|templates|list|inspect|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health>\n");
+    process.stdout.write("  task <run|templates|list|inspect|watch|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health>\n");
     process.stdout.write("  registry <list|register|update|deactivate>\n");
     process.stdout.write("  whoami\n");
     process.stdout.write("  doctor\n");
     process.stdout.write("  draft <create|list>\n");
     process.stdout.write("  config <profile|get|set>\n");
-    process.stdout.write("  workspace <current|use|resolve|clear>\n");
+    process.stdout.write("  workspace <current|use|resolve|clear|policy|webhook>\n");
     process.stdout.write("  session <check-in|heartbeat|check-out>\n");
     process.stdout.write("  context [--snapshot|--delivery]\n");
     process.stdout.write("  bootstrap\n");

package/dist/types/api.d.ts

@@ -88,6 +88,23 @@ export interface WorkspacePolicyRuleRecord {
     updatedAt: string;
     [key: string]: unknown;
 }
+export type WorkspaceWebhookEventType = "task.created" | "task.blocked" | "task.completed" | "task.approval_required" | "health.degraded";
+export interface WorkspaceWebhookRecord {
+    id: string;
+    orgId: string;
+    workspaceId: string;
+    name: string;
+    targetUrl: string;
+    secretPreview: string;
+    events: WorkspaceWebhookEventType[];
+    enabled: boolean;
+    lastDeliveryAt: string | null;
+    lastDeliveryStatus: "delivered" | "failed" | null;
+    lastError: string | null;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
 export interface AgentRegistryRecord {
     id: string;
     orgId: string | null;
@@ -291,3 +308,32 @@ export interface TaskObservabilityRecord {
     timeline?: Array<Record<string, unknown>>;
     [key: string]: unknown;
 }
+export interface WorkspaceStreamEventRecord {
+    type: string;
+    workspaceId: string;
+    taskId?: string | null;
+    stepId?: string | null;
+    timestamp: string;
+    summary?: Record<string, unknown> | null;
+}
+export interface WorkspaceSnapshotDiffRecord {
+    workspaceId: string;
+    from: {
+        reference: string;
+        version: number;
+        generatedAt: string;
+    };
+    to: {
+        reference: string;
+        version: number;
+        generatedAt: string;
+    };
+    summary: Record<string, {
+        added: number;
+        removed: number;
+        modified: number;
+    }>;
+    added: Record<string, Array<Record<string, unknown>>>;
+    removed: Record<string, Array<Record<string, unknown>>>;
+    modified: Record<string, Array<Record<string, unknown>>>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectorplane/ctrl-cli",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Official VectorPlane CLI.",
   "type": "module",
   "main": "./dist/index.js",