@vectorplane/ctrl-cli 0.1.10 → 0.1.12

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

@@ -0,0 +1,20 @@
+import type { VectorPlaneApiClient } from "./api.js";
+import type { Logger } from "./logger.js";
+import { type DetectionConfidence, type SupportedAgent } from "./agent-runtime-detection.js";
+export declare function ensureAgentSetupCurrent(params: {
+    rootPath: string;
+    workspace: string;
+    repoUrl: string | null;
+    source: "manual" | "api-resolve" | "session";
+    accessToken: string;
+    apiClient: VectorPlaneApiClient;
+    logger: Logger;
+    explicitAgent?: SupportedAgent;
+    force?: boolean;
+}): Promise<{
+    agent: SupportedAgent;
+    templatePath: string;
+    fileStatus: "created" | "updated" | "unchanged";
+    changed: boolean;
+    confidence: DetectionConfidence;
+}>;

package/dist/core/agent-setup.js

@@ -0,0 +1,119 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+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",
+    windsurf: ".windsurfrules",
+    copilot: ".github/copilot-instructions.md",
+    codex: "AGENTS.md",
+    generic: "AGENTS.md",
+};
+async function pathExists(filePath) {
+    try {
+        await access(filePath, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function appendGitIgnoreEntry(rootPath, relativeTarget) {
+    const gitIgnorePath = path.join(rootPath, ".gitignore");
+    const normalizedEntry = relativeTarget.replace(/\\/g, "/");
+    const current = await readFile(gitIgnorePath, "utf8").catch(() => "");
+    const lines = current.split(/\r?\n/).map((line) => line.trim());
+    if (lines.includes(normalizedEntry)) {
+        return;
+    }
+    const next = current.trimEnd();
+    const updated = `${next}${next ? "\n" : ""}${normalizedEntry}\n`;
+    await writeFile(gitIgnorePath, updated, "utf8");
+}
+async function writeTemplateFile(rootPath, relativeTarget, content, force) {
+    const absoluteTarget = path.join(rootPath, relativeTarget);
+    await mkdir(path.dirname(absoluteTarget), { recursive: true });
+    if (await pathExists(absoluteTarget)) {
+        const current = await readFile(absoluteTarget, "utf8");
+        if (current === content) {
+            return "unchanged";
+        }
+        if (!force) {
+            throw new ValidationError(`O arquivo ${relativeTarget} já existe. Use --force para sobrescrever.`);
+        }
+        await writeFile(absoluteTarget, content, "utf8");
+        return "updated";
+    }
+    await writeFile(absoluteTarget, content, "utf8");
+    return "created";
+}
+function getAgentTemplate(setup, agent) {
+    const template = setup.agents[agent];
+    if (!template) {
+        throw new ValidationError(`O backend não retornou template para o agente ${agent}.`);
+    }
+    return template;
+}
+export async function ensureAgentSetupCurrent(params) {
+    const binding = await getWorkspaceBinding(params.rootPath);
+    let selection;
+    if (!params.explicitAgent && binding?.configuredAgent) {
+        const detection = await detectAgentRuntime(params.rootPath);
+        if (!detection.selected && detection.confidence === "low") {
+            selection = {
+                agent: binding.configuredAgent,
+                detection: {
+                    selected: binding.configuredAgent,
+                    confidence: "low",
+                    reasons: ["binding-fallback"],
+                    candidates: [binding.configuredAgent],
+                },
+            };
+        }
+        else {
+            selection = await resolveAgentSelection(params.rootPath, params.explicitAgent);
+        }
+    }
+    else {
+        selection = await resolveAgentSelection(params.rootPath, params.explicitAgent);
+    }
+    const { agent, detection } = selection;
+    const expectedPath = AGENT_TEMPLATE_PATHS[agent];
+    if (binding?.workspace === params.workspace && binding.configuredAgent === agent && binding.templatePath === expectedPath && await pathExists(path.join(params.rootPath, expectedPath))) {
+        return {
+            agent,
+            templatePath: expectedPath,
+            fileStatus: "unchanged",
+            changed: false,
+            confidence: detection.confidence,
+        };
+    }
+    const setup = await params.apiClient.getAgentSetup(params.accessToken, params.workspace);
+    const template = getAgentTemplate(setup, agent);
+    const fileStatus = await writeTemplateFile(params.rootPath, template.filename, template.content, params.force ?? false);
+    await appendGitIgnoreEntry(params.rootPath, template.filename);
+    await bindWorkspaceToRoot({
+        rootPath: params.rootPath,
+        workspace: params.workspace,
+        repoUrl: params.repoUrl,
+        source: params.source,
+        configuredAgent: agent,
+        agentConfidence: detection.confidence,
+        templatePath: template.filename,
+        agentConfiguredAt: new Date().toISOString(),
+    });
+    if (binding?.configuredAgent && binding.configuredAgent !== agent) {
+        params.logger.info(`agente ativo detectado mudou de ${binding.configuredAgent} para ${agent}; setup local atualizado.`);
+    }
+    return {
+        agent,
+        templatePath: template.filename,
+        fileStatus,
+        changed: true,
+        confidence: detection.confidence,
+    };
+}
+//# sourceMappingURL=agent-setup.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, ResolveWorkspaceRequest, ResolveWorkspaceResponse, SyncRequest, SyncResponse } 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, WorkspacePolicyRuleRecord, AgentRegistryRecord, TaskTemplateRecord } from "../types/api.js";
 export declare class VectorPlaneApiClient {
     private readonly apiBaseUrl;
     private readonly timeoutMs;
@@ -21,9 +21,99 @@ export declare class VectorPlaneApiClient {
     getWorkspaceContext(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
     getWorkspaceSnapshot(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
     getWorkspaceDeliveryContext(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
-    getAgentSetup(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>;
     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>;

package/dist/core/api.js

@@ -152,6 +152,26 @@ export class VectorPlaneApiClient {
             },
         }, this.timeoutMs, this.logger);
     }
+    async getWorkspaceDeliveryContextSemantic(accessToken, workspaceId, params) {
+        const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/delivery-context`);
+        url.searchParams.set("mode", "semantic");
+        url.searchParams.set("query", params.query);
+        if (params.type) {
+            url.searchParams.set("type", params.type);
+        }
+        if (params.authority) {
+            url.searchParams.set("authority", params.authority);
+        }
+        if (typeof params.limit === "number") {
+            url.searchParams.set("limit", String(params.limit));
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async getAgentSetup(accessToken, workspaceId) {
         return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/agent-setup`, {
             method: "GET",
@@ -160,6 +180,28 @@ export class VectorPlaneApiClient {
             },
         }, this.timeoutMs, this.logger);
     }
+    async listWorkspacePolicyRules(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/policy-rules`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createWorkspacePolicyRule(accessToken, workspaceRef, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/policy-rules`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async updateWorkspacePolicyRule(accessToken, workspaceRef, ruleId, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/policy-rules/${ruleId}`, {
+            method: "PUT",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
     async listMemoryDrafts(accessToken, workspaceRef, status) {
         const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/memory-drafts`);
         if (status) {
@@ -179,6 +221,159 @@ export class VectorPlaneApiClient {
             body: JSON.stringify(payload),
         }, this.timeoutMs, this.logger);
     }
+    async searchWorkspaceMemory(accessToken, workspaceRef, params) {
+        const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/memory/search`);
+        url.searchParams.set("q", params.query);
+        if (params.type) {
+            url.searchParams.set("type", params.type);
+        }
+        if (params.authority) {
+            url.searchParams.set("authority", params.authority);
+        }
+        if (typeof params.limit === "number") {
+            url.searchParams.set("limit", String(params.limit));
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async listTasks(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createTask(accessToken, workspaceRef, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async listTaskTemplates(accessToken) {
+        return requestJson(`${this.apiBaseUrl}/admin/task-templates`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getTask(accessToken, workspaceRef, taskId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async listClaimableTaskSteps(accessToken, workspaceRef, filters) {
+        const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/tasks/claimable`);
+        if (filters?.capability) {
+            url.searchParams.set("capability", filters.capability);
+        }
+        if (filters?.agentName) {
+            url.searchParams.set("agent_name", filters.agentName);
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async claimTaskStep(accessToken, workspaceRef, taskId, stepId, payload) {
+        return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/tasks/${taskId}/steps/${stepId}/claim`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload ?? {}),
+        }, this.timeoutMs, this.logger);
+    }
+    async delegateTask(accessToken, workspaceRef, taskId, stepId, toAgentId, reason) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/delegate`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify({ stepId, toAgentId, reason }),
+        }, this.timeoutMs, this.logger);
+    }
+    async callbackTaskStep(accessToken, workspaceRef, taskId, stepId, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/steps/${stepId}/callback`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async getTaskHandoff(accessToken, workspaceRef, taskId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/handoff`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getTaskObservability(accessToken, workspaceRef, taskId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/observability`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getWorkspaceTaskObservability(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/observability`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async approveTask(accessToken, workspaceRef, taskId, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/approve`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async listAgentRegistry(accessToken) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createRegistryAgent(accessToken, payload) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async updateRegistryAgent(accessToken, agentId, payload) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry/${agentId}`, {
+            method: "PUT",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async deactivateRegistryAgent(accessToken, agentId) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry/${agentId}/deactivate`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+        }, this.timeoutMs, this.logger);
+    }
+    async getWorkspaceHealth(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/health`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async checkInAgent(accessToken, payload) {
         return requestJson(`${this.apiBaseUrl}/cli/workspace/${payload.workspaceId}/agents/check-in`, {
             method: "POST",

package/dist/core/init-workspace.d.ts

@@ -0,0 +1,29 @@
+import type { SupportedAgent } from "./agent-runtime-detection.js";
+import type { CliConfig, CliProfileConfig } from "../types/config.js";
+import type { DeviceIdentity } from "../types/machine.js";
+import type { Logger } from "./logger.js";
+export declare function buildInitLoginArgs(params: {
+    manual: boolean;
+    noBrowser: boolean;
+    profile?: string;
+}): Promise<string[]>;
+export declare function runInitWorkspaceUseCase(params: {
+    cliVersion: string;
+    commandArgs: string[];
+    runtime: {
+        profile: CliProfileConfig;
+        config: CliConfig;
+        device: DeviceIdentity;
+        logger: Logger;
+    };
+    force: boolean;
+    explicitWorkspace?: string;
+    requestedAgent?: SupportedAgent;
+    ensureLoggedIn: () => Promise<void>;
+}): Promise<{
+    workspace: string;
+    agent: SupportedAgent;
+    confidence: string;
+    templatePath: string;
+    fileStatus: string;
+}>;