@nurix/nustack 0.10.0-dev.12 → 0.10.0-dev.14

package/dist/commands/{workspace.js → project.js}

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import * as p from "@clack/prompts";
-import { createWorkspaceViaAsk, getWorkspace, listWorkspaces, listOrganizations, publishWorkspace, resolveNuStackUrl, unpublishWorkspace, } from "../lib/nustack_client.js";
+import { createProjectViaAsk, getProject, listProjects, listOrganizations, publishProject, resolveNuStackUrl, unpublishProject, } from "../lib/nustack_client.js";
 import { ensureAccessToken } from "../lib/auth_grant.js";
 import { ensureAuthWithRecovery, lastAuthFailure } from "../lib/auth_recovery.js";
-import { resolveWorkspaceId, resolveOrganizationId } from "../lib/workspace_context.js";
+import { resolveProjectId, resolveOrganizationId } from "../lib/project_context.js";
 import { readActiveOrganizationContext } from "./organization.js";
 import { confirmOrFallback, isInteractive } from "../lib/interactive.js";
 import { launchBrowser } from "../lib/browser_opener.js";
@@ -13,7 +13,7 @@ import { openLocalStore } from "../lib/local_store/database.js";
 import { readDeviceState } from "../lib/local_store/device_state.js";
 import { getBindingByRepositoryRoot, listBindings } from "../lib/local_store/bindings.js";
 import { resolveRepository } from "../lib/git-sync/core/repository.js";
-import { readWorkspaceManifests } from "../lib/onboarding/manifest_writer.js";
+import { readProjectManifests } from "../lib/onboarding/manifest_writer.js";
 import { hasManifest, scaffoldManifest } from "../lib/manifest.js";
 import { toolkitCompatibility } from "../lib/etna/reconcile.js";
 import { attachExistingGit } from "../lib/onboarding/attach_existing_git.js";
@@ -37,96 +37,96 @@ async function requireAuth(command, json, globals) {
     }
     return { baseUrl, accessToken: deviceAuth.accessToken };
 }
