@vectorplane/ctrl-cli 0.1.11 → 0.1.13

package/dist/commands/workspace.js

@@ -1,10 +1,222 @@
-import { getStringOption, parseArgs, requirePositional } from "../core/cli.js";
+import { getBooleanOption, getStringListOption, getStringOption, parseArgs, requirePositional } from "../core/cli.js";
 import { ensureSessionAvailable, upsertProfile } from "../core/config.js";
 import { collectGitContext } from "../core/git.js";
 import { loadRuntimeStatus } from "../core/runtime.js";
 import { VectorPlaneApiClient } from "../core/api.js";
 import { bindWorkspaceToRoot, clearBoundWorkspace, getBindingStore, resolveWorkspaceRoot } from "../core/workspace-binding.js";
 import { ValidationError } from "../core/errors.js";
+function printJsonIfRequested(parsed, payload) {
+    if (!getBooleanOption(parsed, "json")) {
+        return false;
+    }
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return true;
+}
+function printPolicyRule(rule) {
+    process.stdout.write(`Rule: ${rule.id}\n`);
+    process.stdout.write(`Nome: ${rule.name}\n`);
+    process.stdout.write(`Effect: ${rule.effect}\n`);
+    process.stdout.write(`Enabled: ${rule.enabled ? "true" : "false"}\n`);
+    if (rule.pathPrefix) {
+        process.stdout.write(`Path: ${rule.pathPrefix}\n`);
+    }
+    if (rule.capability) {
+        process.stdout.write(`Capability: ${rule.capability}\n`);
+    }
+    if (rule.approvalRole) {
+        process.stdout.write(`Approval role: ${rule.approvalRole}\n`);
+    }
+    if (rule.rationale) {
+        process.stdout.write(`Rationale: ${rule.rationale}\n`);
+    }
+    if (rule.conditions?.archetypes?.length) {
+        process.stdout.write(`Archetypes: ${rule.conditions.archetypes.join(", ")}\n`);
+    }
+    if (typeof rule.conditions?.minTargetPathCount === "number") {
+        process.stdout.write(`Min target paths: ${rule.conditions.minTargetPathCount}\n`);
+    }
+    if (rule.conditions?.requiredCapabilities?.length) {
+        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");
+    const minTargetPathCountRaw = getStringOption(parsed, "min-target-path-count");
+    const minTargetPathCount = minTargetPathCountRaw ? Number(minTargetPathCountRaw) : undefined;
+    if (minTargetPathCountRaw && (!Number.isInteger(minTargetPathCount) || (minTargetPathCount ?? 0) < 1)) {
+        throw new ValidationError("`--min-target-path-count` deve ser um inteiro maior que zero.");
+    }
+    if (archetypes.length === 0 && requiredCapabilities.length === 0 && minTargetPathCount === undefined) {
+        return undefined;
+    }
+    return {
+        ...(archetypes.length > 0 ? { archetypes } : {}),
+        ...(requiredCapabilities.length > 0 ? { requiredCapabilities } : {}),
+        ...(minTargetPathCount !== undefined ? { minTargetPathCount } : {}),
+    };
+}
+async function resolveWorkspaceApiContext() {
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const git = await collectGitContext(process.cwd());
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    const store = await getBindingStore();
+    const binding = store.bindings[rootPath];
+    const workspace = binding?.workspace ?? runtime.profile.workspace;
+    if (!workspace) {
+        throw new ValidationError("Nenhum workspace resolvido. Use `vp workspace use <workspace>` ou `vp workspace resolve`.");
+    }
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    return { runtime, session, apiClient, workspace };
+}
+async function runWorkspacePolicyCommand(args) {
+    const parsed = parseArgs(args);
+    const [subcommand] = parsed.positionals.slice(1);
+    const { session, apiClient, workspace } = await resolveWorkspaceApiContext();
+    if (!subcommand || subcommand === "list") {
+        const rules = await apiClient.listWorkspacePolicyRules(session.accessToken, workspace);
+        if (printJsonIfRequested(parsed, rules)) {
+            return 0;
+        }
+        if (rules.length === 0) {
+            process.stdout.write("VectorPlane: nenhuma policy rule encontrada.\n");
+            return 0;
+        }
+        for (const rule of rules) {
+            process.stdout.write(`${rule.id} | ${rule.enabled ? "enabled" : "disabled"} | ${rule.effect} | ${rule.name}\n`);
+        }
+        return 0;
+    }
+    if (subcommand === "create") {
+        const name = getStringOption(parsed, "name")?.trim();
+        const pathPrefix = getStringOption(parsed, "path")?.trim();
+        const capability = getStringOption(parsed, "capability")?.trim();
+        const effect = getStringOption(parsed, "effect")?.trim();
+        if (!name || !effect || (!pathPrefix && !capability)) {
+            throw new ValidationError("Informe `--name`, `--effect` e pelo menos um entre `--path` ou `--capability`.");
+        }
+        const rule = await apiClient.createWorkspacePolicyRule(session.accessToken, workspace, {
+            name,
+            pathPrefix: pathPrefix || undefined,
+            capability: capability || undefined,
+            effect,
+            rationale: getStringOption(parsed, "rationale")?.trim() || undefined,
+            approvalRole: getStringOption(parsed, "approval-role")?.trim() || undefined,
+            enabled: parsed.options.enabled === undefined ? true : getBooleanOption(parsed, "enabled"),
+            conditions: resolvePolicyConditions(parsed),
+        });
+        if (!printJsonIfRequested(parsed, rule)) {
+            printPolicyRule(rule);
+        }
+        return 0;
+    }
+    if (subcommand === "update") {
+        const ruleId = requirePositional(parsed, 2, "Informe o identificador da policy rule.");
+        const updates = {};
+        if (parsed.options.name !== undefined) {
+            updates.name = getStringOption(parsed, "name")?.trim();
+        }
+        if (parsed.options.path !== undefined) {
+            updates.pathPrefix = getStringOption(parsed, "path")?.trim() || null;
+        }
+        if (parsed.options.capability !== undefined) {
+            updates.capability = getStringOption(parsed, "capability")?.trim() || null;
+        }
+        if (parsed.options.effect !== undefined) {
+            updates.effect = getStringOption(parsed, "effect")?.trim();
+        }
+        if (parsed.options.rationale !== undefined) {
+            updates.rationale = getStringOption(parsed, "rationale")?.trim() || null;
+        }
+        if (parsed.options["approval-role"] !== undefined) {
+            updates.approvalRole = getStringOption(parsed, "approval-role")?.trim() || null;
+        }
+        if (parsed.options.enabled !== undefined) {
+            updates.enabled = getBooleanOption(parsed, "enabled");
+        }
+        if (parsed.options["clear-conditions"]) {
+            updates.conditions = null;
+        }
+        else {
+            const conditions = resolvePolicyConditions(parsed);
+            if (conditions) {
+                updates.conditions = conditions;
+            }
+        }
+        if (Object.keys(updates).length === 0) {
+            throw new ValidationError("Informe ao menos um campo para atualização.");
+        }
+        const rule = await apiClient.updateWorkspacePolicyRule(session.accessToken, workspace, ruleId, updates);
+        if (!printJsonIfRequested(parsed, rule)) {
+            printPolicyRule(rule);
+        }
+        return 0;
+    }
+    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;
@@ -61,6 +273,12 @@ export async function runWorkspaceCommand(args) {
         process.stdout.write(`Workspace resolvido: ${workspace}\n`);
         return 0;
     }
+    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/agent-runtime-detection.d.ts

@@ -0,0 +1,13 @@
+export type SupportedAgent = "claude" | "cursor" | "windsurf" | "copilot" | "codex" | "generic";
+export type DetectionConfidence = "high" | "medium" | "low";
+export interface AgentDetectionResult {
+    selected: SupportedAgent | null;
+    confidence: DetectionConfidence;
+    reasons: string[];
+    candidates: SupportedAgent[];
+}
+export declare function detectAgentRuntime(rootPath: string): Promise<AgentDetectionResult>;
+export declare function resolveAgentSelection(rootPath: string, explicitAgent?: SupportedAgent): Promise<{
+    agent: SupportedAgent;
+    detection: AgentDetectionResult;
+}>;

package/dist/core/agent-runtime-detection.js

@@ -0,0 +1,117 @@
+import { access } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { ValidationError } from "./errors.js";
+async function pathExists(filePath) {
+    try {
+        await access(filePath, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function uniqueAgents(values) {
+    return [...new Set(values)];
+}
+export async function detectAgentRuntime(rootPath) {
+    const scores = new Map();
+    const reasons = new Map();
+    const addScore = (agent, amount, reason) => {
+        scores.set(agent, (scores.get(agent) ?? 0) + amount);
+        reasons.set(agent, [...(reasons.get(agent) ?? []), reason]);
+    };
+    const fileCandidates = [
+        { agent: "claude", file: path.join(rootPath, "CLAUDE.md") },
+        { agent: "cursor", file: path.join(rootPath, ".cursor") },
+        { agent: "windsurf", file: path.join(rootPath, ".windsurfrules") },
+        { agent: "copilot", file: path.join(rootPath, ".github", "copilot-instructions.md") },
+        { agent: "codex", file: path.join(rootPath, "AGENTS.md") },
+    ];
+    for (const candidate of fileCandidates) {
+        if (await pathExists(candidate.file)) {
+            addScore(candidate.agent, 25, `file:${path.relative(rootPath, candidate.file) || candidate.file}`);
+        }
+    }
+    const envSignals = [
+        { agent: "cursor", value: process.env.CURSOR_TRACE_ID, reason: "env:CURSOR_TRACE_ID" },
+        { agent: "windsurf", value: process.env.WINDSURF_SESSION_ID, reason: "env:WINDSURF_SESSION_ID" },
+        { agent: "codex", value: process.env.CODEX_ENV, reason: "env:CODEX_ENV" },
+        { agent: "claude", value: process.env.CLAUDECODE, reason: "env:CLAUDECODE" },
+        { agent: "copilot", value: process.env.GITHUB_COPILOT, reason: "env:GITHUB_COPILOT" },
+    ];
+    for (const signal of envSignals) {
+        if (signal.value) {
+            addScore(signal.agent, 100, signal.reason);
+        }
+    }
+    const ranked = [...scores.entries()].sort((left, right) => right[1] - left[1]);
+    if (ranked.length === 0) {
+        return { selected: null, confidence: "low", reasons: [], candidates: [] };
+    }
+    const topScore = ranked[0][1];
+    const candidates = uniqueAgents(ranked.filter((entry) => entry[1] === topScore).map(([agent]) => agent));
+    const selected = candidates.length === 1 ? candidates[0] : null;
+    return {
+        selected,
+        confidence: topScore >= 100 ? "high" : candidates.length === 1 ? "medium" : "low",
+        reasons: selected ? (reasons.get(selected) ?? []) : candidates.flatMap((agent) => reasons.get(agent) ?? []),
+        candidates,
+    };
+}
+async function promptForAgent(detection) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new ValidationError("Não foi possível detectar o agente local com segurança. Use --agent claude|cursor|windsurf|copilot|codex|generic.");
+    }
+    const ordered = uniqueAgents([
+        ...detection.candidates,
+        "claude",
+        "cursor",
+        "windsurf",
+        "copilot",
+        "codex",
+        "generic",
+    ]);
+    process.stdout.write("VectorPlane: não foi possível identificar o agente local com segurança.\n");
+    ordered.forEach((agent, index) => {
+        process.stdout.write(`  ${index + 1}. ${agent}\n`);
+    });
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question("Selecione o agente local: ")).trim();
+        const index = Number(answer);
+        if (Number.isInteger(index) && index >= 1 && index <= ordered.length) {
+            return ordered[index - 1];
+        }
+        if (ordered.includes(answer)) {
+            return answer;
+        }
+    }
+    finally {
+        rl.close();
+    }
+    throw new ValidationError("Seleção de agente inválida.");
+}
+export async function resolveAgentSelection(rootPath, explicitAgent) {
+    if (explicitAgent) {
+        return {
+            agent: explicitAgent,
+            detection: {
+                selected: explicitAgent,
+                confidence: "high",
+                reasons: ["explicit-flag"],
+                candidates: [explicitAgent],
+            },
+        };
+    }
+    const detection = await detectAgentRuntime(rootPath);
+    if (detection.selected && detection.confidence !== "low") {
+        return { agent: detection.selected, detection };
+    }
+    return {
+        agent: await promptForAgent(detection),
+        detection,
+    };
+}
+//# sourceMappingURL=agent-runtime-detection.js.map

package/dist/core/agent-setup.d.ts

@@ -1,18 +1,6 @@
 import type { VectorPlaneApiClient } from "./api.js";
 import type { Logger } from "./logger.js";
-export type SupportedAgent = "claude" | "cursor" | "windsurf" | "copilot" | "codex" | "generic";
-export type DetectionConfidence = "high" | "medium" | "low";
-export interface AgentDetectionResult {
-    selected: SupportedAgent | null;
-    confidence: DetectionConfidence;
-    reasons: string[];
-    candidates: SupportedAgent[];
-}
-export declare function detectAgentRuntime(rootPath: string): Promise<AgentDetectionResult>;
-export declare function resolveAgentSelection(rootPath: string, explicitAgent?: SupportedAgent): Promise<{
-    agent: SupportedAgent;
-    detection: AgentDetectionResult;
-}>;
+import { type DetectionConfidence, type SupportedAgent } from "./agent-runtime-detection.js";
 export declare function ensureAgentSetupCurrent(params: {
     rootPath: string;
     workspace: string;

package/dist/core/agent-setup.js

@@ -1,9 +1,9 @@
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import path from "node:path";
-import readline from "node:readline/promises";
 import { ValidationError } from "./errors.js";
 import { bindWorkspaceToRoot, getWorkspaceBinding } from "./workspace-binding.js";
+import { detectAgentRuntime, resolveAgentSelection, } from "./agent-runtime-detection.js";
 const AGENT_TEMPLATE_PATHS = {
     claude: "CLAUDE.md",
     cursor: ".cursor/rules/traceplane.mdc",
@@ -21,92 +21,6 @@ async function pathExists(filePath) {
         return false;
     }
 }
-function uniqueAgents(values) {
-    return [...new Set(values)];
-}
-export async function detectAgentRuntime(rootPath) {
-    const scores = new Map();
-    const reasons = new Map();
-    const addScore = (agent, amount, reason) => {
-        scores.set(agent, (scores.get(agent) ?? 0) + amount);
-        reasons.set(agent, [...(reasons.get(agent) ?? []), reason]);
-    };
-    const fileCandidates = [
-        { agent: "claude", file: path.join(rootPath, "CLAUDE.md") },
-        { agent: "cursor", file: path.join(rootPath, ".cursor") },
-        { agent: "windsurf", file: path.join(rootPath, ".windsurfrules") },
-        { agent: "copilot", file: path.join(rootPath, ".github", "copilot-instructions.md") },
-        { agent: "codex", file: path.join(rootPath, "AGENTS.md") },
-    ];
-    for (const candidate of fileCandidates) {
-        if (await pathExists(candidate.file)) {
-            addScore(candidate.agent, 25, `file:${path.relative(rootPath, candidate.file) || candidate.file}`);
-        }
-    }
-    const envSignals = [
-        { agent: "cursor", value: process.env.CURSOR_TRACE_ID, reason: "env:CURSOR_TRACE_ID" },
-        { agent: "windsurf", value: process.env.WINDSURF_SESSION_ID, reason: "env:WINDSURF_SESSION_ID" },
-        { agent: "codex", value: process.env.CODEX_ENV, reason: "env:CODEX_ENV" },
-        { agent: "claude", value: process.env.CLAUDECODE, reason: "env:CLAUDECODE" },
-        { agent: "copilot", value: process.env.GITHUB_COPILOT, reason: "env:GITHUB_COPILOT" },
-    ];
-    for (const signal of envSignals) {
-        if (signal.value) {
-            addScore(signal.agent, 100, signal.reason);
-        }
-    }
-    const ranked = [...scores.entries()].sort((left, right) => right[1] - left[1]);
-    if (ranked.length === 0) {
-        return {
-            selected: null,
-            confidence: "low",
-            reasons: [],
-            candidates: [],
-        };
-    }
-    const topScore = ranked[0][1];
-    const candidates = uniqueAgents(ranked.filter((entry) => entry[1] === topScore).map(([agent]) => agent));
-    const selected = candidates.length === 1 ? candidates[0] : null;
-    return {
-        selected,
-        confidence: topScore >= 100 ? "high" : candidates.length === 1 ? "medium" : "low",
-        reasons: selected ? (reasons.get(selected) ?? []) : candidates.flatMap((agent) => reasons.get(agent) ?? []),
-        candidates,
-    };
-}
-async function promptForAgent(detection) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        throw new ValidationError("Não foi possível detectar o agente local com segurança. Use --agent claude|cursor|windsurf|copilot|codex|generic.");
-    }
-    const ordered = uniqueAgents([
-        ...detection.candidates,
-        "claude",
-        "cursor",
-        "windsurf",
-        "copilot",
-        "codex",
-        "generic",
-    ]);
-    process.stdout.write("VectorPlane: não foi possível identificar o agente local com segurança.\n");
-    ordered.forEach((agent, index) => {
-        process.stdout.write(`  ${index + 1}. ${agent}\n`);
-    });
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = (await rl.question("Selecione o agente local: ")).trim();
-        const index = Number(answer);
-        if (Number.isInteger(index) && index >= 1 && index <= ordered.length) {
-            return ordered[index - 1];
-        }
-        if (ordered.includes(answer)) {
-            return answer;
-        }
-    }
-    finally {
-        rl.close();
-    }
-    throw new ValidationError("Seleção de agente inválida.");
-}
 async function appendGitIgnoreEntry(rootPath, relativeTarget) {
     const gitIgnorePath = path.join(rootPath, ".gitignore");
     const normalizedEntry = relativeTarget.replace(/\\/g, "/");
@@ -143,27 +57,6 @@ function getAgentTemplate(setup, agent) {
     }
     return template;
 }
