@vectorplane/ctrl-cli 0.1.11 → 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

@@ -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, 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>>;
+    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;
+}>;