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

package/dist/lib/onboarding/attach_existing_git.js

@@ -7,24 +7,24 @@ import { runRepositoryOnboarding, } from "./binding.js";
 export async function attachExistingGit(ctx, options) {
     const state = classifyFolder(ctx.cwd);
     if (state.class !== "git_worktree" || !state.repository || !state.git) {
-        return { ok: false, code: "NOT_A_WORKTREE", message: "`nustack workspace attach` needs an existing Git worktree — run `nustack init` to establish one." };
+        return { ok: false, code: "NOT_A_WORKTREE", message: "`nustack project attach` needs an existing Git worktree — run `nustack init` to establish one." };
     }
     const rejection = attachRejection(state.git);
     if (rejection) {
         return { ok: false, code: rejection.toUpperCase(), message: rejectionMessage(rejection) };
     }
-    if (state.git.markerWorkspaceId && state.git.markerWorkspaceId !== options.workspaceId && !options.confirmRebind) {
+    if (state.git.markerProjectId && state.git.markerProjectId !== options.projectId && !options.confirmRebind) {
         return {
             ok: false,
             code: "REBIND_CONFIRMATION_REQUIRED",
-            message: `This repository is bound to Workspace ${state.git.markerWorkspaceId}. Re-run with confirmation to rebind it to ${options.workspaceId}.`,
+            message: `This repository is bound to Project ${state.git.markerProjectId}. Re-run with confirmation to rebind it to ${options.projectId}.`,
         };
     }
     const boundBranch = readSymbolicBranch(state.repository);
     if (!boundBranch) {
         return { ok: false, code: "DETACHED_HEAD", message: "HEAD is detached — check out a branch before attaching." };
     }
-    const profile = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, options.workspaceId);
+    const profile = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, options.projectId);
     const baselineCommitId = readHeadCommit(state.repository);
     const result = await runRepositoryOnboarding({
         store: ctx.store,
@@ -32,7 +32,7 @@ export async function attachExistingGit(ctx, options) {
         accessToken: ctx.accessToken,
         deviceRef: ctx.deviceRef,
         flow: "existing_git",
-        workspaceId: options.workspaceId,
+        projectId: options.projectId,
         organizationId: options.organizationId,
         repository: state.repository,
         boundBranch,
@@ -55,8 +55,8 @@ async function reconcileLatest(ctx, bindingId) {
 }
 function rejectionMessage(rejection) {
     switch (rejection) {
-        case "nested_workspace":
-            return "This repository is nested inside another NuStack Workspace — one Workspace has one logical repository root (F-014).";
+        case "nested_project":
+            return "This repository is nested inside another NuStack Project — one Project has one logical repository root (F-014).";
         case "operation_in_progress":
             return "A merge, rebase, cherry-pick, or revert is in progress — finish or abort it, then re-attach.";
         case "detached_head":

package/dist/lib/onboarding/binding.js

@@ -3,21 +3,21 @@ import { createBinding } from "../nustack_client.js";
 import { getBindingById, getBindingByRepositoryRoot, insertBinding, updateBindingCursor, updateBindingStatus, } from "../local_store/bindings.js";
 import { ensureBindingTelemetry } from "../session_telemetry.js";
 import { readHeadCommit } from "../git-sync/core/repository.js";
-import { writeWorkspaceManifests } from "./manifest_writer.js";
+import { writeProjectManifests } from "./manifest_writer.js";
 import { installToolkit } from "../etna/manager.js";
 import { serializeProfileForBinding } from "../etna/profile.js";
 import { SYNC_PROTOCOL_VERSION } from "../git-sync/whitelist/types.js";
 export function computeRepositoryFingerprint(repository) {
     return createHash("sha256").update(repository.commonDir).digest("hex");
 }
-function bindingIdempotencyKey(workspaceId, deviceRef, fingerprint) {
-    return createHash("sha256").update(`binding:${workspaceId}:${deviceRef}:${fingerprint}`).digest("hex");
+function bindingIdempotencyKey(projectId, deviceRef, fingerprint) {
+    return createHash("sha256").update(`binding:${projectId}:${deviceRef}:${fingerprint}`).digest("hex");
 }
 export async function establishBinding(input) {
     const { store, repository } = input;
     const fingerprint = computeRepositoryFingerprint(repository);
     const existing = getBindingByRepositoryRoot(store, repository.repositoryRoot);
-    if (existing && existing.workspaceId === input.workspaceId) {
+    if (existing && existing.projectId === input.projectId) {
         if (input.baselineCommitId && existing.lastProcessedCommitId === null) {
             updateBindingCursor(store, existing.id, { lastProcessedCommitId: input.baselineCommitId });
         }
@@ -26,11 +26,11 @@ export async function establishBinding(input) {
         await maybeRunTelemetry(input, existing);
         return { binding: getBindingById(store, existing.id), created: false };
     }
-    const cloudBinding = await createBinding(input.baseUrl, input.accessToken, input.workspaceId, { repositoryFingerprint: fingerprint, boundBranch: input.boundBranch, protocolVersion: SYNC_PROTOCOL_VERSION }, bindingIdempotencyKey(input.workspaceId, input.deviceRef, fingerprint));
+    const cloudBinding = await createBinding(input.baseUrl, input.accessToken, input.projectId, { repositoryFingerprint: fingerprint, boundBranch: input.boundBranch, protocolVersion: SYNC_PROTOCOL_VERSION }, bindingIdempotencyKey(input.projectId, input.deviceRef, fingerprint));
     const row = getBindingById(store, cloudBinding.id) ??
         insertBinding(store, {
             id: cloudBinding.id,
-            workspaceId: input.workspaceId,
+            projectId: input.projectId,
             organizationId: input.organizationId,
             repositoryRoot: repository.repositoryRoot,
             gitDir: repository.gitDir,
@@ -55,7 +55,7 @@ export async function runRepositoryOnboarding(input) {
         store: input.store,
         baseUrl: input.baseUrl,
         accessToken: input.accessToken,
-        workspaceId: input.workspaceId,
+        projectId: input.projectId,
         organizationId: input.organizationId,
         repository: input.repository,
         boundBranch: input.boundBranch,
@@ -65,8 +65,8 @@ export async function runRepositoryOnboarding(input) {
         runTelemetry: input.runTelemetry,
     });
     const install = await installToolkit(input.store, established.binding.id, input.profile, input.repository.repositoryRoot, input.toolkitDeps ?? {});
-    const workspaceManifest = await writeWorkspaceManifests(input.repository.repositoryRoot, {
-        workspaceId: input.workspaceId,
+    const projectManifest = await writeProjectManifests(input.repository.repositoryRoot, {
+        projectId: input.projectId,
         organizationId: input.organizationId,
         toolkit: {
             name: input.profile.name,
@@ -77,7 +77,7 @@ export async function runRepositoryOnboarding(input) {
     });
     return {
         flow: input.flow,
-        workspaceId: input.workspaceId,
+        projectId: input.projectId,
         organizationId: input.organizationId,
         bindingId: established.binding.id,
         boundBranch: input.boundBranch,
@@ -85,7 +85,7 @@ export async function runRepositoryOnboarding(input) {
         toolkit: { name: input.profile.name, version: input.profile.version },
         reused: !established.created,
         install,
-        workspaceManifest,
+        projectManifest,
         noPush: true,
     };
 }

package/dist/lib/onboarding/folder_state.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { resolveRepository, readSymbolicBranch } from "../git-sync/core/repository.js";
 import { readGitOperationState } from "../git-sync/core/operation_state.js";
 import { NotARepositoryError } from "../git-sync/core/git_runner.js";
-import { legacyAppJsonPath, workspaceJsonPath } from "../workspace_context.js";
+import { legacyAppJsonPath, projectJsonPath } from "../project_context.js";
 const SAFE_OS_METADATA = new Set([".DS_Store", "Thumbs.db", "desktop.ini", ".localized"]);
 function significantEntries(dir) {
     let names;
@@ -15,8 +15,8 @@ function significantEntries(dir) {
     }
     return names.filter((name) => name !== ".git" && !SAFE_OS_METADATA.has(name));
 }
-function readMarkerWorkspaceId(root) {
-    const v2 = read(workspaceJsonPath(root));
+function readMarkerProjectId(root) {
+    const v2 = read(projectJsonPath(root));
     if (v2 && v2.schemaVersion === 2) {
         const id = trimmedField(v2.workspaceId);
         if (id)
@@ -38,7 +38,7 @@ function read(filePath) {
 function trimmedField(value) {
     return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
 }
-function isNestedUnderWorkspace(root) {
+function isNestedUnderProject(root) {
     let dir = path.dirname(root);
     while (dir && dir !== path.dirname(dir)) {
         const nustack = path.join(dir, ".nustack");
@@ -66,7 +66,7 @@ export function classifyFolder(dir) {
         const symbolicBranch = readSymbolicBranch(repository);
         const operation = readGitOperationState(repository);
         const pointerFileGit = lstatSync(gitPath).isFile();
-        const markerWorkspaceId = readMarkerWorkspaceId(repository.repositoryRoot);
+        const markerProjectId = readMarkerProjectId(repository.repositoryRoot);
         return {
             class: "git_worktree",
             entries,
@@ -77,9 +77,9 @@ export function classifyFolder(dir) {
                 operationKind: operation.kind,
                 operationInProgress: operation.kind !== "normal",
                 pointerFileGit,
-                hasWorkspaceMarker: markerWorkspaceId !== null,
-                markerWorkspaceId,
-                nestedUnderWorkspace: isNestedUnderWorkspace(repository.repositoryRoot),
+                hasProjectMarker: markerProjectId !== null,
+                markerProjectId,
+                nestedUnderProject: isNestedUnderProject(repository.repositoryRoot),
                 symbolicBranch,
             },
         };
@@ -89,8 +89,8 @@ export function classifyFolder(dir) {
     return { class: "populated_non_git", entries };
 }
 export function attachRejection(git) {
-    if (git.nestedUnderWorkspace)
-        return "nested_workspace";
+    if (git.nestedUnderProject)
+        return "nested_project";
     if (git.operationInProgress)
         return "operation_in_progress";
     if (git.detachedHead)

package/dist/lib/onboarding/handoff_apply.js

@@ -35,7 +35,7 @@ export function decideOnboardingApply(repo, targets) {
         return { kind: "apply" };
     return { kind: "overwrite_required", divergent: decision.divergent };
 }
-export function composeOnboardingCommit(store, repo, binding, handoffId, workspaceId, entries) {
+export function composeOnboardingCommit(store, repo, binding, handoffId, projectId, entries) {
     const oldHead = readHeadCommit(repo);
     const targets = entries.map((entry) => ({
         path: entry.path,
@@ -49,7 +49,7 @@ export function composeOnboardingCommit(store, repo, binding, handoffId, workspa
         if (entry.operation === "upsert" && entry.bytes)
             bytesByPath.set(entry.path, entry.bytes);
     }
-    const message = buildCommitMessage(handoffId, workspaceId, null);
+    const message = buildCommitMessage(handoffId, projectId, null);
     const built = buildCommit(repo, oldHead, targets, bytesByPath, message, {
         authorName: NUSTACK_SYNC_IDENTITY.name,
         authorEmail: NUSTACK_SYNC_IDENTITY.email,

package/dist/lib/onboarding/init_fresh_folder.js

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
-import { acknowledgeBindingCursor, createWorkspaceViaAsk, getWorkspace, latestHandoff, } from "../nustack_client.js";
+import { acknowledgeBindingCursor, createProjectViaAsk, getProject, latestHandoff, } from "../nustack_client.js";
 import { getBindingById } from "../local_store/bindings.js";
 import { hasManifest, scaffoldManifest } from "../manifest.js";
 import { fetchToolkitProfile, toolkitProfileFromManifest, ToolkitProfileUnavailableError } from "../etna/profile.js";
@@ -13,7 +13,7 @@ export const MANAGED_ONBOARDING_FILES = [".nustack/workspace.json", "nustack.ser
 export async function initFreshFolder(ctx, options) {
     const state = classifyFolder(ctx.cwd);
     if (state.class === "git_worktree") {
-        return { ok: false, code: "ALREADY_A_WORKTREE", message: "This folder is already a Git worktree — use `nustack workspace attach` instead of `nustack init`." };
+        return { ok: false, code: "ALREADY_A_WORKTREE", message: "This folder is already a Git worktree — use `nustack project attach` instead of `nustack init`." };
     }
     if (state.class === "populated_non_git" && options.confirmPopulated !== true) {
         return {
@@ -28,13 +28,13 @@ export async function initFreshFolder(ctx, options) {
     }
     const repository = initGitRepository(ctx.cwd);
     const boundBranch = "main";
-    const workspaceId = options.workspaceId ?? (await createFreshWorkspace(ctx, state.class, options));
-    if (workspaceId === null) {
-        return { ok: false, code: "WORKSPACE_INITIALIZATION_FAILED", message: "The Workspace failed to initialize — check the Organization and try again." };
+    const projectId = options.projectId ?? (await createFreshProject(ctx, state.class, options));
+    if (projectId === null) {
+        return { ok: false, code: "PROJECT_INITIALIZATION_FAILED", message: "The Project failed to initialize — check the Organization and try again." };
     }
-    const profile = await resolveProfile(ctx, workspaceId);
+    const profile = await resolveProfile(ctx, projectId);
     if (!profile) {
-        return { ok: false, code: "HARNESS_PROFILE_UNAVAILABLE", message: "The Workspace did not project a Toolkit Profile pin — the owning server plan must expose it." };
+        return { ok: false, code: "HARNESS_PROFILE_UNAVAILABLE", message: "The Project did not project a Toolkit Profile pin — the owning server plan must expose it." };
     }
     const result = await runRepositoryOnboarding({
         store: ctx.store,
@@ -42,7 +42,7 @@ export async function initFreshFolder(ctx, options) {
         accessToken: ctx.accessToken,
         deviceRef: ctx.deviceRef,
         flow: "fresh_folder",
-        workspaceId,
+        projectId,
         organizationId: options.organizationId,
         repository,
         boundBranch,
@@ -51,7 +51,7 @@ export async function initFreshFolder(ctx, options) {
         toolkitDeps: ctx.toolkitDeps,
         runTelemetry: ctx.runTelemetry,
     });
-    const seed = await latestHandoff(ctx.baseUrl, ctx.accessToken, workspaceId);
+    const seed = await latestHandoff(ctx.baseUrl, ctx.accessToken, projectId);
     const entries = MANAGED_ONBOARDING_FILES.map((rel) => ({
         path: rel,
         operation: "upsert",
@@ -67,8 +67,8 @@ export async function initFreshFolder(ctx, options) {
         }
     }
     const binding = getBindingById(ctx.store, result.bindingId);
-    const handoffId = seed?.id ?? `onboarding_seed:${workspaceId}`;
-    const commit = composeOnboardingCommit(ctx.store, repository, binding, handoffId, workspaceId, entries);
+    const handoffId = seed?.id ?? `onboarding_seed:${projectId}`;
+    const commit = composeOnboardingCommit(ctx.store, repository, binding, handoffId, projectId, entries);
     if (seed) {
         await acknowledgeBindingCursor(ctx.baseUrl, ctx.accessToken, { bindingId: result.bindingId, lastAppliedSequence: 0 }).catch(() => { });
     }
@@ -77,22 +77,22 @@ export async function initFreshFolder(ctx, options) {
         result: { ...result, baselineCommitId: commit.commitId, rootCommitId: commit.commitId, changedPaths: commit.changedPaths, handoffId: seed?.id ?? null },
     };
 }
-async function createFreshWorkspace(ctx, folderClass, options) {
+async function createFreshProject(ctx, folderClass, options) {
     void folderClass;
-    const outcome = await createWorkspaceViaAsk(ctx.baseUrl, ctx.accessToken, options.organizationId, `Create a workspace named "${options.name}".`);
-    const final = await getWorkspace(ctx.baseUrl, ctx.accessToken, outcome.workspaceId);
+    const outcome = await createProjectViaAsk(ctx.baseUrl, ctx.accessToken, options.organizationId, `Create a project named "${options.name}".`);
+    const final = await getProject(ctx.baseUrl, ctx.accessToken, outcome.projectId);
     const failed = final.status === "initialization_failed" || final.initStatus === "failed";
-    return failed ? null : outcome.workspaceId;
+    return failed ? null : outcome.projectId;
 }
-async function resolveProfile(ctx, workspaceId) {
+async function resolveProfile(ctx, projectId) {
     try {
-        return await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, workspaceId);
+        return await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, projectId);
     }
     catch (error) {
         if (!(error instanceof ToolkitProfileUnavailableError))
             throw error;
     }
-    const seed = await latestHandoff(ctx.baseUrl, ctx.accessToken, workspaceId);
+    const seed = await latestHandoff(ctx.baseUrl, ctx.accessToken, projectId);
     if (!seed)
         return null;
     const manifest = await fetchHandoffManifest(ctx.baseUrl, ctx.accessToken, { handoffId: seed.id, bindingId: "" }).catch(() => null);

package/dist/lib/onboarding/manifest_writer.js

@@ -1,14 +1,14 @@
 import { readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import path from "node:path";
-import { legacyAppJsonPath, readBindingMarker, workspaceJsonPath } from "../workspace_context.js";
+import { legacyAppJsonPath, readBindingMarker, projectJsonPath } from "../project_context.js";
 import { manifestPath } from "../manifest.js";
 const CURRENT_BINDING_PROTOCOL_VERSION = 1;
 const CURRENT_DOCUMENT_PROTOCOL_VERSION = 1;
-function buildWorkspaceManifest(identity) {
+function buildProjectManifest(identity) {
     return {
         schemaVersion: 2,
-        workspaceId: identity.workspaceId,
+        workspaceId: identity.projectId,
         organizationId: identity.organizationId,
         bindingProtocolVersion: identity.bindingProtocolVersion ?? CURRENT_BINDING_PROTOCOL_VERSION,
         documentProtocolVersion: identity.documentProtocolVersion ?? CURRENT_DOCUMENT_PROTOCOL_VERSION,
@@ -35,10 +35,10 @@ async function restore(target, prior) {
         await writeFile(target, prior, "utf8");
     }
 }
-export async function writeWorkspaceManifests(root, identity, hooks = {}) {
+export async function writeProjectManifests(root, identity, hooks = {}) {
     const servicePath = manifestPath(root);
     if (!existsSync(servicePath)) {
-        throw new Error("nustack.service.json is required before writing the Workspace binding — scaffold it first.");
+        throw new Error("nustack.service.json is required before writing the Project binding — scaffold it first.");
     }
     const serviceRaw = await readFile(servicePath, "utf8");
     let serviceManifest;
@@ -50,66 +50,66 @@ export async function writeWorkspaceManifests(root, identity, hooks = {}) {
     }
     const nextService = {
         ...serviceManifest,
-        nustackWorkspace: { v: 2, workspaceId: identity.workspaceId, organizationId: identity.organizationId },
+        nustackWorkspace: { v: 2, workspaceId: identity.projectId, organizationId: identity.organizationId },
         toolkit: { name: identity.toolkit.name, version: identity.toolkit.version },
     };
     delete nextService.nustackApp;
-    const workspaceManifest = buildWorkspaceManifest(identity);
-    const workspaceDir = path.dirname(workspaceJsonPath(root));
-    await mkdir(workspaceDir, { recursive: true });
-    const workspacePrior = await atomicWrite(workspaceJsonPath(root), JSON.stringify(workspaceManifest, null, 2) + "\n");
+    const projectManifest = buildProjectManifest(identity);
+    const projectDir = path.dirname(projectJsonPath(root));
+    await mkdir(projectDir, { recursive: true });
+    const projectPrior = await atomicWrite(projectJsonPath(root), JSON.stringify(projectManifest, null, 2) + "\n");
     try {
         if (hooks.beforeServiceWrite)
             await hooks.beforeServiceWrite();
         await atomicWrite(servicePath, JSON.stringify(nextService, null, 4) + "\n");
     }
     catch (error) {
-        await restore(workspaceJsonPath(root), workspacePrior);
+        await restore(projectJsonPath(root), projectPrior);
         throw error;
     }
-    return workspaceManifest;
+    return projectManifest;
 }
 function toolkitEqual(a, b) {
     return a !== null && b !== null && a.name === b.name && a.version === b.version;
 }
-export async function readWorkspaceManifests(root) {
-    const workspaceManifest = await readWorkspaceJson(root);
+export async function readProjectManifests(root) {
+    const projectManifest = await readProjectJson(root);
     const service = await readServiceBlocks(root);
     let localDiagnosis;
-    if (!workspaceManifest || !service.toolkit) {
+    if (!projectManifest || !service.toolkit) {
         localDiagnosis = "missing";
     }
     else {
-        localDiagnosis = toolkitEqual(workspaceManifest.toolkit, service.toolkit) ? "aligned" : "divergent";
+        localDiagnosis = toolkitEqual(projectManifest.toolkit, service.toolkit) ? "aligned" : "divergent";
     }
     return {
-        workspaceManifest,
-        serviceWorkspaceBinding: service.binding,
+        projectManifest,
+        serviceProjectBinding: service.binding,
         serviceToolkit: service.toolkit,
         localDiagnosis,
     };
 }
-export function diagnoseManifests(cloud, workspaceJson, serviceJson) {
-    if (!workspaceJson || !serviceJson)
+export function diagnoseManifests(cloud, projectJson, serviceJson) {
+    if (!projectJson || !serviceJson)
         return "missing";
     if (!cloud) {
-        return toolkitEqual(workspaceJson, serviceJson) ? "aligned" : "divergent";
+        return toolkitEqual(projectJson, serviceJson) ? "aligned" : "divergent";
     }
-    const workspaceOk = toolkitEqual(cloud, workspaceJson);
+    const projectOk = toolkitEqual(cloud, projectJson);
     const serviceOk = toolkitEqual(cloud, serviceJson);
-    if (workspaceOk && serviceOk)
+    if (projectOk && serviceOk)
         return "aligned";
-    if (!workspaceOk && serviceOk)
-        return "workspace_json_stale";
-    if (workspaceOk && !serviceOk)
+    if (!projectOk && serviceOk)
+        return "project_json_stale";
+    if (projectOk && !serviceOk)
         return "service_json_stale";
     return "divergent";
 }
-async function readWorkspaceJson(root) {
+async function readProjectJson(root) {
     const marker = await readBindingMarker(root);
     if (!marker)
         return null;
-    const filePath = marker.version === 2 ? workspaceJsonPath(root) : legacyAppJsonPath(root);
+    const filePath = marker.version === 2 ? projectJsonPath(root) : legacyAppJsonPath(root);
     if (!existsSync(filePath))
         return null;
     try {
@@ -121,7 +121,7 @@ async function readWorkspaceJson(root) {
             return null;
         return {
             schemaVersion: 2,
-            workspaceId: marker.workspaceId,
+            workspaceId: marker.projectId,
             organizationId: marker.organizationId,
             bindingProtocolVersion: typeof raw.bindingProtocolVersion === "number" ? raw.bindingProtocolVersion : 1,
             documentProtocolVersion: typeof raw.documentProtocolVersion === "number" ? raw.documentProtocolVersion : 1,
@@ -146,9 +146,9 @@ async function readServiceBlocks(root) {
         const v2 = manifest.nustackWorkspace;
         const v1 = manifest.nustackApp;
         const binding = typeof v2?.workspaceId === "string" && typeof v2?.organizationId === "string"
-            ? { workspaceId: v2.workspaceId, organizationId: v2.organizationId }
+            ? { projectId: v2.workspaceId, organizationId: v2.organizationId }
             : typeof v1?.appId === "string" && typeof v1?.workspaceId === "string"
-                ? { workspaceId: v1.appId, organizationId: v1.workspaceId }
+                ? { projectId: v1.appId, organizationId: v1.workspaceId }
                 : null;
         const toolkit = typeof manifest.toolkit?.name === "string" && typeof manifest.toolkit?.version === "string"
             ? { name: manifest.toolkit.name, version: manifest.toolkit.version }

package/dist/lib/onboarding/web_first_attach.js

@@ -42,9 +42,9 @@ export async function webFirstAttach(ctx, options) {
     if (!hasManifest(repository.repositoryRoot)) {
         await scaffoldManifest(repository.repositoryRoot, deriveScaffoldSlug(repository.repositoryRoot));
     }
-    const profile = await resolveProfile(ctx, options.workspaceId);
+    const profile = await resolveProfile(ctx, options.projectId);
     if (!profile)
-        return { ok: false, code: "HARNESS_PROFILE_UNAVAILABLE", message: "The Workspace did not project a Toolkit Profile pin — the owning server plan must expose it." };
+        return { ok: false, code: "HARNESS_PROFILE_UNAVAILABLE", message: "The Project did not project a Toolkit Profile pin — the owning server plan must expose it." };
     const baselineCommitId = isFresh ? null : readHeadCommit(repository);
     const result = await runRepositoryOnboarding({
         store: ctx.store,
@@ -52,7 +52,7 @@ export async function webFirstAttach(ctx, options) {
         accessToken: ctx.accessToken,
         deviceRef: ctx.deviceRef,
         flow: "web_first",
-        workspaceId: options.workspaceId,
+        projectId: options.projectId,
         organizationId: options.organizationId,
         repository,
         boundBranch,
@@ -62,10 +62,10 @@ export async function webFirstAttach(ctx, options) {
         runTelemetry: ctx.runTelemetry,
     });
     const binding = getBindingById(ctx.store, result.bindingId);
-    const latest = await latestHandoff(ctx.baseUrl, ctx.accessToken, options.workspaceId).catch(() => null);
+    const latest = await latestHandoff(ctx.baseUrl, ctx.accessToken, options.projectId).catch(() => null);
     if (!latest) {
         const applied = isFresh
-            ? composeOnboardingCommit(ctx.store, repository, binding, `onboarding_seed:${options.workspaceId}`, options.workspaceId, managedEntries(repository.repositoryRoot))
+            ? composeOnboardingCommit(ctx.store, repository, binding, `onboarding_seed:${options.projectId}`, options.projectId, managedEntries(repository.repositoryRoot))
             : null;
         return { ok: true, result: baseResult(result, applied, null, false, []) };
     }
@@ -86,7 +86,7 @@ export async function webFirstAttach(ctx, options) {
             entries.push({ path: target.path, operation: target.operation, bytes: bytesByPath.get(target.path) ?? null });
         }
     }
-    const applied = entries.length > 0 ? composeOnboardingCommit(ctx.store, repository, binding, latest.id, options.workspaceId, entries) : null;
+    const applied = entries.length > 0 ? composeOnboardingCommit(ctx.store, repository, binding, latest.id, options.projectId, entries) : null;
     await acknowledgeBindingCursor(ctx.baseUrl, ctx.accessToken, { bindingId: result.bindingId, lastAppliedSequence: 0 }).catch(() => { });
     return { ok: true, result: baseResult(result, applied, latest.id, false, []) };
 }
@@ -104,27 +104,27 @@ function baseResult(result, applied, handoffId, overwriteRequired, divergent) {
         divergent,
     };
 }
-async function resolveProfile(ctx, workspaceId) {
+async function resolveProfile(ctx, projectId) {
     try {
-        return await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, workspaceId);
+        return await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, projectId);
     }
     catch (error) {
         if (!(error instanceof ToolkitProfileUnavailableError))
             throw error;
     }
-    const seed = await latestHandoff(ctx.baseUrl, ctx.accessToken, workspaceId).catch(() => null);
+    const seed = await latestHandoff(ctx.baseUrl, ctx.accessToken, projectId).catch(() => null);
     if (!seed)
         return null;
     const manifest = await fetchHandoffManifest(ctx.baseUrl, ctx.accessToken, { handoffId: seed.id, bindingId: "" }).catch(() => null);
     return manifest ? toolkitProfileFromManifest(manifest) : null;
 }
 function deriveScaffoldSlug(root) {
-    return path.basename(root).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+    return path.basename(root).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
 }
 function rejectionMessage(rejection) {
     switch (rejection) {
-        case "nested_workspace":
-            return "This repository is nested inside another NuStack Workspace — one Workspace has one logical repository root (F-014).";
+        case "nested_project":
+            return "This repository is nested inside another NuStack Project — one Project has one logical repository root (F-014).";
         case "operation_in_progress":
             return "A merge, rebase, cherry-pick, or revert is in progress — finish or abort it, then re-attach.";
         case "detached_head":

package/dist/lib/{workspace_context.js → project_context.js}

@@ -4,22 +4,22 @@ import { existsSync } from "node:fs";
 import { readManagedValues } from "./env_file.js";
 import { manifestPath } from "./manifest.js";
 import { assertSafeOpaqueId } from "./guards.js";
-const NO_WORKSPACE_MESSAGE = "No Workspace id — run inside a bound repository (`.nustack/workspace.json`), pass `--workspace <id>`, add an `nustackWorkspace.workspaceId` to nustack.service.json, or set NUSTACK_WORKSPACE_ID in the managed .env block.";
-export function workspaceJsonPath(cwd) {
+const NO_PROJECT_MESSAGE = "No Project id — run inside a bound repository (`.nustack/workspace.json`), pass `--project <id>`, add an `nustackWorkspace.projectId` to nustack.service.json, or set NUSTACK_WORKSPACE_ID in the managed .env block.";
+export function projectJsonPath(cwd) {
     return path.join(cwd, ".nustack", "workspace.json");
 }
 export function legacyAppJsonPath(cwd) {
     return path.join(cwd, ".nustack", "app.json");
 }
 export async function readBindingMarker(cwd) {
-    const v2Path = workspaceJsonPath(cwd);
+    const v2Path = projectJsonPath(cwd);
     if (existsSync(v2Path)) {
         try {
             const marker = JSON.parse(await readFile(v2Path, "utf8"));
             if (marker.schemaVersion === 2) {
-                const workspaceId = trimmed(marker.workspaceId);
-                if (workspaceId) {
-                    return { workspaceId, organizationId: trimmed(marker.organizationId), version: 2 };
+                const projectId = trimmed(marker.workspaceId);
+                if (projectId) {
+                    return { projectId, organizationId: trimmed(marker.organizationId), version: 2 };
                 }
             }
         }
@@ -33,10 +33,10 @@ export async function readBindingMarker(cwd) {
         const marker = JSON.parse(await readFile(v1Path, "utf8"));
         if (marker.schemaVersion !== undefined && marker.schemaVersion !== 1)
             return null;
-        const workspaceId = trimmed(marker.appId);
-        if (!workspaceId)
+        const projectId = trimmed(marker.appId);
+        if (!projectId)
             return null;
-        return { workspaceId, organizationId: trimmed(marker.workspaceId), version: 1 };
+        return { projectId, organizationId: trimmed(marker.workspaceId), version: 1 };
     }
     catch {
         return null;
@@ -45,10 +45,10 @@ export async function readBindingMarker(cwd) {
 function trimmed(value) {
     return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
 }
-export async function readWorkspaceJsonWorkspaceId(cwd) {
-    return (await readBindingMarker(cwd))?.workspaceId ?? null;
+export async function readProjectJsonProjectId(cwd) {
+    return (await readBindingMarker(cwd))?.projectId ?? null;
 }
-async function readManifestWorkspaceId(cwd) {
+async function readManifestProjectId(cwd) {
     const filePath = manifestPath(cwd);
     if (!existsSync(filePath))
         return null;
@@ -60,24 +60,24 @@ async function readManifestWorkspaceId(cwd) {
         return null;
     }
 }
-async function readEnvWorkspaceId(cwd) {
+async function readEnvProjectId(cwd) {
     const managed = await readManagedValues(path.join(cwd, ".env"));
-    const workspaceId = managed.NUSTACK_WORKSPACE_ID?.trim();
-    return workspaceId ? workspaceId : null;
+    const projectId = managed.NUSTACK_WORKSPACE_ID?.trim();
+    return projectId ? projectId : null;
 }
-export async function resolveWorkspaceId(cwd, options) {
-    const flag = options.workspace?.trim();
-    const workspaceJsonId = await readWorkspaceJsonWorkspaceId(cwd);
-    const candidate = workspaceJsonId
-        ? { value: workspaceJsonId, source: "workspace_json" }
+export async function resolveProjectId(cwd, options) {
+    const flag = options.project?.trim();
+    const projectJsonId = await readProjectJsonProjectId(cwd);
+    const candidate = projectJsonId
+        ? { value: projectJsonId, source: "project_json" }
         : flag
             ? { value: flag, source: "flag" }
-            : (await readManifestWorkspaceId(cwd).then((id) => (id ? { value: id, source: "manifest" } : null))) ??
-                (await readEnvWorkspaceId(cwd).then((id) => (id ? { value: id, source: "env" } : null)));
+            : (await readManifestProjectId(cwd).then((id) => (id ? { value: id, source: "manifest" } : null))) ??
+                (await readEnvProjectId(cwd).then((id) => (id ? { value: id, source: "env" } : null)));
     if (!candidate)
-        return { ok: false, message: NO_WORKSPACE_MESSAGE };
+        return { ok: false, message: NO_PROJECT_MESSAGE };
     try {
-        return { ok: true, workspaceId: assertSafeOpaqueId("The Workspace id", candidate.value), source: candidate.source };
+        return { ok: true, projectId: assertSafeOpaqueId("The Project id", candidate.value), source: candidate.source };
     }
     catch (error) {
         return { ok: false, message: error instanceof Error ? error.message : String(error) };

package/dist/lib/review/client.js

@@ -41,7 +41,7 @@ export function makeReviewClient(baseUrl, accessToken) {
                 method: "POST",
                 body: JSON.stringify({
                     kind: "blocking_approval",
-                    workspaceId: input.workspaceId,
+                    projectId: input.projectId,
                     sessionId: input.sessionId,
                     subject: input.subject,
                     ...(input.answerableByUserId ? { answerableByUserId: input.answerableByUserId } : {}),

package/dist/lib/session_telemetry.js

@@ -44,7 +44,7 @@ function toTelemetryBinding(binding, deviceRef, userId) {
         bindingId: binding.id,
         repoRoot: binding.repositoryRoot,
         organizationId: binding.organizationId,
-        workspaceId: binding.workspaceId,
+        projectId: binding.projectId,
         deviceRef,
         userId,
     };
@@ -122,7 +122,7 @@ export async function ensureBindingTelemetry(opts) {
         }
         let brokerFailure = null;
         const credential = await fetchBrokeredCredential(baseUrl, auth.accessToken, {
-            workspaceId: binding.workspaceId,
+            projectId: binding.projectId,
             service: TELEMETRY_SERVICE,
         }).catch((error) => {
             brokerFailure = error instanceof Error ? error.message : String(error);