-export async function resolveAgentSelection(rootPath, explicitAgent) {
-    if (explicitAgent) {
-        return {
-            agent: explicitAgent,
-            detection: {
-                selected: explicitAgent,
-                confidence: "high",
-                reasons: ["explicit-flag"],
-                candidates: [explicitAgent],
-            },
-        };
-    }
-    const detection = await detectAgentRuntime(rootPath);
-    if (detection.selected && detection.confidence !== "low") {
-        return { agent: detection.selected, detection };
-    }
-    return {
-        agent: await promptForAgent(detection),
-        detection,
-    };
-}
 export async function ensureAgentSetupCurrent(params) {
     const binding = await getWorkspaceBinding(params.rootPath);
     let selection;

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, ResolveWorkspaceRequest, ResolveWorkspaceResponse, SyncRequest, SyncResponse, WorkspaceAgentSetup } 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,13 +20,125 @@ 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;
+        type?: string;
+        authority?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
     getAgentSetup(accessToken: string, workspaceId: string): Promise<WorkspaceAgentSetup>;
+    listWorkspacePolicyRules(accessToken: string, workspaceRef: string): Promise<WorkspacePolicyRuleRecord[]>;
+    createWorkspacePolicyRule(accessToken: string, workspaceRef: string, payload: {
+        name: string;
+        pathPrefix?: string;
+        capability?: string;
+        effect: WorkspacePolicyRuleRecord["effect"];
+        rationale?: string;
+        conditions?: WorkspacePolicyRuleRecord["conditions"];
+        approvalRole?: string;
+        enabled?: boolean;
+    }): Promise<WorkspacePolicyRuleRecord>;
+    updateWorkspacePolicyRule(accessToken: string, workspaceRef: string, ruleId: string, payload: {
+        name?: string;
+        pathPrefix?: string | null;
+        capability?: string | null;
+        effect?: WorkspacePolicyRuleRecord["effect"];
+        rationale?: string | null;
+        conditions?: WorkspacePolicyRuleRecord["conditions"] | null;
+        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: {
+        query: string;
+        type?: string;
+        authority?: string;
+        limit?: number;
+    }): Promise<MemorySearchRecord[]>;
+    listTasks(accessToken: string, workspaceRef: string): Promise<TaskRecord[]>;
+    createTask(accessToken: string, workspaceRef: string, payload: TaskCreateRequest): Promise<TaskRecord>;
+    listTaskTemplates(accessToken: string): Promise<TaskTemplateRecord[]>;
+    getTask(accessToken: string, workspaceRef: string, taskId: string): Promise<TaskRecord>;
+    listClaimableTaskSteps(accessToken: string, workspaceRef: string, filters?: {
+        capability?: string;
+        agentName?: string;
+    }): Promise<ClaimableTaskStepRecord[]>;
+    claimTaskStep(accessToken: string, workspaceRef: string, taskId: string, stepId: string, payload?: {
+        sessionId?: string;
+        clientInstanceId?: string;
+        agentName?: string;
+    }): Promise<ClaimedTaskStepResponse>;
+    delegateTask(accessToken: string, workspaceRef: string, taskId: string, stepId: string, toAgentId: string, reason: string): Promise<TaskRecord>;
+    callbackTaskStep(accessToken: string, workspaceRef: string, taskId: string, stepId: string, payload: {
+        status: "running" | "completed" | "failed" | "blocked";
+        agentId?: string;
+        output?: Record<string, unknown>;
+        error?: string;
+    }): Promise<TaskRecord>;
+    getTaskHandoff(accessToken: string, workspaceRef: string, taskId: string): Promise<TaskHandoffRecord>;
+    getTaskObservability(accessToken: string, workspaceRef: string, taskId: string): Promise<TaskObservabilityRecord>;
+    getWorkspaceTaskObservability(accessToken: string, workspaceRef: string): Promise<TaskObservabilityRecord>;
+    approveTask(accessToken: string, workspaceRef: string, taskId: string, payload: {
+        approved: boolean;
+        approvedBy?: string;
+        rationale?: string;
+    }): Promise<TaskRecord>;
+    listAgentRegistry(accessToken: string): Promise<AgentRegistryRecord[]>;
+    createRegistryAgent(accessToken: string, payload: {
+        orgId?: string;
+        name: string;
+        runtimeType: string;
+        provider: string;
+        model: string;
+        capabilities: string[];
+        costProfile: string;
+        latencyProfile: string;
+        reliabilityScore: number;
+        status?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AgentRegistryRecord>;
+    updateRegistryAgent(accessToken: string, agentId: string, payload: {
+        name?: string;
+        provider?: string;
+        model?: string;
+        capabilities?: string[];
+        costProfile?: string;
+        latencyProfile?: string;
+        reliabilityScore?: number;
+        status?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AgentRegistryRecord>;
+    deactivateRegistryAgent(accessToken: string, agentId: string): Promise<{
+        deactivated: boolean;
+    }>;
+    getWorkspaceHealth(accessToken: string, workspaceRef: string): Promise<Record<string, unknown>>;
     checkInAgent(accessToken: string, payload: AgentSessionRequest): Promise<AgentSessionResponse>;
     heartbeatAgent(accessToken: string, payload: AgentHeartbeatRequest): Promise<AgentSessionResponse>;
     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>;
 }