@vectorplane/ctrl-cli 0.1.11 → 0.1.12

package/README.md

@@ -18,6 +18,14 @@ vp login
 vp logout
 vp status
 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 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 --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"
@@ -42,6 +50,7 @@ vp draft create --type progress --title "Entrega concluída" --content "Resumo d
 - salva a sessão localmente
 - suporta `--no-browser` e `--manual`
 - em ambientes remotos ou isolados, o loopback local pode exigir um fluxo alternativo
+- a URL web do login é emitida pelo control plane; o domínio do app não deve ser hardcoded em automações externas
 
 ### `vp logout`
 
@@ -59,6 +68,25 @@ vp draft create --type progress --title "Entrega concluída" --content "Resumo d
 - mostra o estado da sessão local
 - exibe workspace ativo, diretório atual e última sincronização
 
+### `vp task`
+
+- cria tasks no orchestrator do workspace
+- 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
+- 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 ...`
+- registra delegação de step
+- envia callback de execução por step para concluir a pipeline
+- lê handoff operacional por task
+- consulta observabilidade por task ou workspace
+- consulta health do workspace ligado às tasks
+- para automação local real, o agente de registry deve ter `metadata.execution` com:
+  - `type: "command"`
+  - `command: "npm"` ou equivalente
+  - `args`, `cwd` e `env` opcionais
+
 ### `vp draft`
 
 - cria drafts editoriais ligados ao workspace atual
@@ -87,12 +115,16 @@ vp draft create --type progress --title "Entrega concluída" --content "Resumo d
   - 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
 - `vp bootstrap`
   - obtém instruções de setup do workspace
 - `vp event send`
   - envia eventos operacionais
 - `vp draft`
   - envia e consulta drafts editoriais do workspace
+- `vp task`
+  - opera tasks do autonomous control plane
 
 ## Persistência local
 

package/dist/commands/context.js

@@ -7,11 +7,12 @@ import { ensureFreshSession, resolveWorkspaceSlug } from "../core/session.js";
 import { VectorPlaneApiClient } from "../core/api.js";
 import { getBoundWorkspace, resolveWorkspaceRoot } from "../core/workspace-binding.js";
 import { ValidationError } from "../core/errors.js";
-import { ensureAgentSetupCurrent } from "../core/agent-setup.js";
+import { ensureRuntimeAgentSetup } from "../core/runtime-agent-setup.js";
 export async function runContextCommand(cliVersion, args) {
     const parsed = parseArgs(args);
     const delivery = getBooleanOption(parsed, "delivery");
     const snapshot = getBooleanOption(parsed, "snapshot");
+    const search = getStringOption(parsed, "search")?.trim();
     const runtime = await loadRuntimeStatus();
     const session = await ensureSessionAvailable(runtime.profile.name);
     const [git, machine, runtimeContext] = await Promise.all([
@@ -36,20 +37,26 @@ export async function runContextCommand(cliVersion, args) {
     if (!workspace) {
         throw new ValidationError("Nenhum workspace resolvido para carregar contexto.");
     }
-    await ensureAgentSetupCurrent({
-        rootPath,
-        workspace,
-        repoUrl: git.remoteOrigin,
-        source: git.remoteOrigin ? "api-resolve" : "manual",
-        accessToken: freshSession.accessToken,
-        apiClient,
-        logger: runtime.logger,
-    });
-    const payload = delivery
-        ? await apiClient.getWorkspaceDeliveryContext(freshSession.accessToken, workspace)
-        : snapshot
-            ? await apiClient.getWorkspaceSnapshot(freshSession.accessToken, workspace)
-            : await apiClient.getWorkspaceContext(freshSession.accessToken, workspace);
+    await ensureRuntimeAgentSetup({ rootPath, workspace, git, session: freshSession, apiClient, logger: runtime.logger });
+    const payload = search
+        ? (delivery
+            ? await apiClient.getWorkspaceDeliveryContextSemantic(freshSession.accessToken, workspace, {
+                query: search,
+                type: getStringOption(parsed, "type")?.trim(),
+                authority: getStringOption(parsed, "authority")?.trim(),
+                limit: Number(getStringOption(parsed, "limit") ?? "0") || undefined,
+            })
+            : await apiClient.searchWorkspaceMemory(freshSession.accessToken, workspace, {
+                query: search,
+                type: getStringOption(parsed, "type")?.trim(),
+                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);
     process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
     return 0;
 }

package/dist/commands/init.js

@@ -1,76 +1,32 @@
 import { getBooleanOption, getStringOption, parseArgs } from "../core/cli.js";
-import { ensureSessionAvailable, loadSession, upsertProfile } from "../core/config.js";
-import { collectGitContext } from "../core/git.js";
 import { runLoginCommand } from "./login.js";
-import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
 import { loadRuntimeStatus } from "../core/runtime.js";
-import { ensureFreshSession } from "../core/session.js";
-import { VectorPlaneApiClient } from "../core/api.js";
-import { ensureAgentSetupCurrent } from "../core/agent-setup.js";
-import { resolveWorkspaceRoot } from "../core/workspace-binding.js";
-import { resolveAuthorizedWorkspace } from "../core/workspace-resolution.js";
+import { buildInitLoginArgs, runInitWorkspaceUseCase } from "../core/init-workspace.js";
 export async function runInitCommand(cliVersion, args) {
     const parsed = parseArgs(args);
     const force = getBooleanOption(parsed, "force");
     const requestedAgent = getStringOption(parsed, "agent");
     const explicitWorkspace = getStringOption(parsed, "workspace");
-    const loginArgs = [];
-    if (getBooleanOption(parsed, "manual")) {
-        loginArgs.push("--manual");
-    }
-    if (getBooleanOption(parsed, "no-browser")) {
-        loginArgs.push("--no-browser");
-    }
     const requestedProfile = getStringOption(parsed, "profile");
-    if (requestedProfile) {
-        loginArgs.push("--profile", requestedProfile);
-    }
-    let runtime = await loadRuntimeStatus();
-    let session = await loadSession(runtime.profile.name);
-    if (!session) {
-        runtime.logger.info("sessão local ausente, iniciando login...");
-        await runLoginCommand(cliVersion, loginArgs);
-        runtime = await loadRuntimeStatus();
-        session = await ensureSessionAvailable(runtime.profile.name);
-    }
-    const [git, machine, runtimeContext] = await Promise.all([
-        collectGitContext(process.cwd()),
-        collectMachineContext(runtime.device, runtime.config),
-        collectRuntimeContext(cliVersion, "init", process.argv.slice(2)),
-    ]);
-    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
-    const freshSession = await ensureFreshSession({
-        profileName: runtime.profile.name,
-        session,
-        machine,
-        runtime: runtimeContext,
-        device: runtime.device,
-        apiClient,
-        logger: runtime.logger,
+    const loginArgs = await buildInitLoginArgs({
+        manual: getBooleanOption(parsed, "manual"),
+        noBrowser: getBooleanOption(parsed, "no-browser"),
+        profile: requestedProfile ?? undefined,
     });
-    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
-    const workspace = await resolveAuthorizedWorkspace({
-        apiClient,
-        accessToken: freshSession.accessToken,
-        git,
-        explicitWorkspace: explicitWorkspace ?? undefined,
-        profile: runtime.profile,
-        session: freshSession,
-    });
-    const result = await ensureAgentSetupCurrent({
-        rootPath,
-        workspace,
-        repoUrl: git.remoteOrigin,
-        source: git.remoteOrigin ? "api-resolve" : "manual",
-        accessToken: freshSession.accessToken,
-        apiClient,
-        logger: runtime.logger,
-        explicitAgent: requestedAgent,
+    const runtime = await loadRuntimeStatus();
+    const result = await runInitWorkspaceUseCase({
+        cliVersion,
+        commandArgs: process.argv.slice(2),
+        runtime,
         force,
+        explicitWorkspace: explicitWorkspace ?? undefined,
+        requestedAgent,
+        ensureLoggedIn: async () => {
+            await runLoginCommand(cliVersion, loginArgs);
+        },
     });
-    await upsertProfile(runtime.profile.name, { workspace });
     runtime.logger.success("workspace inicializado.");
-    process.stdout.write(`Workspace: ${workspace}\n`);
+    process.stdout.write(`Workspace: ${result.workspace}\n`);
     process.stdout.write(`Agente configurado: ${result.agent}\n`);
     process.stdout.write(`Confiança da detecção: ${result.confidence}\n`);
     process.stdout.write(`Template: ${result.templatePath} (${result.fileStatus})\n`);

package/dist/commands/registry.d.ts

@@ -0,0 +1 @@
+export declare function runRegistryCommand(args: string[]): Promise<number>;

package/dist/commands/registry.js

@@ -0,0 +1,116 @@
+import { getBooleanOption, getStringListOption, getStringOption, parseArgs, parseJsonOption, requirePositional } from "../core/cli.js";
+import { ensureSessionAvailable } from "../core/config.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { VectorPlaneApiClient } from "../core/api.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 printAgent(agent) {
+    process.stdout.write(`Agent: ${agent.id}\n`);
+    process.stdout.write(`Nome: ${agent.name}\n`);
+    process.stdout.write(`Runtime: ${agent.runtimeType}\n`);
+    process.stdout.write(`Provider: ${agent.provider}\n`);
+    process.stdout.write(`Model: ${agent.model}\n`);
+    process.stdout.write(`Status: ${agent.status}\n`);
+    process.stdout.write(`Reliability: ${String(agent.reliabilityScore)}\n`);
+    process.stdout.write(`Capabilities: ${agent.capabilities.join(", ")}\n`);
+    if (agent.metadata && Object.keys(agent.metadata).length > 0) {
+        process.stdout.write(`Metadata: ${JSON.stringify(agent.metadata)}\n`);
+    }
+}
+async function resolveRegistryContext() {
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    return { runtime, session, apiClient };
+}
+export async function runRegistryCommand(args) {
+    const parsed = parseArgs(args);
+    const subcommand = requirePositional(parsed, 0, "Uso: vp registry <list|register|update|deactivate> [...]");
+    const { runtime, session, apiClient } = await resolveRegistryContext();
+    if (subcommand === "list") {
+        const agents = await apiClient.listAgentRegistry(session.accessToken);
+        if (printJsonIfRequested(parsed, agents))
+            return 0;
+        if (agents.length === 0) {
+            process.stdout.write("VectorPlane: nenhum agente registrado.\n");
+            return 0;
+        }
+        for (const agent of agents) {
+            process.stdout.write(`${agent.id} | ${agent.status} | ${agent.runtimeType} | ${agent.provider}/${agent.model} | ${agent.name}\n`);
+        }
+        return 0;
+    }
+    if (subcommand === "register") {
+        const name = getStringOption(parsed, "name")?.trim();
+        const runtimeType = getStringOption(parsed, "runtime")?.trim();
+        const provider = getStringOption(parsed, "provider")?.trim();
+        const model = getStringOption(parsed, "model")?.trim();
+        if (!name || !runtimeType || !provider || !model) {
+            throw new ValidationError("Informe `--name`, `--runtime`, `--provider` e `--model`.");
+        }
+        const agent = await apiClient.createRegistryAgent(session.accessToken, {
+            orgId: getStringOption(parsed, "org-id")?.trim() || undefined,
+            name,
+            runtimeType,
+            provider,
+            model,
+            capabilities: getStringListOption(parsed, "capabilities"),
+            costProfile: getStringOption(parsed, "cost")?.trim() || "standard",
+            latencyProfile: getStringOption(parsed, "latency")?.trim() || "standard",
+            reliabilityScore: Number(getStringOption(parsed, "reliability") ?? "0.9"),
+            status: getStringOption(parsed, "status")?.trim() || "active",
+            metadata: parseJsonOption(getStringOption(parsed, "metadata")),
+        });
+        runtime.logger.success("agente registrado.");
+        if (!printJsonIfRequested(parsed, agent)) {
+            printAgent(agent);
+        }
+        return 0;
+    }
+    if (subcommand === "update") {
+        const agentId = requirePositional(parsed, 1, "Informe o identificador do agente.");
+        const payload = {};
+        if (parsed.options.name !== undefined)
+            payload.name = getStringOption(parsed, "name")?.trim();
+        if (parsed.options.provider !== undefined)
+            payload.provider = getStringOption(parsed, "provider")?.trim();
+        if (parsed.options.model !== undefined)
+            payload.model = getStringOption(parsed, "model")?.trim();
+        if (parsed.options.capabilities !== undefined)
+            payload.capabilities = getStringListOption(parsed, "capabilities");
+        if (parsed.options.cost !== undefined)
+            payload.costProfile = getStringOption(parsed, "cost")?.trim();
+        if (parsed.options.latency !== undefined)
+            payload.latencyProfile = getStringOption(parsed, "latency")?.trim();
+        if (parsed.options.reliability !== undefined)
+            payload.reliabilityScore = Number(getStringOption(parsed, "reliability"));
+        if (parsed.options.status !== undefined)
+            payload.status = getStringOption(parsed, "status")?.trim();
+        if (parsed.options.metadata !== undefined)
+            payload.metadata = parseJsonOption(getStringOption(parsed, "metadata"));
+        if (Object.keys(payload).length === 0) {
+            throw new ValidationError("Informe ao menos um campo para atualização.");
+        }
+        const agent = await apiClient.updateRegistryAgent(session.accessToken, agentId, payload);
+        runtime.logger.success("agente atualizado.");
+        if (!printJsonIfRequested(parsed, agent)) {
+            printAgent(agent);
+        }
+        return 0;
+    }
+    if (subcommand === "deactivate") {
+        const agentId = requirePositional(parsed, 1, "Informe o identificador do agente.");
+        await apiClient.deactivateRegistryAgent(session.accessToken, agentId);
+        runtime.logger.success("agente desativado.");
+        process.stdout.write(`Agent deactivated: ${agentId}\n`);
+        return 0;
+    }
+    throw new ValidationError("Subcomando de registry não suportado.");
+}
+//# sourceMappingURL=registry.js.map

package/dist/commands/session.js

@@ -7,7 +7,7 @@ import { ensureFreshSession, resolveWorkspaceSlug } from "../core/session.js";
 import { VectorPlaneApiClient } from "../core/api.js";
 import { deriveClientInstanceId, getBoundWorkspace, resolveWorkspaceRoot } from "../core/workspace-binding.js";
 import { ValidationError } from "../core/errors.js";
-import { ensureAgentSetupCurrent } from "../core/agent-setup.js";
+import { ensureRuntimeAgentSetup } from "../core/runtime-agent-setup.js";
 function readCollaborationMetadata(parsed, rootPath) {
     const owningPaths = getStringListOption(parsed, "owning-path");
     const needs = getStringListOption(parsed, "need");
@@ -57,15 +57,7 @@ export async function runSessionCommand(cliVersion, args) {
     if (!workspace) {
         throw new ValidationError("Nenhum workspace resolvido para a sessão.");
     }
-    await ensureAgentSetupCurrent({
-        rootPath,
-        workspace,
-        repoUrl: git.remoteOrigin,
-        source: git.remoteOrigin ? "api-resolve" : "manual",
-        accessToken: freshSession.accessToken,
-        apiClient,
-        logger: runtime.logger,
-    });
+    await ensureRuntimeAgentSetup({ rootPath, workspace, git, session: freshSession, apiClient, logger: runtime.logger });
     const clientInstanceId = getStringOption(parsed, "client-instance-id") ?? deriveClientInstanceId(runtime.device.machineId, rootPath, git);
     const metadata = readCollaborationMetadata(parsed, rootPath);
     if (subcommand === "check-in") {

package/dist/commands/sync.js

@@ -10,7 +10,7 @@ import { VectorPlaneApiClient } from "../core/api.js";
 import { collectWorkspaceContext } from "../core/workspace.js";
 import { getBoundWorkspace } from "../core/workspace-binding.js";
 import { ValidationError } from "../core/errors.js";
-import { ensureAgentSetupCurrent } from "../core/agent-setup.js";
+import { ensureRuntimeAgentSetup } from "../core/runtime-agent-setup.js";
 export async function runSyncCommand(cliVersion, args) {
     const parsed = parseArgs(args);
     const force = getBooleanOption(parsed, "force");
@@ -40,12 +40,11 @@ export async function runSyncCommand(cliVersion, args) {
     if (!workspaceSlug) {
         throw new ValidationError("Nenhum workspace ativo foi resolvido. Use `vp workspace use <workspace>` ou `vp login`.");
     }
-    await ensureAgentSetupCurrent({
+    await ensureRuntimeAgentSetup({
         rootPath: workspaceRoot,
         workspace: workspaceSlug,
-        repoUrl: git.remoteOrigin,
-        source: git.remoteOrigin ? "api-resolve" : "manual",
-        accessToken: freshSession.accessToken,
+        git,
+        session: freshSession,
         apiClient,
         logger: runtime.logger,
     });

package/dist/commands/task.d.ts

@@ -0,0 +1 @@
+export declare function runTaskCommand(cliVersion: string, args: string[]): Promise<number>;