@thinkingai/ae-cli 6.1.24 → 6.1.26

package/dist/{personal-semantic-preference-5C3WUXFI.js → personal-semantic-preference-QECDPHND.js}

@@ -1,16 +1,16 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   createCapabilityCommand
-} from "./chunk-CCS66K4K.js";
-import "./chunk-HFGZGYCG.js";
+} from "./chunk-KAEHZZH4.js";
+import "./chunk-EOYSKMXN.js";
 import {
   registerCapabilityGatewayRoute
 } from "./chunk-KPQY44JQ.js";
-import "./chunk-DX5CDO34.js";
+import "./chunk-KFNMQTZI.js";
 import "./chunk-Y74WTIKJ.js";
-import "./chunk-7XGFSUOM.js";
-import "./chunk-7FTTULED.js";
-import "./chunk-MAPZ7VB6.js";
+import "./chunk-GIK6EDUG.js";
+import "./chunk-UQ77JXYH.js";
+import "./chunk-WNGFSIOB.js";
 
 // src/commands/personal-semantic-preference/shared.ts
 function createPersonalSemanticPreferenceCommand(config) {
@@ -24,16 +24,22 @@ function optionalString(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
 }
-function optionalKeywords(ctx) {
-  if (ctx.str("keywords") === "") {
+function optionalNumber(ctx, name) {
+  return ctx.optionalNum(name);
+}
+function optionalJsonStringArray(ctx, name, flag) {
+  if (ctx.str(name) === "") {
     return void 0;
   }
-  const value = ctx.json("keywords");
+  const value = ctx.json(name);
   if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    throw new Error("--keywords must be a JSON array of strings.");
+    throw new Error(`${flag} must be a JSON array of strings.`);
   }
   return value;
 }
+function optionalKeywords(ctx) {
+  return optionalJsonStringArray(ctx, "keywords", "--keywords");
+}
 function optionalResourceRefs(ctx) {
   if (ctx.str("resource-refs") === "") {
     return void 0;
@@ -161,12 +167,14 @@ var personalSemanticPreferenceGet = createPersonalSemanticPreferenceCommand({
   flags: [
     { name: "project-id", type: "number", required: true, desc: "Numeric project ID.", alias: "p", min: 1 },
     { name: "id", type: "string", required: true, desc: "Preference ID returned by list/add." },
+    { name: "title", type: "string", required: true, desc: "Preference title copied from list output for telemetry only.", minLength: 1, maxLength: 255 },
     { name: "mark-used", type: "boolean", desc: "Count this preference as adopted and update its usage heat." }
   ],
   risk: "read",
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     id: ctx.str("id"),
+    title: ctx.str("title"),
     mark_used: ctx.bool("mark-used")
   })
 });
@@ -187,6 +195,103 @@ var personalSemanticPreferenceList = createPersonalSemanticPreferenceCommand({
   })
 });
 
