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

package/dist/commands/sync.js

@@ -1,9 +1,9 @@
 import path from "node:path";
 import * as p from "@clack/prompts";
-import { exchangeServiceCredential, fetchServiceCredential, listWorkspaceIntegrations, resolveNuStackUrl, } from "../lib/nustack_client.js";
+import { exchangeServiceCredential, fetchServiceCredential, listProjectIntegrations, resolveNuStackUrl, } from "../lib/nustack_client.js";
 import { readConsumesEdges } from "../lib/manifest.js";
 import { ensureAccessToken, signedOutCopy } from "../lib/auth_grant.js";
-import { resolveWorkspaceId } from "../lib/workspace_context.js";
+import { resolveProjectId } from "../lib/project_context.js";
 import { readManagedValues, writeManagedValues } from "../lib/env_file.js";
 import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
 const COMMAND = "sync";
@@ -18,23 +18,23 @@ export async function runSync(options) {
     if (!deviceAuth)
         return failSync(json, "SIGNED_OUT", signedOut(), "The managed block was not touched.");
     const accessToken = deviceAuth.accessToken;
-    const workspace = await resolveWorkspaceId(cwd, { workspace: options.workspace });
-    if (!workspace.ok)
-        return failSync(json, "WORKSPACE_UNRESOLVED", workspace.message, "The managed block was not touched.");
+    const project = await resolveProjectId(cwd, { project: options.project });
+    if (!project.ok)
+        return failSync(json, "PROJECT_UNRESOLVED", project.message, "The managed block was not touched.");
     const spinner = json ? null : p.spinner();
     spinner?.start("Exchanging declared services");
     let activeServices;
     let projections;
     try {
         for (const edge of await readConsumesEdges(cwd)) {
-            await exchangeServiceCredential(baseUrl, accessToken, { workspaceId: workspace.workspaceId, service: edge.service });
+            await exchangeServiceCredential(baseUrl, accessToken, { projectId: project.projectId, service: edge.service });
         }
         spinner?.message("Enumerating active integrations");
-        const integrations = await listWorkspaceIntegrations(baseUrl, accessToken, workspace.workspaceId);
+        const integrations = await listProjectIntegrations(baseUrl, accessToken, project.projectId);
         activeServices = integrations.filter((i) => i.status === "active").map((i) => i.serviceSlug);
         projections = [];
         for (const service of activeServices) {
-            projections.push(await fetchServiceCredential(baseUrl, accessToken, { workspaceId: workspace.workspaceId, service }));
+            projections.push(await fetchServiceCredential(baseUrl, accessToken, { projectId: project.projectId, service }));
         }
     }
     catch (error) {
@@ -59,7 +59,7 @@ export async function runSync(options) {
     await writeManagedValues(path.join(cwd, ".env.example"), placeholders);
     if (json) {
         printJsonSuccess(COMMAND, {
-            workspaceId: workspace.workspaceId,
+            projectId: project.projectId,
             integrations: activeServices.map((service) => ({ service, status: "active" })),
             envKeysWritten: Object.keys(nextValues),
             removedKeys,
@@ -69,7 +69,7 @@ export async function runSync(options) {
     p.log.success(`Managed block rewritten: ${projections.length} service credential(s).`);
     if (removedKeys.length > 0)
         p.log.info(`Removed stale entries: ${removedKeys.join(", ")}`);
-    p.outro("In sync with NuStack — Service credentials only (Documents & Git are `nustack workspace sync`).");
+    p.outro("In sync with NuStack — Service credentials only (Documents & Git are `nustack project sync`).");
 }
 function failSync(json, code, message, humanTail) {
     if (json) {

package/dist/commands/toolkit.js

@@ -1,12 +1,12 @@
 import * as p from "@clack/prompts";
 import { resolveNuStackUrl } from "../lib/nustack_client.js";
 import { ensureAuthWithRecovery, lastAuthFailure } from "../lib/auth_recovery.js";
-import { resolveWorkspaceId } from "../lib/workspace_context.js";
+import { resolveProjectId } from "../lib/project_context.js";
 import { isInteractive } from "../lib/interactive.js";
 import { openLocalStore } from "../lib/local_store/database.js";
 import { getBindingByRepositoryRoot } from "../lib/local_store/bindings.js";
 import { resolveRepository } from "../lib/git-sync/core/repository.js";
-import { readWorkspaceManifests, diagnoseManifests } from "../lib/onboarding/manifest_writer.js";
+import { readProjectManifests, diagnoseManifests } from "../lib/onboarding/manifest_writer.js";
 import { fetchToolkitProfile, ToolkitProfileUnavailableError } from "../lib/etna/profile.js";
 import { buildReconcilePlan, applyReconcile, toolkitCompatibility } from "../lib/etna/reconcile.js";
 import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
@@ -28,9 +28,9 @@ async function resolveContext(command, json, options, globals) {
         return null;
     }
     const baseUrl = resolveNuStackUrl(globals);
-    const workspace = await resolveWorkspaceId(root, options);
-    if (!workspace.ok) {
-        emitFail(command, json, "WORKSPACE_CONTEXT_MISSING", workspace.message);
+    const project = await resolveProjectId(root, options);
+    if (!project.ok) {
+        emitFail(command, json, "PROJECT_CONTEXT_MISSING", project.message);
         return null;
     }
     const deviceAuth = await ensureAuthWithRecovery(baseUrl, json);
@@ -39,7 +39,7 @@ async function resolveContext(command, json, options, globals) {
         emitFail(command, json, failure.code, failure.message);
         return null;
     }
-    return { baseUrl, accessToken: deviceAuth.accessToken, workspaceId: workspace.workspaceId, root };
+    return { baseUrl, accessToken: deviceAuth.accessToken, projectId: project.projectId, root };
 }
 export async function runToolkitStatus(options, globals) {
     const json = options.json === true;
@@ -48,7 +48,7 @@ export async function runToolkitStatus(options, globals) {
         return;
     let cloud;
     try {
-        cloud = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, ctx.workspaceId);
+        cloud = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, ctx.projectId);
     }
     catch (error) {
         if (error instanceof ToolkitProfileUnavailableError) {
@@ -57,24 +57,24 @@ export async function runToolkitStatus(options, globals) {
         }
         throw error;
     }
-    const manifests = await readWorkspaceManifests(ctx.root);
-    const diagnosis = diagnoseManifests({ name: cloud.name, version: cloud.version }, manifests.workspaceManifest?.toolkit ?? null, manifests.serviceToolkit);
+    const manifests = await readProjectManifests(ctx.root);
+    const diagnosis = diagnoseManifests({ name: cloud.name, version: cloud.version }, manifests.projectManifest?.toolkit ?? null, manifests.serviceToolkit);
     const binding = await withStore((store) => getBindingByRepositoryRoot(store, ctx.root));
     const compatibility = toolkitCompatibility(binding ?? { etnaProfileJson: null }, cloud);
     if (json) {
         printJsonSuccess("toolkit status", {
-            workspaceId: ctx.workspaceId,
+            projectId: ctx.projectId,
             cloud,
-            workspaceJson: manifests.workspaceManifest?.toolkit ?? null,
+            projectJson: manifests.projectManifest?.toolkit ?? null,
             serviceJson: manifests.serviceToolkit,
             diagnosis,
             compatibility,
         });
         return;
     }
-    console.log(`Toolkit for Workspace ${ctx.workspaceId}`);
+    console.log(`Toolkit for Project ${ctx.projectId}`);
     console.log(`  cloud pin:          ${cloud.name}@${cloud.version} (renderer ${cloud.rendererVersion}, placement ${cloud.placementMapVersion})`);
-    console.log(`  .nustack/app.json:   ${fmtToolkit(manifests.workspaceManifest?.toolkit)}`);
+    console.log(`  .nustack/app.json:   ${fmtToolkit(manifests.projectManifest?.toolkit)}`);
     console.log(`  nustack.service.json:${fmtToolkit(manifests.serviceToolkit)}`);
     console.log(`  diagnosis:          ${diagnosis}`);
     console.log(`  write gate:         ${compatibility.blocksWrites ? `BLOCKED — ${compatibility.reason}` : "clear (projection and sync writes allowed)"}`);
@@ -89,7 +89,7 @@ export async function runToolkitReconcile(options, globals) {
         return;
     let cloud;
     try {
-        cloud = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, ctx.workspaceId);
+        cloud = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, ctx.projectId);
     }
     catch (error) {
         if (error instanceof ToolkitProfileUnavailableError) {
@@ -99,12 +99,12 @@ export async function runToolkitReconcile(options, globals) {
         throw error;
     }
     const binding = await withStore((store) => getBindingByRepositoryRoot(store, ctx.root));
-    const manifests = await readWorkspaceManifests(ctx.root);
-    const identity = manifests.workspaceManifest
-        ? { workspaceId: manifests.workspaceManifest.workspaceId, organizationId: manifests.workspaceManifest.organizationId }
-        : manifests.serviceWorkspaceBinding;
+    const manifests = await readProjectManifests(ctx.root);
+    const identity = manifests.projectManifest
+        ? { projectId: manifests.projectManifest.workspaceId, organizationId: manifests.projectManifest.organizationId }
+        : manifests.serviceProjectBinding;
     if (!identity) {
-        emitFail("toolkit reconcile", json, "WORKSPACE_CONTEXT_MISSING", "No `.nustack/app.json` binding to reconcile — attach the repository first.");
+        emitFail("toolkit reconcile", json, "PROJECT_CONTEXT_MISSING", "No `.nustack/app.json` binding to reconcile — attach the repository first.");
         return;
     }
     const plan = await buildReconcilePlan(ctx.root, binding ?? { etnaProfileJson: null }, cloud);

package/dist/index.js

@@ -16,8 +16,8 @@ import { runLogout } from "./commands/logout.js";
 import { runTelemetry } from "./commands/telemetry.js";
 import { runSearch, runSearchServices } from "./commands/search.js";
 import { runDeviceList, runDeviceRevoke, runDeviceStatus } from "./commands/device.js";
-import { registerWorkspaceSyncCommands } from "./commands/workspace-sync.js";
-import { registerWorkspaceCommands } from "./commands/workspace.js";
+import { registerProjectSyncCommands } from "./commands/project-sync.js";
+import { registerProjectCommands } from "./commands/project.js";
 import { runOrganizationList, runOrganizationCreate, runOrganizationUse } from "./commands/organization.js";
 import { runDocsList, runDocsShow, runDocsStatus } from "./commands/docs.js";
 import { runHandoffList, runHandoffShow } from "./commands/handoff.js";
@@ -52,8 +52,8 @@ program
     .action(async (options) => runLogout(program.opts(), { forgetDevice: options.forgetDevice }));
 program
     .command("init")
-    .description("Onboard this folder: sign in, then bind it to a Workspace (the onboarding router)")
-    .option("--organization <id>", "the Organization to create or select the Workspace in")
+    .description("Onboard this folder: sign in, then bind it to a Project (the onboarding router)")
+    .option("--organization <id>", "the Organization to create or select the Project in")
     .option("--yes", "pre-confirm the populated-folder onboarding guard")
     .action(async (options) => runInit({ ...program.opts(), ...options }));
 program
@@ -69,8 +69,8 @@ program
     .action(async (options) => runList(options, program.opts()));
 program
     .command("sync")
-    .description("Project this Workspace's Service credentials into the managed .env block (not Documents or Git)")
-    .option("--workspace <id>", "the Workspace to act as (defaults to nustack.service.json / NUSTACK_WORKSPACE_ID)")
+    .description("Project this Project's Service credentials into the managed .env block (not Documents or Git)")
+    .option("--project <id>", "the Project to act as (defaults to nustack.service.json / NUSTACK_WORKSPACE_ID)")
     .option("--json", "emit the versioned machine envelope instead of interactive output")
     .action(async (options) => runSync({ ...program.opts(), ...options }));
 program
@@ -98,7 +98,7 @@ program
 program
     .command("doctor")
     .description("Run the full local diagnostics matrix (identity, repository, manifests, toolkit, telemetry, credentials)")
-    .option("--workspace <id>", "the Workspace to diagnose (defaults to the bound repository)")
+    .option("--project <id>", "the Project to diagnose (defaults to the bound repository)")
     .option("--json", "emit the versioned machine envelope (secrets and absolute paths redacted)")
     .option("--local-verbose", "include Device-local absolute paths in the output")
     .action(async (options) => runDoctor({ ...program.opts(), ...options }));
@@ -144,9 +144,9 @@ program
 const toLimit = (value) => Number.parseInt(value, 10);
 const search = program
     .command("search [keywords...]")
-    .description("Search the NuStack Directory for workspaces by keyword")
+    .description("Search the NuStack Directory for projects by keyword")
     .option("--json", "emit the raw results array as JSON")
-    .option("--category <cat>", "filter workspaces by category")
+    .option("--category <cat>", "filter projects by category")
     .option("--limit <n>", "max results (default 20)", toLimit)
     .action(async (keywords, options) => runSearch(keywords, options, program.opts()));
 search
@@ -156,8 +156,8 @@ search
     .option("--type <type>", "filter services by type")
     .option("--limit <n>", "max results (default 20)", toLimit)
     .action(async (keywords, options) => runSearchServices(keywords, { ...search.opts(), ...options }, program.opts()));
-search.addHelpText("after", '\n`services` is a reserved subcommand. To search workspaces for the literal word "services", use the\n' +
-    "explicit separator: `nustack search -- services` (everything after `--` is an workspaces query).");
+search.addHelpText("after", '\n`services` is a reserved subcommand. To search projects for the literal word "services", use the\n' +
+    "explicit separator: `nustack search -- services` (everything after `--` is an projects query).");
 const organization = program.command("organization").description("Work with your NuStack Organizations");
 organization
     .command("list")
@@ -174,40 +174,40 @@ organization
     .description("Set the active Organization context for this device")
     .option("--json", "emit the versioned machine envelope")
     .action(async (target, options) => runOrganizationUse(target, options, program.opts()));
-const workspace = program.command("workspace").description("Work with NuStack Workspaces");
-registerWorkspaceCommands(workspace, () => program.opts());
-registerWorkspaceSyncCommands(workspace, () => program.opts());
+const project = program.command("project").description("Work with NuStack Projects");
+registerProjectCommands(project, () => program.opts());
+registerProjectSyncCommands(project, () => program.opts());
 registerReviewCommands(program.command("review").description("Read and mirror NuStack Review items"), () => program.opts());
-const docs = program.command("docs").description("Work with a Workspace's Documents");
+const docs = program.command("docs").description("Work with a Project's Documents");
 docs
     .command("list")
-    .description("List the Workspace's Documents")
-    .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+    .description("List the Project's Documents")
+    .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--json", "emit the versioned machine envelope")
     .action(async (options) => runDocsList(options, program.opts()));
 docs
     .command("show <slug-or-id>")
     .description("Show a Document: a bounded inline body or its content URL")
-    .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+    .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--json", "emit the versioned machine envelope")
     .action(async (target, options) => runDocsShow(target, options, program.opts()));
 docs
     .command("status")
     .description("Report per-path local/cloud Document convergence for the bound repository")
-    .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+    .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--json", "emit the versioned machine envelope")
     .action(async (options) => runDocsStatus(options, program.opts()));
-const handoff = program.command("handoff").description("Work with a Workspace's Handoffs");
+const handoff = program.command("handoff").description("Work with a Project's Handoffs");
 handoff
     .command("list")
-    .description("List the Workspace's Handoffs")
-    .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+    .description("List the Project's Handoffs")
+    .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--json", "emit the versioned machine envelope")
     .action(async (options) => runHandoffList(options, program.opts()));
 handoff
     .command("show <id>")
     .description("Show a Handoff (add --targets for the binding-scoped per-target manifest)")
-    .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+    .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--targets", "list each target's path, operation, and base semantics")
     .option("--json", "emit the versioned machine envelope")
     .action(async (id, options) => runHandoffShow(id, options, program.opts()));
@@ -223,17 +223,17 @@ sessions
     .option("--scan <json>", "the scan payload as JSON, or @<path> to read it from a file")
     .option("--json", "emit the versioned machine envelope")
     .action(async (options) => runSessionsRecord(options, program.opts()));
-const toolkit = program.command("toolkit").description("Inspect and reconcile the Workspace's toolkit pin");
+const toolkit = program.command("toolkit").description("Inspect and reconcile the Project's toolkit pin");
 toolkit
     .command("status")
     .description("Compare the cloud pin against .nustack/workspace.json and nustack.service.json (F-026)")
-    .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+    .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--json", "emit the versioned machine envelope")
     .action(async (options) => runToolkitStatus(options, program.opts()));
 toolkit
     .command("reconcile")
     .description("Preview and apply the deterministic toolkit repair (no User content is touched)")
-    .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+    .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--yes", "apply the deterministic preview without prompting")
     .option("--json", "emit the versioned machine envelope")
     .action(async (options) => runToolkitReconcile(options, program.opts()));
@@ -253,14 +253,14 @@ agentHook
     .action(async () => runAgentHookRemove());
 function describeError(error) {
     const directCode = error?.code;
-    if (directCode === "WORKSPACE_CONTEXT_MISSING") {
-        return "no Workspace in context — run inside a bound repository (`.nustack/workspace.json`) or pass `--workspace <id>`.";
+    if (directCode === "PROJECT_CONTEXT_MISSING") {
+        return "no Project in context — run inside a bound repository (`.nustack/workspace.json`) or pass `--project <id>`.";
     }
     if (directCode === "ORGANIZATION_CONTEXT_MISSING") {
         return "no Organization in context — run `nustack organization use <id>` or pass `--organization <id>`.";
     }
     if (directCode === "TOOLKIT_INCOMPATIBLE") {
-        return "the installed toolkit is incompatible with the Workspace's cloud pin — run `nustack toolkit reconcile`.";
+        return "the installed toolkit is incompatible with the Project's cloud pin — run `nustack toolkit reconcile`.";
     }
     const cause = error?.cause;
     const code = cause?.code;

package/dist/lib/etna/profile.js

@@ -1,17 +1,17 @@
-import { getWorkspace } from "../nustack_client.js";
+import { getProject } from "../nustack_client.js";
 export class ToolkitProfileUnavailableError extends Error {
-    workspaceId;
-    constructor(workspaceId) {
-        super("The Workspace summary did not project a Toolkit Profile pin — the owning server plan must expose it on GET /api/v2/workspaces/{workspaceId}.");
+    projectId;
+    constructor(projectId) {
+        super("The Project summary did not project a Toolkit Profile pin — the owning server plan must expose it on GET /api/v2/projects/{projectId}.");
         this.name = "ToolkitProfileUnavailableError";
-        this.workspaceId = workspaceId;
+        this.projectId = projectId;
     }
 }
-export async function fetchToolkitProfile(baseUrl, accessToken, workspaceId) {
-    const workspace = await getWorkspace(baseUrl, accessToken, workspaceId);
-    const toolkit = workspace.toolkit;
+export async function fetchToolkitProfile(baseUrl, accessToken, projectId) {
+    const project = await getProject(baseUrl, accessToken, projectId);
+    const toolkit = project.toolkit;
     if (!toolkit || typeof toolkit.name !== "string" || typeof toolkit.version !== "string") {
-        throw new ToolkitProfileUnavailableError(workspaceId);
+        throw new ToolkitProfileUnavailableError(projectId);
     }
     return {
         name: toolkit.name,

package/dist/lib/etna/reconcile.js

@@ -1,4 +1,4 @@
-import { writeWorkspaceManifests, readWorkspaceManifests, diagnoseManifests, } from "../onboarding/manifest_writer.js";
+import { writeProjectManifests, readProjectManifests, diagnoseManifests, } from "../onboarding/manifest_writer.js";
 import { serializeProfileForBinding } from "./profile.js";
 import { updateBindingEtnaProfile } from "../local_store/bindings.js";
 export function parseRecordedToolkit(binding) {
@@ -35,16 +35,16 @@ export function toolkitCompatibility(binding, cloud) {
     return { compatible: true, blocksWrites: false, reason: null };
 }
 export async function buildReconcilePlan(root, binding, cloud) {
-    const manifests = await readWorkspaceManifests(root);
+    const manifests = await readProjectManifests(root);
     const cloudId = { name: cloud.name, version: cloud.version };
-    const diagnosis = diagnoseManifests(cloudId, manifests.workspaceManifest?.toolkit ?? null, manifests.serviceToolkit);
+    const diagnosis = diagnoseManifests(cloudId, manifests.projectManifest?.toolkit ?? null, manifests.serviceToolkit);
     const changes = [];
-    const workspace = manifests.workspaceManifest?.toolkit;
-    if (workspace) {
-        pushIf(changes, ".nustack/workspace.json", "toolkit.name", workspace.name, cloud.name);
-        pushIf(changes, ".nustack/workspace.json", "toolkit.version", workspace.version, cloud.version);
-        pushIf(changes, ".nustack/workspace.json", "toolkit.rendererVersion", workspace.rendererVersion, cloud.rendererVersion);
-        pushIf(changes, ".nustack/workspace.json", "toolkit.placementMapVersion", workspace.placementMapVersion, cloud.placementMapVersion);
+    const project = manifests.projectManifest?.toolkit;
+    if (project) {
+        pushIf(changes, ".nustack/workspace.json", "toolkit.name", project.name, cloud.name);
+        pushIf(changes, ".nustack/workspace.json", "toolkit.version", project.version, cloud.version);
+        pushIf(changes, ".nustack/workspace.json", "toolkit.rendererVersion", project.rendererVersion, cloud.rendererVersion);
+        pushIf(changes, ".nustack/workspace.json", "toolkit.placementMapVersion", project.placementMapVersion, cloud.placementMapVersion);
     }
     const svc = manifests.serviceToolkit;
     if (svc) {
@@ -63,8 +63,8 @@ function pushIf(changes, file, field, from, to) {
         changes.push({ file, field, from, to });
 }
 export async function applyReconcile(store, bindingId, root, identity, cloud) {
-    await writeWorkspaceManifests(root, {
-        workspaceId: identity.workspaceId,
+    await writeProjectManifests(root, {
+        projectId: identity.projectId,
         organizationId: identity.organizationId,
         toolkit: {
             name: cloud.name,

package/dist/lib/git-sync/core/engine.js

@@ -10,7 +10,7 @@ const DEFAULT_HEARTBEAT_MS = 30_000;
 export function observeBinding(binding) {
     const base = {
         bindingId: binding.id,
-        workspaceId: binding.workspaceId,
+        projectId: binding.projectId,
         boundBranch: binding.boundBranch,
         status: binding.status,
         resolved: false,
@@ -18,7 +18,7 @@ export function observeBinding(binding) {
         operationState: "unknown",
         headCommitId: null,
         lastProcessedCommitId: binding.lastProcessedCommitId,
-        lastAppliedWorkspaceSequence: binding.lastAppliedWorkspaceSequence,
+        lastAppliedProjectSequence: binding.lastAppliedProjectSequence,
         pendingCommitCount: 0,
     };
     let repo;
@@ -209,12 +209,12 @@ export function createSyncEngine(options) {
             safeEmit({
                 event: "binding_status",
                 bindingId: observation.bindingId,
-                workspaceId: observation.workspaceId,
+                projectId: observation.projectId,
                 boundBranch: observation.boundBranch,
                 status: observation.status,
                 headCommitId: observation.headCommitId,
                 lastProcessedCommitId: observation.lastProcessedCommitId,
-                lastAppliedWorkspaceSequence: observation.lastAppliedWorkspaceSequence,
+                lastAppliedProjectSequence: observation.lastAppliedProjectSequence,
                 pendingCommitCount: observation.pendingCommitCount,
             });
         }

package/dist/lib/git-sync/inbound/apply_commit.js

@@ -11,12 +11,12 @@ import { readTargetState } from "./content_decision.js";
 import { computeStateFingerprint } from "./state_fingerprint.js";
 import { persistRecoveryBundle } from "../recovery/store.js";
 export const NUSTACK_SYNC_IDENTITY = { name: "NuStack Sync", email: "sync@nustack.local" };
-export function buildCommitMessage(handoffId, workspaceId, approvedByUserId) {
+export function buildCommitMessage(handoffId, projectId, approvedByUserId) {
     const lines = [
         `nustack(sync): apply cloud handoff ${handoffId.slice(0, 12)}`,
         "",
         `NuStack-Handoff: ${handoffId}`,
-        `NuStack-Workspace: ${workspaceId}`,
+        `NuStack-Project: ${projectId}`,
         "NuStack-Origin: cloud",
     ];
     if (approvedByUserId)
@@ -186,7 +186,7 @@ export async function applyCommit(input) {
         if (target.operation === "upsert" && target.blobPath)
             bytesByPath.set(target.path, readFileSync(target.blobPath));
     }
-    const message = buildCommitMessage(handoffId, manifest.workspaceId, approved ? (input.approvedByUserId ?? null) : null);
+    const message = buildCommitMessage(handoffId, manifest.projectId, approved ? (input.approvedByUserId ?? null) : null);
     const built = buildCommit(repo, oldHead, targets, bytesByPath, message, {
         authorName: NUSTACK_SYNC_IDENTITY.name,
         authorEmail: NUSTACK_SYNC_IDENTITY.email,

package/dist/lib/git-sync/inbound/approval.js

@@ -12,7 +12,7 @@ export const APPROVAL_RECOVERY_NOTE = "Approving overwrites the listed paths. Gi
 export function toDownloadBinding(binding) {
     return {
         id: binding.id,
-        workspaceId: binding.workspaceId,
+        projectId: binding.projectId,
         boundBranch: binding.boundBranch,
         repositoryRoot: binding.repositoryRoot,
         etnaProfileJson: binding.etnaProfileJson,

package/dist/lib/git-sync/inbound/download.js

@@ -27,7 +27,7 @@ function recomputeManifestHash(manifest) {
     const core = {
         schemaVersion: 1,
         handoffId: manifest.handoffId,
-        workspaceId: manifest.workspaceId,
+        projectId: manifest.projectId,
         documentSetVersionId: manifest.documentSetVersionId,
         toolkit: {
             name: manifest.toolkit.name,
@@ -62,7 +62,7 @@ function toolkitTechnicalWait(binding, manifest) {
         return "harness_incompatible";
     return null;
 }
-function crossWorkspaceMarker(body, workspaceId) {
+function crossProjectMarker(body, projectId) {
     if (!body.startsWith("---\n"))
         return false;
     const secondLineEnd = body.indexOf("\n", 4);
@@ -71,8 +71,8 @@ function crossWorkspaceMarker(body, workspaceId) {
         return false;
     const fence = body.indexOf("\n---", 4);
     const block = body.slice(0, fence === -1 ? body.length : fence);
-    const match = /\n\s*workspace_id:\s*(\S+)/.exec(block);
-    return match !== null && match[1] !== workspaceId;
+    const match = /\n\s*project_id:\s*(\S+)/.exec(block);
+    return match !== null && match[1] !== projectId;
 }
 function isUnsupportedMedia(bytes) {
     for (const byte of bytes)
@@ -136,8 +136,8 @@ export async function downloadHandoff(deps, binding, handoffId) {
     const downloadContent = deps.downloadContent ?? downloadTargetContent;
     const fetchWhitelist = deps.fetchWhitelist ?? fetchSyncWhitelist;
     const manifest = await fetchManifest(deps.baseUrl, deps.accessToken, { handoffId, bindingId: binding.id });
-    if (manifest.workspaceId !== binding.workspaceId)
-        return reject("workspace_mismatch", "manifest Workspace does not match the binding");
+    if (manifest.projectId !== binding.projectId)
+        return reject("project_mismatch", "manifest Project does not match the binding");
     if (recomputeManifestHash(manifest) !== manifest.manifestSha256) {
         return reject("manifest_hash", "manifest hash does not verify");
     }
@@ -207,8 +207,8 @@ export async function downloadHandoff(deps, binding, handoffId) {
         const actualSha256 = sha256(bytes);
         if (actualSha256 !== target.targetSha256)
             return reject("hash_mismatch", "downloaded body hash does not match the manifest");
-        if (crossWorkspaceMarker(new TextDecoder().decode(bytes), binding.workspaceId)) {
-            return reject("cross_workspace_marker", "target body declares a foreign Workspace id");
+        if (crossProjectMarker(new TextDecoder().decode(bytes), binding.projectId)) {
+            return reject("cross_project_marker", "target body declares a foreign Project id");
         }
         const blobPath = blobCachePath(actualSha256);
         await mkdirSecure(path.dirname(blobPath));

package/dist/lib/git-sync/inbound/event_sync.js

@@ -1,6 +1,6 @@
 import { getBindingById, updateBindingCursor } from "../../local_store/bindings.js";
 import { hasCloudOriginForHandoff } from "../../local_store/commit_origins.js";
-import { cacheWorkspaceEvents, listCachedWorkspaceEvents, pruneWorkspaceEvents, } from "../../local_store/workspace_events_cache.js";
+import { cacheProjectEvents, listCachedProjectEvents, pruneProjectEvents, } from "../../local_store/project_events_cache.js";
 import { getApplication, upsertApplication, transitionApplicationState, listApplicationsForBinding, } from "../../local_store/handoff_applications.js";
 import { fetchBindingEvents, acknowledgeBindingCursor } from "../../nustack_client.js";
 const PENDING_STATES = new Set([
@@ -29,7 +29,7 @@ function supersedeOlderApplications(store, bindingId, newerHandoffId) {
     return flipped;
 }
 function handoffIdOf(event) {
-    return event.type === "version.created" && event.entity.kind === "workspace_document_version" ? event.entity.id : null;
+    return event.type === "version.created" && event.entity.kind === "project_document_version" ? event.entity.id : null;
 }
 export async function syncBindingEvents(store, deps, bindingId) {
     const binding = getBindingById(store, bindingId);
@@ -40,9 +40,9 @@ export async function syncBindingEvents(store, deps, bindingId) {
         createdHandoffs: [],
         supersededHandoffs: [],
         acknowledgedOwnOrigin: [],
-        highestSequence: binding.lastAppliedWorkspaceSequence,
+        highestSequence: binding.lastAppliedProjectSequence,
     };
-    let after = binding.lastAppliedWorkspaceSequence;
+    let after = binding.lastAppliedProjectSequence;
     for (;;) {
         const events = await fetchEvents(deps.baseUrl, deps.accessToken, {
             bindingId,
@@ -51,8 +51,8 @@ export async function syncBindingEvents(store, deps, bindingId) {
         });
         if (events.length === 0)
             break;
-        cacheWorkspaceEvents(store, bindingId, events.map((event) => ({
-            workspaceSequence: event.sequence,
+        cacheProjectEvents(store, bindingId, events.map((event) => ({
+            projectSequence: event.sequence,
             eventType: event.type,
             payloadJson: JSON.stringify({ entity: event.entity, payload: event.payload }),
         })));
@@ -81,7 +81,7 @@ export async function syncBindingEvents(store, deps, bindingId) {
         if (events.length < EVENTS_PAGE_LIMIT)
             break;
     }
-    pruneWorkspaceEvents(store, bindingId);
+    pruneProjectEvents(store, bindingId);
     return result;
 }
 function cachedHandoffId(eventType, payloadJson) {
@@ -100,9 +100,9 @@ export async function advanceContiguousCursor(store, deps, bindingId) {
     if (!binding)
         throw new Error(`No binding "${bindingId}" on this machine.`);
     const acknowledgeCursor = deps.acknowledgeCursor ?? acknowledgeBindingCursor;
-    let cursor = binding.lastAppliedWorkspaceSequence;
-    for (const event of listCachedWorkspaceEvents(store, bindingId)) {
-        if (event.workspaceSequence <= cursor)
+    let cursor = binding.lastAppliedProjectSequence;
+    for (const event of listCachedProjectEvents(store, bindingId)) {
+        if (event.projectSequence <= cursor)
             continue;
         const handoffId = cachedHandoffId(event.eventType, event.payloadJson);
         if (handoffId !== null) {
@@ -110,10 +110,10 @@ export async function advanceContiguousCursor(store, deps, bindingId) {
             if (!application || PENDING_STATES.has(application.state))
                 break;
         }
-        cursor = event.workspaceSequence;
+        cursor = event.projectSequence;
     }
-    if (cursor > binding.lastAppliedWorkspaceSequence) {
-        updateBindingCursor(store, bindingId, { lastAppliedWorkspaceSequence: cursor });
+    if (cursor > binding.lastAppliedProjectSequence) {
+        updateBindingCursor(store, bindingId, { lastAppliedProjectSequence: cursor });
         try {
             await acknowledgeCursor(deps.baseUrl, deps.accessToken, { bindingId, lastAppliedSequence: cursor });
         }

package/dist/lib/git-sync/inbound/notification.js

@@ -7,7 +7,7 @@ export function renderCommitNotification(application, changedPaths) {
         lines.push(`  commit: ${application.generatedCommitId.slice(0, 12)}`);
     if (changedPaths.length > 0)
         lines.push(`  changed: ${changedPaths.join(", ")}`);
-    lines.push(`  View: nustack workspace sync pending    Undo: nustack workspace sync undo ${application.handoffId}`);
+    lines.push(`  View: nustack project sync pending    Undo: nustack project sync undo ${application.handoffId}`);
     if (application.recoveryBundleId) {
         lines.push(`  Recovery bundle ${application.recoveryBundleId} holds your pre-approval content until it expires.`);
     }

package/dist/lib/git-sync/outbound/extraction.js

@@ -43,11 +43,11 @@ function readBlob(repo, blobId) {
 export function isCommitTreeReadable(repo, commitId) {
     return runGit(repo.repositoryRoot, ["cat-file", "-e", `${commitId}^{tree}`], { allowFailure: true }).exitCode === 0;
 }
-export function extractCommitDelta(repo, commitId, whitelist, workspaceId, direction = "local_to_cloud") {
+export function extractCommitDelta(repo, commitId, whitelist, projectId, direction = "local_to_cloud") {
     const parentCommitId = readRefCommit(repo, `${commitId}^1`);
-    return computeTreeDelta(repo, parentCommitId, commitId, whitelist, workspaceId, direction);
+    return computeTreeDelta(repo, parentCommitId, commitId, whitelist, projectId, direction);
 }
-export function computeTreeDelta(repo, baseCommitId, targetCommitId, whitelist, workspaceId, direction = "local_to_cloud") {
+export function computeTreeDelta(repo, baseCommitId, targetCommitId, whitelist, projectId, direction = "local_to_cloud") {
     const diffArgs = ["diff-tree", "-r", "-z", "--no-renames", "--no-commit-id"];
     const args = baseCommitId === null ? [...diffArgs, "--root", targetCommitId] : [...diffArgs, baseCommitId, targetCommitId];
     const { stdout } = runGit(repo.repositoryRoot, args);
@@ -81,7 +81,7 @@ export function computeTreeDelta(repo, baseCommitId, targetCommitId, whitelist,
             bytes: blob.bytes,
             byteSize: blob.byteSize,
             entry: match.entry,
-            workspaceId,
+            projectId,
         });
         if (!validation.ok)
             return { ok: false, code: validation.code, path };