-async function resolveOrganizationForWorkspace(auth, options) {
+async function resolveOrganizationForProject(auth, options) {
     const memberships = await listOrganizations(auth.baseUrl, auth.accessToken);
     const views = memberships.map((m) => ({ id: m.organization.id, slug: m.organization.slug }));
     const active = await readActiveOrganizationContext();
     const resolution = resolveOrganizationId({ organization: options.organization }, active, views);
     return resolution.ok ? { ok: true, organizationId: resolution.organizationId } : { ok: false, message: resolution.message };
 }
-export async function runWorkspaceList(options, globals) {
+export async function runProjectList(options, globals) {
     const json = options.json === true;
-    const auth = await requireAuth("workspace list", json, globals);
+    const auth = await requireAuth("project list", json, globals);
     if (!auth)
         return;
-    const ws = await resolveOrganizationForWorkspace(auth, options);
+    const ws = await resolveOrganizationForProject(auth, options);
     if (!ws.ok) {
-        emitFail("workspace list", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+        emitFail("project list", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
         return;
     }
-    const workspaces = await listWorkspaces(auth.baseUrl, auth.accessToken, ws.organizationId);
+    const projects = await listProjects(auth.baseUrl, auth.accessToken, ws.organizationId);
     if (json) {
-        printJsonSuccess("workspace list", { organizationId: ws.organizationId, workspaces });
+        printJsonSuccess("project list", { organizationId: ws.organizationId, projects });
         return;
     }
-    if (workspaces.length === 0) {
-        console.log("No Workspaces in this Organization. Create one with `nustack workspace create`.");
+    if (projects.length === 0) {
+        console.log("No Projects in this Organization. Create one with `nustack project create`.");
         return;
     }
-    for (const workspace of workspaces) {
-        console.log(`${workspace.id.padEnd(24)} ${workspace.status.padEnd(12)} ${workspace.publicationState.padEnd(12)} ${workspace.label}`);
+    for (const project of projects) {
+        console.log(`${project.id.padEnd(24)} ${project.status.padEnd(12)} ${project.publicationState.padEnd(12)} ${project.label}`);
     }
 }
-export async function runWorkspaceCreate(options, globals) {
+export async function runProjectCreate(options, globals) {
     const json = options.json === true;
-    const auth = await requireAuth("workspace create", json, globals);
+    const auth = await requireAuth("project create", json, globals);
     if (!auth)
         return;
-    const ws = await resolveOrganizationForWorkspace(auth, options);
+    const ws = await resolveOrganizationForProject(auth, options);
     if (!ws.ok) {
-        emitFail("workspace create", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+        emitFail("project create", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
         return;
     }
     const gathered = await gatherCreatePrompt(options, json);
     if (!gathered.ok) {
-        emitFail("workspace create", json, "VALIDATION_FAILED", gathered.message);
+        emitFail("project create", json, "VALIDATION_FAILED", gathered.message);
         return;
     }
-    const workspace = await createWorkspaceFromPrompt(auth, ws.organizationId, gathered.prompt, "workspace create", json);
-    if (!workspace)
+    const project = await createProjectFromPrompt(auth, ws.organizationId, gathered.prompt, "project create", json);
+    if (!project)
         return;
     if (json) {
-        printJsonSuccess("workspace create", { workspace, organizationId: ws.organizationId });
+        printJsonSuccess("project create", { project, organizationId: ws.organizationId });
         return;
     }
-    console.log(`Created Workspace ${workspace.label} (${workspace.id}), status ${workspace.status}.`);
-    console.log(`Attach a local folder with \`nustack workspace attach --workspace ${workspace.id}\`.`);
-    if (isInteractive() && (await confirmOrFallback("Attach the current folder to this Workspace now?", false))) {
+    console.log(`Created Project ${project.label} (${project.id}), status ${project.status}.`);
+    console.log(`Attach a local folder with \`nustack project attach --project ${project.id}\`.`);
+    if (isInteractive() && (await confirmOrFallback("Attach the current folder to this Project now?", false))) {
         const store = await openLocalStore();
         try {
             const ctx = buildOnboardingContext(auth, store, json, options.yes === true);
             const outcome = await webFirstAttach(ctx, {
-                workspaceId: workspace.id,
+                projectId: project.id,
                 organizationId: ws.organizationId,
                 confirmPopulated: options.yes === true,
             });
-            reportWebFirst("workspace create", outcome, json);
+            reportWebFirst("project create", outcome, json);
         }
         finally {
             store.close();
         }
     }
 }
-export async function runWorkspaceAttach(options, globals) {
+export async function runProjectAttach(options, globals) {
     const json = options.json === true;
-    const auth = await requireAuth("workspace attach", json, globals);
+    const auth = await requireAuth("project attach", json, globals);
     if (!auth)
         return;
     const store = await openLocalStore();
     try {
         const ctx = buildOnboardingContext(auth, store, json, options.yes === true);
-        if (options.workspace) {
-            const ws = await resolveOrganizationForWorkspace(auth, options);
+        if (options.project) {
+            const ws = await resolveOrganizationForProject(auth, options);
             if (!ws.ok) {
-                emitFail("workspace attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+                emitFail("project attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
                 return;
             }
             const outcome = await webFirstAttach(ctx, {
-                workspaceId: options.workspace,
+                projectId: options.project,
                 organizationId: ws.organizationId,
                 confirmPopulated: options.yes === true,
             });
-            reportWebFirst("workspace attach", outcome, json);
+            reportWebFirst("project attach", outcome, json);
             return;
         }
         let root;
@@ -134,31 +134,31 @@ export async function runWorkspaceAttach(options, globals) {
             root = resolveRepository(ctx.cwd).repositoryRoot;
         }
         catch {
-            emitFail("workspace attach", json, "NOT_A_WORKTREE", "`nustack workspace attach` needs a Git worktree — run `nustack init` to establish one, or pass `--workspace <id>` for a web-created Workspace.");
+            emitFail("project attach", json, "NOT_A_WORKTREE", "`nustack project attach` needs a Git worktree — run `nustack init` to establish one, or pass `--project <id>` for a web-created Project.");
             return;
         }
-        const resolved = await resolveOrCreateWorkspaceForAttach(auth, options, root, json);
+        const resolved = await resolveOrCreateProjectForAttach(auth, options, root, json);
         if (!resolved.ok)
             return;
         if (!hasManifest(root))
             await scaffoldManifest(root, deriveSlug(path.basename(root)));
         const outcome = await attachExistingGit(ctx, {
-            workspaceId: resolved.workspaceId,
+            projectId: resolved.projectId,
             organizationId: resolved.organizationId,
             confirmRebind: options.yes === true,
         });
-        reportAttach("workspace attach", outcome, json);
+        reportAttach("project attach", outcome, json);
     }
     finally {
         store.close();
     }
 }
-export async function runWorkspaceStatus(options, globals) {
+export async function runProjectStatus(options, globals) {
     const json = options.json === true;
     const cwd = process.cwd();
-    const workspace = await resolveWorkspaceId(cwd, { workspace: options.workspace });
-    if (!workspace.ok) {
-        emitFail("workspace status", json, "WORKSPACE_CONTEXT_MISSING", workspace.message);
+    const project = await resolveProjectId(cwd, { project: options.project });
+    if (!project.ok) {
+        emitFail("project status", json, "PROJECT_CONTEXT_MISSING", project.message);
         return;
     }
     const baseUrl = resolveNuStackUrl(globals);
@@ -166,44 +166,44 @@ export async function runWorkspaceStatus(options, globals) {
     const store = await openLocalStore();
     let binding = null;
     try {
-        binding = findBindingForWorkspace(store, workspace.workspaceId, cwd);
+        binding = findBindingForProject(store, project.projectId, cwd);
     }
     finally {
         store.close();
     }
-    let cloudWorkspace = null;
+    let cloudProject = null;
     let cloud = null;
     if (auth) {
         try {
-            cloudWorkspace = await getWorkspace(baseUrl, auth.accessToken, workspace.workspaceId);
-            if (cloudWorkspace.toolkit && cloudWorkspace.toolkit.version && cloudWorkspace.toolkit.rendererVersion && cloudWorkspace.toolkit.placementMapVersion) {
+            cloudProject = await getProject(baseUrl, auth.accessToken, project.projectId);
+            if (cloudProject.toolkit && cloudProject.toolkit.version && cloudProject.toolkit.rendererVersion && cloudProject.toolkit.placementMapVersion) {
                 cloud = {
-                    name: cloudWorkspace.toolkit.name,
-                    version: cloudWorkspace.toolkit.version,
-                    rendererVersion: cloudWorkspace.toolkit.rendererVersion,
-                    placementMapVersion: cloudWorkspace.toolkit.placementMapVersion,
+                    name: cloudProject.toolkit.name,
+                    version: cloudProject.toolkit.version,
+                    rendererVersion: cloudProject.toolkit.rendererVersion,
+                    placementMapVersion: cloudProject.toolkit.placementMapVersion,
                     catalogVersionId: null,
                 };
             }
         }
         catch {
-            cloudWorkspace = null;
+            cloudProject = null;
         }
     }
     const compatibility = toolkitCompatibility(binding ?? { etnaProfileJson: null }, cloud);
     if (json) {
-        printJsonSuccess("workspace status", {
-            workspaceId: workspace.workspaceId,
-            cloudReachable: cloudWorkspace !== null,
-            cloud: cloudWorkspace
-                ? { label: cloudWorkspace.label, status: cloudWorkspace.status, publicationState: cloudWorkspace.publicationState, initStatus: cloudWorkspace.initStatus }
+        printJsonSuccess("project status", {
+            projectId: project.projectId,
+            cloudReachable: cloudProject !== null,
+            cloud: cloudProject
+                ? { label: cloudProject.label, status: cloudProject.status, publicationState: cloudProject.publicationState, initStatus: cloudProject.initStatus }
                 : null,
             binding: binding
                 ? {
                     id: binding.id,
                     boundBranch: binding.boundBranch,
                     lastProcessedCommitId: binding.lastProcessedCommitId,
-                    lastAppliedWorkspaceSequence: binding.lastAppliedWorkspaceSequence,
+                    lastAppliedProjectSequence: binding.lastAppliedProjectSequence,
                     status: binding.status,
                 }
                 : null,
@@ -211,71 +211,71 @@ export async function runWorkspaceStatus(options, globals) {
         });
         return;
     }
-    console.log(`Workspace ${workspace.workspaceId}`);
-    console.log(`  cloud:    ${cloudWorkspace ? `${cloudWorkspace.label} — ${cloudWorkspace.status} / ${cloudWorkspace.publicationState}` : "(unreachable — local-only view)"}`);
+    console.log(`Project ${project.projectId}`);
+    console.log(`  cloud:    ${cloudProject ? `${cloudProject.label} — ${cloudProject.status} / ${cloudProject.publicationState}` : "(unreachable — local-only view)"}`);
     if (binding) {
         console.log(`  binding:  ${binding.id} on ${binding.boundBranch} (${binding.status})`);
-        console.log(`  cursor:   processed=${binding.lastProcessedCommitId?.slice(0, 12) ?? "—"}  applied@${binding.lastAppliedWorkspaceSequence}`);
+        console.log(`  cursor:   processed=${binding.lastProcessedCommitId?.slice(0, 12) ?? "—"}  applied@${binding.lastAppliedProjectSequence}`);
     }
     else {
         console.log("  binding:  (this folder is not bound on this device)");
     }
     console.log(`  toolkit:  ${compatibility.blocksWrites ? `BLOCKED — ${compatibility.reason}` : "clear (projection and sync writes allowed)"}`);
 }
-export async function runWorkspaceOpen(options, globals) {
+export async function runProjectOpen(options, globals) {
     const json = options.json === true;
-    const workspace = await resolveWorkspaceId(process.cwd(), { workspace: options.workspace });
-    if (!workspace.ok) {
-        emitFail("workspace open", json, "WORKSPACE_CONTEXT_MISSING", workspace.message);
+    const project = await resolveProjectId(process.cwd(), { project: options.project });
+    if (!project.ok) {
+        emitFail("project open", json, "PROJECT_CONTEXT_MISSING", project.message);
         return;
     }
     const baseUrl = resolveNuStackUrl(globals);
     let url;
     try {
-        url = assertSafeBrowserUrl(`${baseUrl}/workspaces/${encodeURIComponent(workspace.workspaceId)}`);
+        url = assertSafeBrowserUrl(`${baseUrl}/projects/${encodeURIComponent(project.projectId)}`);
     }
     catch (error) {
-        emitFail("workspace open", json, "UNSAFE_URL", error instanceof Error ? error.message : String(error));
+        emitFail("project open", json, "UNSAFE_URL", error instanceof Error ? error.message : String(error));
         return;
     }
     if (json) {
-        printJsonSuccess("workspace open", { workspaceId: workspace.workspaceId, url });
+        printJsonSuccess("project open", { projectId: project.projectId, url });
         return;
     }
     launchBrowser(url);
     console.log(`Opening ${url}`);
 }
-export async function runWorkspacePublish(options, globals) {
-    return runPublication("publish", "workspace publish", options, globals);
+export async function runProjectPublish(options, globals) {
+    return runPublication("publish", "project publish", options, globals);
 }
-export async function runWorkspaceUnpublish(options, globals) {
-    return runPublication("unpublish", "workspace unpublish", options, globals);
+export async function runProjectUnpublish(options, globals) {
+    return runPublication("unpublish", "project unpublish", options, globals);
 }
 async function runPublication(action, command, options, globals) {
     const json = options.json === true;
     const auth = await requireAuth(command, json, globals);
     if (!auth)
         return;
-    const workspace = await resolveWorkspaceId(process.cwd(), { workspace: options.workspace });
-    if (!workspace.ok) {
-        emitFail(command, json, "WORKSPACE_CONTEXT_MISSING", workspace.message);
+    const project = await resolveProjectId(process.cwd(), { project: options.project });
+    if (!project.ok) {
+        emitFail(command, json, "PROJECT_CONTEXT_MISSING", project.message);
         return;
     }
     try {
         if (action === "publish")
-            await publishWorkspace(auth.baseUrl, auth.accessToken, workspace.workspaceId, {}, randomUUID());
+            await publishProject(auth.baseUrl, auth.accessToken, project.projectId, {}, randomUUID());
         else
-            await unpublishWorkspace(auth.baseUrl, auth.accessToken, workspace.workspaceId, randomUUID());
+            await unpublishProject(auth.baseUrl, auth.accessToken, project.projectId, randomUUID());
     }
     catch (error) {
         emitFail(command, json, action === "publish" ? "PUBLISH_FAILED" : "UNPUBLISH_FAILED", error instanceof Error ? error.message : String(error));
         return;
     }
     if (json) {
-        printJsonSuccess(command, { workspaceId: workspace.workspaceId, publicationState: action === "publish" ? "public" : "private" });
+        printJsonSuccess(command, { projectId: project.projectId, publicationState: action === "publish" ? "public" : "private" });
         return;
     }
-    console.log(action === "publish" ? `Published Workspace ${workspace.workspaceId}.` : `Unpublished Workspace ${workspace.workspaceId}.`);
+    console.log(action === "publish" ? `Published Project ${project.projectId}.` : `Unpublished Project ${project.projectId}.`);
 }
 function buildOnboardingContext(auth, store, json, yes) {
     const deviceState = readDeviceState(store);
@@ -297,61 +297,61 @@ async function gatherCreatePrompt(options, json) {
         return { ok: true, prompt: flagPrompt };
     const name = options.name?.trim();
     if (name)
-        return { ok: true, prompt: `Create a workspace named "${name}".` };
+        return { ok: true, prompt: `Create a project named "${name}".` };
     if (json || !isInteractive()) {
         return { ok: false, message: "A prompt is required — pass `--prompt <text>` (or `--name <name>`)." };
     }
-    const answer = await p.text({ message: "What should this workspace be?" });
+    const answer = await p.text({ message: "What should this project be?" });
     if (p.isCancel(answer) || !String(answer).trim())
         return { ok: false, message: "A prompt is required." };
     return { ok: true, prompt: String(answer).trim() };
 }
-async function createWorkspaceFromPrompt(auth, organizationId, prompt, command, json) {
+async function createProjectFromPrompt(auth, organizationId, prompt, command, json) {
     let outcome;
     try {
-        outcome = await createWorkspaceViaAsk(auth.baseUrl, auth.accessToken, organizationId, prompt, {
+        outcome = await createProjectViaAsk(auth.baseUrl, auth.accessToken, organizationId, prompt, {
             onPhase: json ? undefined : (message) => p.log.info(message),
         });
     }
     catch (error) {
-        emitFail(command, json, "WORKSPACE_CREATE_FAILED", error instanceof Error ? error.message : String(error));
+        emitFail(command, json, "PROJECT_CREATE_FAILED", error instanceof Error ? error.message : String(error));
         return null;
     }
     if (outcome.generationError && !json) {
         p.log.warn(`The first document did not finish: ${outcome.generationError}`);
     }
-    return getWorkspace(auth.baseUrl, auth.accessToken, outcome.workspaceId);
+    return getProject(auth.baseUrl, auth.accessToken, outcome.projectId);
 }
-async function resolveOrCreateWorkspaceForAttach(auth, options, root, json) {
-    const marker = await resolveWorkspaceId(root, {});
+async function resolveOrCreateProjectForAttach(auth, options, root, json) {
+    const marker = await resolveProjectId(root, {});
     if (marker.ok) {
-        const manifests = await readWorkspaceManifests(root);
-        const markerOrganization = manifests.workspaceManifest?.organizationId ?? manifests.serviceWorkspaceBinding?.organizationId ?? null;
+        const manifests = await readProjectManifests(root);
+        const markerOrganization = manifests.projectManifest?.organizationId ?? manifests.serviceProjectBinding?.organizationId ?? null;
         if (markerOrganization)
-            return { ok: true, workspaceId: marker.workspaceId, organizationId: markerOrganization };
-        const ws = await resolveOrganizationForWorkspace(auth, options);
+            return { ok: true, projectId: marker.projectId, organizationId: markerOrganization };
+        const ws = await resolveOrganizationForProject(auth, options);
         if (!ws.ok) {
-            emitFail("workspace attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+            emitFail("project attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
             return { ok: false };
         }
-        return { ok: true, workspaceId: marker.workspaceId, organizationId: ws.organizationId };
+        return { ok: true, projectId: marker.projectId, organizationId: ws.organizationId };
     }
-    const ws = await resolveOrganizationForWorkspace(auth, options);
+    const ws = await resolveOrganizationForProject(auth, options);
     if (!ws.ok) {
-        emitFail("workspace attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+        emitFail("project attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
         return { ok: false };
     }
     const gathered = await gatherCreatePrompt(options, json);
     if (!gathered.ok) {
-        emitFail("workspace attach", json, "WORKSPACE_CONTEXT_MISSING", `No Workspace to attach — ${gathered.message} Or pass \`--workspace <id>\` for a web-created Workspace.`);
+        emitFail("project attach", json, "PROJECT_CONTEXT_MISSING", `No Project to attach — ${gathered.message} Or pass \`--project <id>\` for a web-created Project.`);
         return { ok: false };
     }
-    const workspace = await createWorkspaceFromPrompt(auth, ws.organizationId, gathered.prompt, "workspace attach", json);
-    if (!workspace)
+    const project = await createProjectFromPrompt(auth, ws.organizationId, gathered.prompt, "project attach", json);
+    if (!project)
         return { ok: false };
-    return { ok: true, workspaceId: workspace.id, organizationId: ws.organizationId };
+    return { ok: true, projectId: project.id, organizationId: ws.organizationId };
 }
-function findBindingForWorkspace(store, workspaceId, cwd) {
+function findBindingForProject(store, projectId, cwd) {
     try {
         const byRoot = getBindingByRepositoryRoot(store, resolveRepository(cwd).repositoryRoot);
         if (byRoot)
@@ -359,15 +359,15 @@ function findBindingForWorkspace(store, workspaceId, cwd) {
     }
     catch {
     }
-    return listBindings(store).find((binding) => binding.workspaceId === workspaceId) ?? null;
+    return listBindings(store).find((binding) => binding.projectId === projectId) ?? null;
 }
 function deriveSlug(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
 }
 function toResultJson(result) {
     return {
         flow: result.flow,
-        workspaceId: result.workspaceId,
+        projectId: result.projectId,
         organizationId: result.organizationId,
         bindingId: result.bindingId,
         boundBranch: result.boundBranch,
@@ -379,7 +379,7 @@ function toResultJson(result) {
     };
 }
 function printOnboardingHuman(result) {
-    console.log(`Bound Workspace ${result.workspaceId} on branch ${result.boundBranch} (binding ${result.bindingId})${result.reused ? " [reused]" : ""}.`);
+    console.log(`Bound Project ${result.projectId} on branch ${result.boundBranch} (binding ${result.bindingId})${result.reused ? " [reused]" : ""}.`);
     const installNote = result.install.skipped
         ? result.install.reason ?? "no install"
         : result.install.installed
@@ -407,7 +407,7 @@ function reportWebFirst(command, outcome, json) {
     }
     printOnboardingHuman(result);
     if (result.overwriteRequired) {
-        console.log(`Divergent target(s) — nothing was changed. Review, then run \`nustack workspace sync approve ${result.handoffId ?? ""}\`:`);
+        console.log(`Divergent target(s) — nothing was changed. Review, then run \`nustack project sync approve ${result.handoffId ?? ""}\`:`);
         for (const entry of result.divergent)
             console.log(`  ${entry.path} (${entry.divergence})`);
     }
@@ -426,54 +426,54 @@ function reportAttach(command, outcome, json) {
     }
     printOnboardingHuman(outcome.result);
 }
-export function registerWorkspaceCommands(workspaceCommand, getGlobalOptions) {
-    workspaceCommand
+export function registerProjectCommands(projectCommand, getGlobalOptions) {
+    projectCommand
         .command("list")
-        .description("List the Workspaces in the active (or --organization) Organization")
+        .description("List the Projects in the active (or --organization) Organization")
         .option("--organization <id>", "the Organization to list (defaults to the active Organization)")
         .option("--json", "emit the versioned machine envelope")
-        .action(async (options) => runWorkspaceList(options, getGlobalOptions()));
-    workspaceCommand
+        .action(async (options) => runProjectList(options, getGlobalOptions()));
+    projectCommand
         .command("create")
-        .description("Create a Workspace from a prompt, then optionally attach the current folder")
+        .description("Create a Project from a prompt, then optionally attach the current folder")
         .option("--organization <id>", "the owning Organization (defaults to the active Organization)")
-        .option("--prompt <text>", "what the Workspace should be — the first prompt creates it")
+        .option("--prompt <text>", "what the Project should be — the first prompt creates it")
         .option("--name <name>", "shorthand: builds the create prompt from a name")
         .option("--yes", "assume yes for onboarding confirmations")
         .option("--json", "emit the versioned machine envelope")
-        .action(async (options) => runWorkspaceCreate(options, getGlobalOptions()));
-    workspaceCommand
+        .action(async (options) => runProjectCreate(options, getGlobalOptions()));
+    projectCommand
         .command("attach")
-        .description("Bind the current folder to a Workspace (existing-Git flow, or --workspace for a web-created Workspace)")
-        .option("--workspace <id>", "attach to this web-created Workspace (web-first flow)")
+        .description("Bind the current folder to a Project (existing-Git flow, or --project for a web-created Project)")
+        .option("--project <id>", "attach to this web-created Project (web-first flow)")
         .option("--organization <id>", "the owning Organization (defaults to the active Organization)")
-        .option("--prompt <text>", "the create prompt when creating a Workspace for this worktree")
+        .option("--prompt <text>", "the create prompt when creating a Project for this worktree")
         .option("--name <name>", "shorthand: builds the create prompt from a name")
         .option("--yes", "confirm populated-folder onboarding and rebind")
         .option("--json", "emit the versioned machine envelope")
-        .action(async (options) => runWorkspaceAttach(options, getGlobalOptions()));
-    workspaceCommand
+        .action(async (options) => runProjectAttach(options, getGlobalOptions()));
+    projectCommand
         .command("status")
-        .description("Show the cloud Workspace summary merged with the local binding (degraded offline)")
-        .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+        .description("Show the cloud Project summary merged with the local binding (degraded offline)")
+        .option("--project <id>", "the Project to act as (defaults to the bound repository)")
         .option("--json", "emit the versioned machine envelope")
-        .action(async (options) => runWorkspaceStatus(options, getGlobalOptions()));
-    workspaceCommand
+        .action(async (options) => runProjectStatus(options, getGlobalOptions()));
+    projectCommand
         .command("open")
-        .description("Open the Workspace in the browser (--json prints the URL instead of launching)")
-        .option("--workspace <id>", "the Workspace to open (defaults to the bound repository)")
+        .description("Open the Project in the browser (--json prints the URL instead of launching)")
+        .option("--project <id>", "the Project to open (defaults to the bound repository)")
         .option("--json", "print the resolved URL as the machine envelope instead of launching")
-        .action(async (options) => runWorkspaceOpen(options, getGlobalOptions()));
-    workspaceCommand
+        .action(async (options) => runProjectOpen(options, getGlobalOptions()));
+    projectCommand
         .command("publish")
-        .description("Publish the Workspace (role-gated)")
-        .option("--workspace <id>", "the Workspace to publish (defaults to the bound repository)")
+        .description("Publish the Project (role-gated)")
+        .option("--project <id>", "the Project to publish (defaults to the bound repository)")
         .option("--json", "emit the versioned machine envelope")
-        .action(async (options) => runWorkspacePublish(options, getGlobalOptions()));
-    workspaceCommand
+        .action(async (options) => runProjectPublish(options, getGlobalOptions()));
+    projectCommand
         .command("unpublish")
-        .description("Return the Workspace to private (role-gated)")
-        .option("--workspace <id>", "the Workspace to unpublish (defaults to the bound repository)")
+        .description("Return the Project to private (role-gated)")
+        .option("--project <id>", "the Project to unpublish (defaults to the bound repository)")
         .option("--json", "emit the versioned machine envelope")
-        .action(async (options) => runWorkspaceUnpublish(options, getGlobalOptions()));
+        .action(async (options) => runProjectUnpublish(options, getGlobalOptions()));
 }

package/dist/commands/review.js

@@ -117,13 +117,13 @@ export async function runReviewMirror(options, globals) {
             const answered = await client.answerReviewItem(id, verdict);
             return mirrorReport(json, "answered", answered.id);
         }
-        const workspaceId = options.workspace?.trim() ?? "";
-        if (!workspaceId)
-            return mirrorReport(json, "skipped", null, "--workspace is required to open a mirrored prompt");
+        const projectId = options.project?.trim() ?? "";
+        if (!projectId)
+            return mirrorReport(json, "skipped", null, "--project is required to open a mirrored prompt");
         const subject = readSubject(options.subject);
         if (!subject)
             return mirrorReport(json, "skipped", null, "--subject must be a tool-permission JSON object");
-        const created = await client.createReviewItem({ workspaceId, sessionId, subject });
+        const created = await client.createReviewItem({ projectId, sessionId, subject });
         return mirrorReport(json, "open", created.id);
     }
     catch (error) {
@@ -142,7 +142,7 @@ export function registerReviewCommands(reviewCommand, getGlobalOptions) {
         .command("mirror")
         .description("Reflect a lane's permission prompt, or its answer, into the Review pane")
         .option("--session <laneId>", "the lane's session id")
-        .option("--workspace <id>", "the Workspace the lane's folder is bound to (required with --state open)")
+        .option("--project <id>", "the Project the lane's folder is bound to (required with --state open)")
         .option("--state <state>", "open or answered")
         .option("--subject <json>", "the tool-permission subject, as JSON (required with --state open)")
         .option("--verdict <verdict>", "allow or deny (required with --state answered)")

package/dist/commands/search.js

@@ -1,4 +1,4 @@
-import { resolveNuStackUrl, searchWorkspaces, searchCatalogue, } from "../lib/nustack_client.js";
+import { resolveNuStackUrl, searchProjects, searchCatalogue, } from "../lib/nustack_client.js";
 export async function runSearch(keywords, options, globals) {
     const query = keywords.join(" ").trim();
     if (!query) {
@@ -12,20 +12,20 @@ export async function runSearch(keywords, options, globals) {
         return;
     }
     const baseUrl = resolveNuStackUrl(globals);
-    const results = await searchWorkspaces(baseUrl, query, { category: options.category, limit: options.limit });
+    const results = await searchProjects(baseUrl, query, { category: options.category, limit: options.limit });
     if (options.json) {
         console.log(JSON.stringify(results, null, 2));
         return;
     }
     if (results.length === 0) {
-        console.log(`No workspaces matched "${query}". Looking for a platform capability? Try \`nustack search services ${query}\`.`);
+        console.log(`No projects matched "${query}". Looking for a platform capability? Try \`nustack search services ${query}\`.`);
         return;
     }
     console.log(`${results.length} result${results.length === 1 ? "" : "s"} for "${query}"`);
-    for (const workspace of results) {
-        const category = workspace.categories[0] ?? "—";
-        console.log(`${workspace.displayName.padEnd(28)} ${category.padEnd(16)} ${workspace.tagline ?? ""}`);
-        const link = workspace.links[0];
+    for (const project of results) {
+        const category = project.categories[0] ?? "—";
+        console.log(`${project.displayName.padEnd(28)} ${category.padEnd(16)} ${project.tagline ?? ""}`);
+        const link = project.links[0];
         if (link)
             console.log(`  ${link.url}`);
     }

package/dist/commands/sessions.js

@@ -25,7 +25,7 @@ function readTranscripts(value) {
             sessionKey,
             provider,
             modifiedMs,
-            workspaceId: typeof row.workspaceId === "string" && row.workspaceId ? row.workspaceId : null,
+            projectId: typeof row.projectId === "string" && row.projectId ? row.projectId : null,
             vendorSessionId: typeof row.id === "string" && row.id ? row.id : null,
             ...(typeof row.sizeBytes === "number" ? { sizeBytes: row.sizeBytes } : {}),
         });