+// src/commands/personal-semantic-preference/review-list.ts
+var REVIEW_STATUSES = ["none", "pending", "adopted", "rejected"];
+var CONTEXT_TYPES = ["preference", "asset_context", "experience", "background"];
+var personalSemanticPreferenceReviewList = createPersonalSemanticPreferenceCommand({
+  resource: "",
+  command: "review-list",
+  capabilityId: "business_semantics.personal_context.review_list",
+  description: "List all project personal semantic preferences for admin review.",
+  flags: [
+    { name: "project-id", type: "number", required: true, desc: "Numeric project ID.", alias: "p", min: 1 },
+    { name: "project-review-status", type: "string", desc: "none | pending | adopted | rejected." },
+    { name: "owner", type: "string", desc: "Owner selector: user name, login name, or user ID. open_id is not accepted." },
+    { name: "context-type", type: "string", desc: "preference | asset_context | experience | background." },
+    { name: "keyword", type: "string", desc: "Match title, summary, content, or keywords." },
+    { name: "limit", type: "number", desc: "Page size. Defaults to 50.", min: 1, max: 200 },
+    { name: "offset", type: "number", desc: "Zero-based page offset.", min: 0 }
+  ],
+  risk: "read",
+  validate: (ctx) => {
+    const status = ctx.str("project-review-status");
+    if (status !== "" && !REVIEW_STATUSES.includes(status)) {
+      throw new Error(`--project-review-status must be one of: ${REVIEW_STATUSES.join(", ")}.`);
+    }
+    const contextType = ctx.str("context-type");
+    if (contextType !== "" && !CONTEXT_TYPES.includes(contextType)) {
+      throw new Error(`--context-type must be one of: ${CONTEXT_TYPES.join(", ")}.`);
+    }
+  },
+  buildInput: (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    project_review_status: optionalString(ctx, "project-review-status"),
+    owner: optionalString(ctx, "owner"),
+    context_type: optionalString(ctx, "context-type"),
+    keyword: optionalString(ctx, "keyword"),
+    limit: optionalNumber(ctx, "limit"),
+    offset: optionalNumber(ctx, "offset")
+  })
+});
+
+// src/commands/personal-semantic-preference/review.ts
+var ACTIONS = ["adopt", "reject"];
+var personalSemanticPreferenceReview = createPersonalSemanticPreferenceCommand({
+  resource: "",
+  command: "review",
+  capabilityId: "business_semantics.personal_context.review",
+  description: "Adopt or reject personal semantic preferences, including unsubmitted ones, for future project KB refresh.",
+  flags: [
+    { name: "project-id", type: "number", required: true, desc: "Numeric project ID.", alias: "p", min: 1 },
+    { name: "ids", type: "json", required: true, desc: "JSON array of preference IDs from review-list." },
+    { name: "action", type: "string", required: true, desc: "adopt | reject." },
+    { name: "project-review-note", type: "string", desc: "Optional reviewer note.", maxLength: 1e3 },
+    { name: "request-id", type: "string", desc: "Optional idempotency key; generated when omitted.", maxLength: 128 }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    const action = ctx.str("action");
+    if (!ACTIONS.includes(action)) {
+      throw new Error(`--action must be one of: ${ACTIONS.join(", ")}.`);
+    }
+    const ids = optionalJsonStringArray(ctx, "ids", "--ids");
+    if (!ids || ids.length === 0) {
+      throw new Error("--ids must contain at least one preference ID.");
+    }
+    if (ids.length > 100) {
+      throw new Error("--ids must contain at most 100 preference IDs.");
+    }
+  },
+  buildInput: (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    ids: optionalJsonStringArray(ctx, "ids", "--ids"),
+    action: ctx.str("action"),
+    project_review_note: optionalString(ctx, "project-review-note"),
+    request_id: optionalString(ctx, "request-id")
+  })
+});
+
+// src/commands/personal-semantic-preference/submit.ts
+var personalSemanticPreferenceSubmit = createPersonalSemanticPreferenceCommand({
+  resource: "",
+  command: "submit",
+  capabilityId: "business_semantics.personal_context.submit",
+  description: "Submit one personal semantic preference for project semantic review.",
+  flags: [
+    { name: "project-id", type: "number", required: true, desc: "Numeric project ID.", alias: "p", min: 1 },
+    { name: "id", type: "string", required: true, desc: "Preference ID returned by list/add." },
+    { name: "project-review-note", type: "string", desc: "Optional note for the reviewer.", maxLength: 1e3 },
+    { name: "request-id", type: "string", desc: "Optional idempotency key; generated when omitted.", maxLength: 128 }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    id: ctx.str("id"),
+    project_review_note: optionalString(ctx, "project-review-note"),
+    request_id: optionalString(ctx, "request-id")
+  })
+});
+
 // src/commands/personal-semantic-preference/update.ts
 var personalSemanticPreferenceUpdate = createPersonalSemanticPreferenceCommand({
   resource: "",
@@ -233,7 +338,10 @@ var commands = [
   personalSemanticPreferenceGet,
   personalSemanticPreferenceAdd,
   personalSemanticPreferenceUpdate,
-  personalSemanticPreferenceDelete
+  personalSemanticPreferenceDelete,
+  personalSemanticPreferenceSubmit,
+  personalSemanticPreferenceReviewList,
+  personalSemanticPreferenceReview
 ];
 var personal_semantic_preference_default = commands;
 export {

package/dist/project-semantic-Z4QAMBWF.js

@@ -0,0 +1,356 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  assertOutputPathAvailable,
+  downloadAnalysisArtifact,
+  withAsyncArtifactLifecycle
+} from "./chunk-XCHAYMSF.js";
+import {
+  CapabilityGatewayError,
+  dryRunCapability,
+  executeCapabilityWithEnvelope,
+  validateCapability
+} from "./chunk-EOYSKMXN.js";
+import {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain
+} from "./chunk-KPQY44JQ.js";
+import "./chunk-KFNMQTZI.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-GIK6EDUG.js";
+import "./chunk-UQ77JXYH.js";
+import "./chunk-WNGFSIOB.js";
+
+// src/commands/project-semantic/asset-package/materializer.ts
+import { createHash, randomBytes } from "crypto";
+import { createReadStream } from "fs";
+import {
+  appendFile,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { createInterface } from "readline";
+import { createGunzip } from "zlib";
+import { basename, dirname, resolve } from "path";
+var MAX_COMPRESSED_BYTES = 64 * 1024 * 1024;
+var MAX_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+var MAX_RECORDS = 2e5;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+var SUPPORTED_SCHEMA_VERSIONS = /* @__PURE__ */ new Set(["1.0", "3.0"]);
+var REQUIRED_FILES = [
+  "manifest.json",
+  "indexes/work-units.jsonl",
+  "indexes/asset-directory.jsonl",
+  "indexes/coverage-batches.jsonl",
+  "indexes/definition-families.jsonl",
+  "indexes/governance-coverage.jsonl",
+  "catalog/published.jsonl",
+  "catalog/active-candidates.jsonl",
+  "catalog/rejected-candidates.jsonl"
+];
+async function preflightAssetPackageOutput(args) {
+  await assertOutputPathAvailable(args.output, args.force);
+}
+async function materializeProjectSemanticAssetPackage(args) {
+  const descriptor = packageDescriptor(args.finalDescriptor);
+  const output = resolve(args.output);
+  const parent = dirname(output);
+  const nonce = `${process.pid}-${randomBytes(6).toString("hex")}`;
+  const staging = resolve(parent, `.${basename(output)}.staging-${nonce}`);
+  const archive = resolve(parent, `.${basename(output)}.archive-${nonce}.jsonl.gz`);
+  const backup = resolve(parent, `.${basename(output)}.backup-${nonce}`);
+  let movedExisting = false;
+  await assertOutputPathAvailable(output, args.force, {
+    run_id: args.runId,
+    artifact_id: args.artifactId
+  });
+  await mkdir(parent, { recursive: true });
+  await mkdir(staging, { recursive: false });
+  try {
+    const download = await downloadAnalysisArtifact(
+      args.ctx.host(),
+      args.runId,
+      args.artifactId,
+      archive,
+      { signal: args.signal, ensureReady: false }
+    );
+    if (download.bytes > MAX_COMPRESSED_BYTES) {
+      throw packageError("Asset package archive exceeds 64 MiB.", "ASSET_PACKAGE_ARCHIVE_TOO_LARGE");
+    }
+    const materialized = await materializeArchive(archive, staging, descriptor);
+    if (args.force && await exists(output)) {
+      await rename(output, backup);
+      movedExisting = true;
+    }
+    await rename(staging, output);
+    if (movedExisting) {
+      await rm(backup, { recursive: true, force: true });
+      movedExisting = false;
+    }
+    return {
+      ...args.finalDescriptor,
+      output_path: output,
+      archive_bytes: download.bytes,
+      record_count: materialized.recordCount,
+      uncompressed_bytes: materialized.uncompressedBytes
+    };
+  } catch (error) {
+    if (movedExisting) {
+      await rename(backup, output).catch(() => void 0);
+    }
+    throw error;
+  } finally {
+    await rm(archive, { force: true }).catch(() => void 0);
+    await rm(staging, { recursive: true, force: true }).catch(() => void 0);
+    if (!movedExisting) {
+      await rm(backup, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+}
+async function materializeArchive(archive, staging, descriptor) {
+  const compressed = await stat(archive);
+  if (compressed.size > MAX_COMPRESSED_BYTES) {
+    throw packageError("Asset package archive exceeds 64 MiB.", "ASSET_PACKAGE_ARCHIVE_TOO_LARGE");
+  }
+  const digest = createHash("sha256");
+  const lines = createInterface({
+    input: createReadStream(archive).pipe(createGunzip()),
+    crlfDelay: Infinity
+  });
+  let recordCount = 0;
+  let uncompressedBytes = 0;
+  let manifest;
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    uncompressedBytes += Buffer.byteLength(line, "utf8") + 1;
+    if (uncompressedBytes > MAX_UNCOMPRESSED_BYTES) {
+      throw packageError(
+        "Asset package archive exceeds 512 MiB after decompression.",
+        "ASSET_PACKAGE_ARCHIVE_TOO_LARGE"
+      );
+    }
+    recordCount += 1;
+    if (recordCount > MAX_RECORDS) {
+      throw packageError("Asset package has too many records.", "ASSET_PACKAGE_RECORD_LIMIT_EXCEEDED");
+    }
+    digest.update(line, "utf8");
+    digest.update("\n", "utf8");
+    const record = parseRecord(line);
+    const target = resolveRecordPath(staging, record.path);
+    await mkdir(dirname(target), { recursive: true });
+    const content = `${JSON.stringify(record.content)}
+`;
+    if (record.append) {
+      await appendFile(target, content, "utf8");
+    } else {
+      await writeFile(target, content, { encoding: "utf8", flag: "wx" });
+    }
+    if (record.path === "manifest.json") {
+      manifest = asObject(record.content);
+    }
+  }
+  const actualHash = digest.digest("hex");
+  if (actualHash !== descriptor.snapshotHash) {
+    throw packageError(
+      `Asset package content hash mismatch: expected ${descriptor.snapshotHash}, received ${actualHash}.`,
+      "ASSET_PACKAGE_HASH_MISMATCH"
+    );
+  }
+  if (!manifest || !Number.isInteger(Number(manifest.project_id))) {
+    throw packageError("Asset package manifest is missing project identity.", "ASSET_PACKAGE_MANIFEST_INVALID");
+  }
+  const schemaVersion = typeof manifest.schema_version === "string" ? manifest.schema_version : "";
+  if (!SUPPORTED_SCHEMA_VERSIONS.has(schemaVersion)) {
+    throw packageError(
+      `Project semantic asset package schema ${[...SUPPORTED_SCHEMA_VERSIONS].join(" or ")} is required.`,
+      "ASSET_PACKAGE_VERSION_MISMATCH"
+    );
+  }
+  for (const required of REQUIRED_FILES) {
+    if (!await exists(resolve(staging, required))) {
+      throw packageError(`Asset package is missing required file ${required}.`, "ASSET_PACKAGE_MANIFEST_INVALID");
+    }
+  }
+  await verifyDetailLocators(staging, schemaVersion);
+  await writeFile(resolve(staging, ".asset-package.json"), JSON.stringify({
+    snapshot_id: descriptor.snapshotId,
+    snapshot_hash: descriptor.snapshotHash,
+    schema_version: schemaVersion,
+    package_kind: typeof manifest.package_kind === "string" ? manifest.package_kind : "project_semantic_asset_package",
+    company_id: Number(manifest.company_id),
+    project_id: Number(manifest.project_id),
+    project_name: typeof manifest.project_name === "string" ? manifest.project_name : void 0,
+    record_count: recordCount,
+    asset_scope: typeof manifest.asset_scope === "string" ? manifest.asset_scope : "governed",
+    exported_asset_count: Number(manifest.exported_asset_count ?? manifest.authenticated_asset_count),
+    authenticated_asset_count: Number(manifest.authenticated_asset_count),
+    unauthenticated_asset_count: Number(manifest.unauthenticated_asset_count ?? 0),
+    truncated: Boolean(manifest.truncated),
+    counts: manifest.counts,
+    filter_policy: manifest.filter_policy
+  }, null, 2), "utf8");
+  return { recordCount, uncompressedBytes };
+}
+async function verifyDetailLocators(root, schemaVersion) {
+  const directory = await readFile(resolve(root, "indexes/asset-directory.jsonl"), "utf8");
+  for (const line of directory.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const row = asObject(JSON.parse(line));
+    if (!row || row.record_type === "header") continue;
+    const detail = await verifyContentLocator(root, row.detail_locator, "Detail");
+    await verifyContentLocator(root, detail.raw_locator, "Raw detail", { skipHash: schemaVersion === "3.0" });
+  }
+}
+async function verifyContentLocator(root, value, label, options = {}) {
+  const locator = asObject(value);
+  if (!locator || typeof locator.path !== "string" || typeof locator.content_hash !== "string" || !SHA256_PATTERN.test(locator.content_hash)) {
+    throw packageError(
+      `Asset package contains an invalid ${label.toLowerCase()} locator.`,
+      "ASSET_PACKAGE_MANIFEST_INVALID"
+    );
+  }
+  const target = resolveRecordPath(root, locator.path);
+  if (!await exists(target)) {
+    throw packageError(`Asset package is missing ${label.toLowerCase()} file ${locator.path}.`, "ASSET_PACKAGE_MANIFEST_INVALID");
+  }
+  const content = asObject(JSON.parse(await readFile(target, "utf8")));
+  if (!content) {
+    throw packageError(`${label} file is not a JSON object: ${locator.path}.`, "ASSET_PACKAGE_MANIFEST_INVALID");
+  }
+  if (!options.skipHash) {
+    const actualHash = createHash("sha256").update(JSON.stringify(content), "utf8").digest("hex");
+    if (actualHash !== locator.content_hash) {
+      throw packageError(`${label} content hash mismatch for ${locator.path}.`, "ASSET_PACKAGE_HASH_MISMATCH");
+    }
+  }
+  return content;
+}
+function parseRecord(line) {
+  const value = JSON.parse(line);
+  const record = asObject(value);
+  if (!record || typeof record.path !== "string") {
+    throw packageError("Asset package record is missing path.", "ASSET_PACKAGE_RECORD_INVALID");
+  }
+  if (!Object.prototype.hasOwnProperty.call(record, "content")) {
+    throw packageError("Asset package record is missing content.", "ASSET_PACKAGE_RECORD_INVALID");
+  }
+  return {
+    path: record.path,
+    append: Boolean(record.append),
+    content: record.content
+  };
+}
+function resolveRecordPath(root, path) {
+  if (path.startsWith("/") || path.includes("\0")) {
+    throw packageError(`Invalid asset package path: ${path}`, "ASSET_PACKAGE_PATH_INVALID");
+  }
+  const target = resolve(root, path);
+  const normalizedRoot = `${resolve(root)}/`;
+  if (!target.startsWith(normalizedRoot)) {
+    throw packageError(`Invalid asset package path: ${path}`, "ASSET_PACKAGE_PATH_INVALID");
+  }
+  return target;
+}
+function packageDescriptor(descriptor) {
+  const snapshotHash = stringValue(descriptor.snapshot_hash, "snapshot_hash").toLowerCase();
+  if (!SHA256_PATTERN.test(snapshotHash)) {
+    throw packageError("Asset package export returned invalid snapshot_hash.", "ASSET_PACKAGE_DESCRIPTOR_INVALID");
+  }
+  return {
+    snapshotId: typeof descriptor.snapshot_id === "string" ? descriptor.snapshot_id : void 0,
+    snapshotHash
+  };
+}
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function stringValue(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw packageError(`${label} must be a non-empty string.`, "ASSET_PACKAGE_DESCRIPTOR_INVALID");
+  }
+  return value;
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function packageError(message, code) {
+  return new CapabilityGatewayError(message, code, 422);
+}
+
+// src/commands/project-semantic/asset-package/export.ts
+var ASSET_PACKAGE_EXPORT_CAPABILITY = "business_semantics.asset_package.export";
+var ASSET_SCOPES = /* @__PURE__ */ new Set(["governed", "collaborative", "all_visible"]);
+var GATEWAY_DOMAIN = "analysis";
+function assetScope(ctx) {
+  const value = ctx.str("asset-scope") || "governed";
+  if (!ASSET_SCOPES.has(value)) {
+    throw new Error("asset-scope must be one of: governed, collaborative, all_visible");
+  }
+  return value;
+}
+var assetPackageExportCommand = {
+  service: "project-semantic",
+  resource: "asset-package",
+  command: "export",
+  description: "Export and materialize a knowledge-ready project asset package for CLI Agent consumption.",
+  helpText: "Requires access to the target project. Explicit asset-package export is independent of automatic knowledge-base discovery.",
+  flags: [
+    { name: "project-id", type: "number", required: true, desc: "Numeric project ID.", alias: "p", min: 1 },
+    {
+      name: "asset-scope",
+      type: "string",
+      required: false,
+      desc: "Asset scope: governed, collaborative, or all_visible. Defaults to governed."
+    }
+  ],
+  risk: "read",
+  validateInput: (ctx) => validateCapability(
+    ctx.host(),
+    resolveGatewayDomain(GATEWAY_DOMAIN, GATEWAY_DOMAIN),
+    ASSET_PACKAGE_EXPORT_CAPABILITY,
+    { project_id: ctx.num("project-id"), asset_scope: assetScope(ctx) }
+  ),
+  dryRun: (ctx) => dryRunCapability(
+    ctx.host(),
+    resolveGatewayDomain(GATEWAY_DOMAIN, GATEWAY_DOMAIN),
+    ASSET_PACKAGE_EXPORT_CAPABILITY,
+    { project_id: ctx.num("project-id"), asset_scope: assetScope(ctx) }
+  ),
+  execute: async (ctx) => {
+    const projectId = ctx.num("project-id");
+    const scope = assetScope(ctx);
+    const response = await executeCapabilityWithEnvelope(
+      ctx.host(),
+      resolveGatewayDomain(GATEWAY_DOMAIN, GATEWAY_DOMAIN),
+      ASSET_PACKAGE_EXPORT_CAPABILITY,
+      { project_id: projectId, asset_scope: scope }
+    );
+    return response.data;
+  }
+};
+var projectSemanticAssetPackageExport = withAsyncArtifactLifecycle(assetPackageExportCommand, {
+  preflightOutput: ({ output, force }) => preflightAssetPackageOutput({ output, force }),
+  materialize: materializeProjectSemanticAssetPackage
+});
+
+// src/commands/project-semantic/index.ts
+registerCapabilityGatewayRoute("project-semantic", {
+  gatewayDomain: "analysis",
+  capabilityPrefixes: ["business_semantics.asset_package"]
+});
+var commands = [
+  projectSemanticAssetPackageExport
+];
+var project_semantic_default = commands;
+export {
+  project_semantic_default as default
+};

package/dist/{sync-O45NXEQY.js → sync-SU33KYX7.js}

@@ -19,10 +19,13 @@ import {
 import {
   assertSkillDocumentSize
 } from "./chunk-T6OSFQZD.js";
+import {
+  assertLegacyWorkspaceCommand
+} from "./chunk-RK6GLDGI.js";
 import {
   require_lib
-} from "./chunk-DVMLWQD4.js";
-import "./chunk-V2NUHPXF.js";
+} from "./chunk-CT7QDJS6.js";
+import "./chunk-S6M42KND.js";
 import {
   TeAgentApiError,
   TeAgentCredentialsError,
@@ -30,16 +33,16 @@ import {
   postSandboxSyncPull,
   postToMainApp,
   uploadToMainApp
-} from "./chunk-HBGADCKA.js";
+} from "./chunk-PLE722AJ.js";
 import {
   printError
-} from "./chunk-DX5CDO34.js";
+} from "./chunk-KFNMQTZI.js";
 import "./chunk-Y74WTIKJ.js";
-import "./chunk-7XGFSUOM.js";
-import "./chunk-7FTTULED.js";
+import "./chunk-GIK6EDUG.js";
+import "./chunk-UQ77JXYH.js";
 import {
   __toESM
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/commands/sync/index.ts
 var import_jszip = __toESM(require_lib(), 1);
@@ -488,8 +491,9 @@ async function runPull(kind) {
   renderResults(pullResultRows(resp));
 }
 function registerSync(program) {
-  program.command("sync").description("Sync Skills / MCPs between current workspace and te-claude main app").option("--direction <direction>", "push | pull (skip interactive direction picker)").option("--include-secrets", "Include MCP env secrets (TOKEN/SECRET/KEY) in push", false).option("--kind <kind>", "skill | mcp | both (skip interactive picker)").action(async (opts) => {
+  program.command("sync").description("Sync Skills / MCPs between a legacy sandbox workspace and te-claude main app").option("--direction <direction>", "push | pull (skip interactive direction picker)").option("--include-secrets", "Include MCP env secrets (TOKEN/SECRET/KEY) in push", false).option("--kind <kind>", "skill | mcp | both (skip interactive picker)").action(async (opts) => {
     try {
+      assertLegacyWorkspaceCommand("sync");
       const direction = await selectDirection(opts.direction);
       const kind = await selectKind(opts.kind);
       if (direction === "push") await runPush(kind, !!opts.includeSecrets);