draftgo-cli 4.0.25 → 4.0.26

package/src/commandRegistry.js

@@ -16,20 +16,14 @@ const commands = [
   { name: 'checkout', run: (dir, args, flags) => require('./commands/checkout')(dir, args, flags) },
   { name: 'refresh', run: (dir, args, flags) => require('./commands/checkout')(dir, args, flags) },
   { name: 'commit', run: (dir, args, flags) => require('./commands/commit')(dir, args, flags) },
-  { name: 'validate', run: (dir, args, flags) => require('./commands/customService').validate(dir, args, flags) },
-  { name: 'test', run: (dir, args, flags) => require('./commands/customService').test(dir, args, flags) },
-  { name: 'publish', run: (dir, args, flags) => require('./commands/customService').publish(dir, args, flags) },
   { name: 'reconcile', run: (dir, args, flags) => require('./commands/reconcile')(dir, args, flags) },
   { name: 'diff', run: (dir, args, flags) => require('./commands/diff')(dir, args, flags) },
   { name: 'conflicts', run: (dir, args, flags) => require('./commands/conflicts')(dir, args, flags) },
   { name: 'conflict', run: (dir, args, flags) => require('./commands/conflict')(dir, args, flags) },
   { name: 'api', run: (dir, args, flags) => require('./commands/api')(dir, args, flags) },
-  { name: 'space', run: (dir, args, flags) => require('./commands/space')(dir, args, flags) },
   { name: 'group', run: (dir, args, flags) => require('./commands/group')(dir, args, flags) },
-  { name: 'grant', run: (dir, args, flags) => require('./commands/grant')(dir, args, flags) },
   { name: 'api-key', run: (dir, args, flags) => require('./commands/apiKey')(dir, args, flags) },
   { name: 'role', run: (dir, args, flags) => require('./commands/role')(dir, args, flags) },
-  { name: 'data-range', run: (dir, args, flags) => require('./commands/dataRange')(dir, args, flags) },
   { name: 'delete', run: (dir, args, flags) => require('./commands/delete')(dir, args, flags) },
   { name: 'deploy', run: (dir, args, flags) => require('./commands/deploy')(dir, args, flags) },
   { name: 'auto-push', run: (dir, args, flags) => require('./commands/autoPush')(dir, args, flags) },

package/src/commands/api.js

@@ -5,17 +5,51 @@ const path = require('path');
 const log = require('../logger');
 const { confirm } = require('../prompt');
 const { loadProjectConfig } = require('../projectConfig');
-const { TOOL_NAMES, openToolSession, callStructured, configuredScope } = require('../mcp/tools');
+const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
 const { cachedDescription, normalizeDescription, storeDescription } = require('../apiContractCache');
 const {
   isContractCompatibilityError,
   isHardContractIncompatibility,
   isDangerousOperation,
   sameOperationContract,
+  canRetryAfterContractChange,
   incompatibleOperationError,
 } = require('../contractCompatibility');
 
+async function registryRevision(session, operationId) {
+  const result = await callStructured(session, TOOL_NAMES.apiSearch, {
+    query: operationId,
+    limit: 100,
+  });
+  const items = result && Array.isArray(result.items) ? result.items : [];
+  const operation = items.find((item) => item && item.operation_id === operationId);
+  const revision = String(result && result.registry_revision || '').trim();
+  if (!operation || !revision) {
+    throw new Error(`DraftGo Registry could not resolve operation ${operationId} with a revision.`);
+  }
+  return revision;
+}
+
+async function describeOperation(projectDir, config, session, operationId, knownRevision = '') {
+  let revision = String(knownRevision || '').trim();
+  if (!revision) revision = await registryRevision(session, operationId);
+  const described = await callStructured(session, TOOL_NAMES.apiDescribe, {
+    operation_id: operationId,
+    registry_revision: revision,
+  });
+  return storeDescription(projectDir, config.server, described, revision)
+    || normalizeDescription(described, revision);
+}
+
+async function descriptionForRevision(projectDir, config, session, operationId, knownRevision = '') {
+  const revision = String(knownRevision || '').trim() || await registryRevision(session, operationId);
+  const cached = cachedDescription(projectDir, config.server, operationId);
+  if (cached && cached.registry_revision === revision) return cached;
+  return describeOperation(projectDir, config, session, operationId, revision);
+}
+
 function readCallInput(projectDir, flags) {
+  if (flags.input && flags.params) throw new Error('Use either --input or --params, not both.');
   const raw = flags.input
     ? fs.readFileSync(path.resolve(projectDir, String(flags.input)))
     : flags.params ? Buffer.from(String(flags.params), 'utf8') : Buffer.from('{}', 'utf8');
@@ -32,17 +66,38 @@ function diagnosticResult(operationId, result) {
   const statusCode = source.status_code ?? source.statusCode ?? source.status ?? null;
   const headerRequestId = source.headers
     && (source.headers['x-request-id'] || source.headers['X-Request-Id']);
-  const requestId = source.request_id ?? source.requestId ?? headerRequestId ?? null;
-  const error = source.error && typeof source.error === 'object' ? source.error : null;
+  const rawRequestId = source.request_id ?? source.requestId ?? headerRequestId ?? null;
+  const requestId = Array.isArray(rawRequestId) ? rawRequestId[0] || null : rawRequestId;
+  const data = source.data && typeof source.data === 'object' ? source.data : {};
+  const error = source.error || data.error || {};
   return {
     operation_id: operationId,
     status_code: statusCode,
-    server_code: error && error.code || source.code || null,
+    server_code: error.code || data.code || source.code || null,
     request_id: requestId,
     result,
   };
 }
 
+function assertInvocationResult(operationId, result) {
+  const diagnostic = diagnosticResult(operationId, result);
+  if (result && result.workflow && result.workflow.required) {
+    const error = new Error(`Operation ${operationId} requires the ${result.workflow.workflow || result.workflow.mode} workflow; it has not executed.`);
+    error.code = 'WORKFLOW_REQUIRED';
+    error.details = { ...diagnostic, workflow: result.workflow };
+    throw error;
+  }
+  if (Number(diagnostic.status_code) >= 400) {
+    const data = result.data || {};
+    const error = new Error(data.error && data.error.message || data.message || `DraftGo returned HTTP ${diagnostic.status_code}.`);
+    error.code = diagnostic.server_code || 'HTTP_ERROR';
+    error.status = diagnostic.status_code;
+    error.details = { ...data, request_id: diagnostic.request_id };
+    throw error;
+  }
+  return result;
+}
+
 function diagnosticError(operationId, error) {
   const source = error && (error.details || error.data) || {};
   const nested = source.error && typeof source.error === 'object' ? source.error : {};
@@ -77,11 +132,12 @@ async function callOperation(projectDir, operationId, flags = {}) {
   let config;
   try {
 	config = loadProjectConfig(projectDir);
-    session = await openToolSession(config, [TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall]);
+    session = await openToolSession(config, [
+      TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall,
+    ]);
     description = cachedDescription(projectDir, config.server, operationId);
     if (!description) {
-      const described = await callStructured(session, TOOL_NAMES.apiDescribe, { operation_id: operationId });
-      description = storeDescription(projectDir, config.server, described) || normalizeDescription(described);
+      description = await describeOperation(projectDir, config, session, operationId);
     }
     if (!description) throw new Error('DraftGo API description is missing contract revision metadata.');
     input = readCallInput(projectDir, flags);
@@ -90,14 +146,20 @@ async function callOperation(projectDir, operationId, flags = {}) {
   }
   const dangerous = isDangerousOperation(description);
   if (dangerous && !flags.yes && !flags.y) {
+    if (flags.output === 'json' || !process.stdin.isTTY) {
+      console.log(JSON.stringify({
+        operation_id: operationId,
+        error: { code: 'CONFIRMATION_REQUIRED', message: 'Dangerous operations require --yes in JSON output mode.' },
+      }, null, 2));
+      return 1;
+    }
     const approved = await confirm(`Call destructive DraftGo operation ${operationId}?`, { default: false });
-    if (!approved) return 0;
+    if (!approved) return 1;
   }
   let result;
   try {
     const invoke = (contract, confirmed) => callStructured(session, TOOL_NAMES.apiCall, {
       ...input, operation_id: operationId, registry_revision: contract.registry_revision,
-      ...configuredScope(config, contract),
       ...(confirmed ? { confirm: true } : {}),
     });
     try {
@@ -108,15 +170,19 @@ async function callOperation(projectDir, operationId, flags = {}) {
         throw incompatibleOperationError(operationId, error);
       }
       const previousDescription = description;
-      const described = await callStructured(session, TOOL_NAMES.apiDescribe, { operation_id: operationId });
-      description = storeDescription(projectDir, config.server, described) || normalizeDescription(described);
+      const revision = await registryRevision(session, operationId);
+      description = await describeOperation(projectDir, config, session, operationId, revision);
       if (!description) throw new Error('DraftGo API description is missing contract revision metadata.');
       const changedDangerous = isDangerousOperation(description);
       if ((dangerous || changedDangerous) && !sameOperationContract(previousDescription, description)) {
         throw incompatibleOperationError(operationId, error);
       }
+      if (!canRetryAfterContractChange(previousDescription, description)) {
+        throw incompatibleOperationError(operationId, error);
+      }
       result = await invoke(description, changedDangerous);
     }
+    assertInvocationResult(operationId, result);
   } catch (error) {
     return printCallError(operationId, error, flags);
   }
@@ -155,12 +221,12 @@ async function apiCommand(projectDir, positional, flags = {}) {
   }
 
   const config = loadProjectConfig(projectDir);
-  const expected = describe ? TOOL_NAMES.apiDescribe : TOOL_NAMES.apiSearch;
-  const session = await openToolSession(config, [expected]);
-  const result = await callStructured(session, expected, describe
-    ? { operation_id: query }
-    : { query });
-  if (describe) storeDescription(projectDir, config.server, result);
+  const expected = describe ? [TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe] : [TOOL_NAMES.apiSearch];
+  const session = await openToolSession(config, expected);
+  const result = describe
+    ? await describeOperation(projectDir, config, session, query)
+    : await callStructured(session, TOOL_NAMES.apiSearch,
+      require('./capabilities').searchArguments(query, flags, flags.cursor));
   if (flags.output === 'json') console.log(JSON.stringify(result, null, 2));
   else printResult(describe ? `DraftGo API ${query}` : `DraftGo API search: ${query}`, result);
   return 0;
@@ -172,3 +238,7 @@ module.exports.diagnosticResult = diagnosticResult;
 module.exports.diagnosticError = diagnosticError;
 module.exports.printCallError = printCallError;
 module.exports.callOperation = callOperation;
+module.exports.registryRevision = registryRevision;
+module.exports.describeOperation = describeOperation;
+module.exports.descriptionForRevision = descriptionForRevision;
+module.exports.assertInvocationResult = assertInvocationResult;

package/src/commands/apiKey.js

@@ -6,12 +6,9 @@ const { callOperation } = require('./api');
 const OPERATIONS = Object.freeze({
   status: 'getCurrentUserAPIKey',
   create: 'createCurrentUserAPIKey',
-  update: 'updateCurrentUserAPIKey',
+  update: 'setCurrentUserAPIKeyActive',
   delete: 'deleteCurrentUserAPIKey',
   rotate: 'rotateCurrentUserAPIKey',
-  reset: 'resetCurrentUserAPIKey',
-  enable: 'enableCurrentUserAPIKey',
-  disable: 'disableCurrentUserAPIKey',
 });
 
 function operationKey(value) {
@@ -22,10 +19,9 @@ function operationKey(value) {
 async function apiKeyCommand(projectDir, positional, flags = {}) {
   const action = operationKey(positional[0]);
   if (!action) {
-    log.err('Usage: draftgo api-key status|create|update|delete|rotate|reset|enable|disable [--input <json-file>]');
+    log.err('Usage: draftgo api-key status|create|update|delete|rotate [--input <json-file>]');
     return 1;
   }
-  if (action === 'reset') log.warn('api-key reset is deprecated; prefer rotate.');
   return callOperation(projectDir, OPERATIONS[action], flags);
 }
 

package/src/commands/autoPush.js

@@ -1,72 +1,36 @@
 'use strict';
 
 const fs = require('fs');
-const log = require('../logger');
-const check = require('./check');
 const { loadProjectConfig } = require('../projectConfig');
 const { loadManifest, absolutePath } = require('../worktree/manifest');
 const { hashFile } = require('../worktree/streams');
-const { listConflicts, commitResources } = require('../worktree');
+const { targetsFrom, deliverTargets, outputResult } = require('./deploy');
 
 async function changedEntries(projectDir, manifest) {
   const changed = [];
   for (const entry of Object.values(manifest.entries)) {
     const local = absolutePath(projectDir, entry.local_path);
-    if (!fs.existsSync(local)) continue;
-    if ((await hashFile(local)).hash !== entry.base_hash) changed.push(entry);
+    // Missing files must be validated, not silently dropped from delivery.
+    if (!fs.existsSync(local) || (await hashFile(local)).hash !== entry.base_hash) changed.push(entry);
   }
   return changed;
 }
 
 async function autoPush(projectDir, positional, flags = {}) {
-  let config;
   try {
-    config = loadProjectConfig(projectDir);
-  } catch {
-    log.dim('auto-push skipped: this project is not connected to DraftGo.');
-    return 0;
-  }
-
-  if (config.auto_push !== true) {
-    log.dim('auto-push skipped: .draftgo/config.json does not set auto_push to true.');
-    return 0;
-  }
-  const conflicts = listConflicts(projectDir);
-  if (conflicts.length) {
-    log.err(`auto-push stopped: ${conflicts.length} unresolved DraftGo conflict(s).`);
-    return 1;
-  }
-
-  const checkCode = await check(projectDir, { strict: flags.strict });
-  if (checkCode !== 0) {
-    log.err('auto-push stopped because local validation failed.');
-    return checkCode;
-  }
-
-  const groups = new Map();
-  if (positional.length) {
-    const [resourceType, ...ids] = positional;
-    if (!resourceType || !ids.length) {
-      log.err('Usage: draftgo auto-push [<pages|nav|docs> <id...>]');
-      return 1;
-    }
-    groups.set(resourceType, ids);
-  } else {
-    for (const entry of await changedEntries(projectDir, loadManifest(projectDir))) {
-      if (!groups.has(entry.resource_type)) groups.set(entry.resource_type, []);
-      groups.get(entry.resource_type).push(entry.resource_id);
+    let config;
+    try { config = loadProjectConfig(projectDir); }
+    catch (error) {
+      if (fs.existsSync(require('path').join(projectDir, '.draftgo', 'config.json'))) throw error;
+      return outputResult({ skipped: 'auto-push skipped: this project is not connected to DraftGo.' }, flags);
     }
-  }
-  if (!groups.size) {
-    log.dim('auto-push: no checked-out content changed.');
-    return 0;
-  }
-
-  for (const [resourceType, ids] of groups) {
-    await commitResources(projectDir, resourceType, ids, { config });
-  }
-  log.ok('auto-push committed all changed checked-out content.');
-  return 0;
+    if (config.auto_push !== true) return outputResult({ skipped: 'auto-push skipped: auto_push is not enabled.' }, flags);
+    const targets = positional.length ? targetsFrom(positional)
+      : (await changedEntries(projectDir, loadManifest(projectDir))).map(({ resource_type, resource_id }) => ({ resource_type, resource_id }));
+    if (!targets.length) return outputResult({ skipped: 'auto-push: no checked-out content changed.' }, flags);
+    const value = await deliverTargets(projectDir, targets, { ...flags, delivery: 'deploy' }, { config });
+    return outputResult({ ...value, delivery: 'auto-push' }, flags);
+  } catch (error) { return outputResult({ error: { code: error.code || 'AUTO_PUSH_FAILED', message: error.message } }, flags); }
 }
 
 module.exports = autoPush;

package/src/commands/capabilities.js

@@ -23,10 +23,12 @@ function print(value, flags, title) {
 }
 
 function searchArguments(query, flags, cursor) {
-  const input = { limit: Math.min(100, Math.max(1, Number(flags.limit) || 100)) };
+  const limit = flags.limit == null ? 20 : Number(flags.limit);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new Error('--limit must be an integer between 1 and 100.');
+  const input = { limit };
   if (query) input.query = query;
   if (flags.module) input.module = String(flags.module);
-  if (flags['resource-type'] || flags.type) input.resource_type = String(flags['resource-type'] || flags.type);
+  if (flags.type) input.module = String(flags.type);
   if (flags.method) input.method = String(flags.method).toUpperCase();
   if (flags.risk) input.risk = String(flags.risk);
   if (flags.permission) input.permission = String(flags.permission);
@@ -36,43 +38,48 @@ function searchArguments(query, flags, cursor) {
 
 async function collect(session, query, flags, allPages) {
   const result = [];
+  let registryRevision = null;
+  let total = null;
   let cursor = flags.cursor || null;
   const seen = new Set();
   do {
     const page = await callStructured(session, TOOL_NAMES.apiSearch, searchArguments(query, flags, cursor));
     result.push(...itemsOf(page));
+    registryRevision ||= page && page.registry_revision || null;
+    if (Number.isFinite(Number(page && page.total))) total = Number(page.total);
     cursor = nextCursorOf(page);
     if (!allPages || !cursor) break;
     if (seen.has(cursor)) throw new Error('DraftGo capability search repeated a cursor.');
     seen.add(cursor);
   } while (true);
-  return { items: result, next_cursor: cursor };
+  return { items: result, next_cursor: cursor, registry_revision: registryRevision, total };
 }
 
 async function capabilities(projectDir, positional = [], flags = {}) {
+  if (flags['resource-type'] != null) {
+    throw new Error('Capabilities --resource-type is not supported; use --type or --module for a Registry module.');
+  }
   const action = String(positional[0] || 'list').toLowerCase();
   const config = loadProjectConfig(projectDir);
   if (action === 'show') {
     const operationID = String(positional[1] || '').trim();
     if (!operationID) throw new Error('Usage: draftgo capabilities show <operation_id>');
-    const session = await openToolSession(config, [TOOL_NAMES.apiDescribe]);
-    const result = await callStructured(session, TOOL_NAMES.apiDescribe, { operation_id: operationID });
+    const { registryRevision, descriptionForRevision } = require('./api');
+    const session = await openToolSession(config, [TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe]);
+    const revision = await registryRevision(session, operationID);
+    const result = await descriptionForRevision(projectDir, config, session, operationID, revision);
     print(result, flags, `DraftGo capability ${operationID}`);
     return 0;
   }
   if (action === 'audit') {
-    const session = await openToolSession(config, [TOOL_NAMES.projectOverview, TOOL_NAMES.apiSearch]);
-    const overview = await callStructured(session, TOOL_NAMES.projectOverview, {});
+    const session = await openToolSession(config, [TOOL_NAMES.apiSearch]);
     const catalog = await collect(session, '', flags, true);
-    const registry = overview && (overview.operation_registry || overview.registry) || {};
     const result = {
       server: config.server,
-      registry_revision: registry.registry_revision || overview.registry_revision || null,
-      mapped_operations: registry.mapped_operations ?? registry.mapped ?? catalog.items.length,
-      excluded_operations: registry.excluded_operations ?? registry.excluded ?? null,
-      total_operations: registry.total_operations ?? registry.total ?? null,
+      registry_revision: catalog.registry_revision,
+      total_operations: catalog.total ?? catalog.items.length,
       discovered_operations: catalog.items.length,
-      complete: (registry.mapped_operations ?? registry.mapped ?? catalog.items.length) === catalog.items.length,
+      complete: catalog.next_cursor == null && (catalog.total == null || catalog.total === catalog.items.length),
     };
     print(result, flags, 'DraftGo capability audit');
     return result.complete ? 0 : 1;
@@ -83,8 +90,8 @@ async function capabilities(projectDir, positional = [], flags = {}) {
     throw new Error('Capability search needs a query or filter.');
   }
   const session = await openToolSession(config, [TOOL_NAMES.apiSearch]);
-  const result = await collect(session, query, flags, action === 'list' && !flags.cursor);
-  print(flags.output === 'json' ? result : result.items, flags, action === 'search' ? `DraftGo capabilities: ${query || 'filtered'}` : 'DraftGo capabilities');
+  const result = await collect(session, query, flags, false);
+  print(result, flags, action === 'search' ? `DraftGo capabilities: ${query || 'filtered'}` : 'DraftGo capabilities');
   return 0;
 }
 

package/src/commands/check.js

@@ -3,24 +3,19 @@
 const log = require('../logger');
 const { analyzeProject } = require('../projectMap');
 const { inspectRemoteCheckouts } = require('../worktree/status');
-const customServices = require('../customServices');
-const { workspaceHealth } = require('../workspaceHealth');
+const { projectHealth } = require('../projectHealth');
 
 async function check(projectDir, positional = [], flags = {}) {
   if (!Array.isArray(positional)) {
     flags = positional || {};
     positional = [];
   }
-  const [requestedType, ...requestedIds] = positional;
-  if (requestedType && !customServicesCommand().isServiceType(requestedType)) {
-    log.err('Usage: draftgo check [custom-services <id...>] [--remote]');
-    return 1;
-  }
-  if (requestedType && !requestedIds.length) {
-    log.err('Usage: draftgo check custom-services <id...> [--remote]');
+  if (positional.length) {
+    if (!flags.quiet) log.err('Usage: draftgo check [--remote]');
     return 1;
   }
   const resourceKeys = flags.resourceKeys || null;
+  const quiet = Boolean(flags.quiet);
   const result = analyzeProject(projectDir, { resourceKeys });
   if (resourceKeys) {
     const manifestKeys = new Set(Object.keys(result.map.checkouts.reduce((entries, entry) => {
@@ -29,44 +24,17 @@ async function check(projectDir, positional = [], flags = {}) {
     }, {})));
     for (const key of resourceKeys) if (!manifestKeys.has(key)) result.errors.push(`${key}: resource is not checked out`);
   }
-  const hygiene = workspaceHealth(projectDir);
-  hygiene.warnings.forEach((warning) => result.warningDetails.push({ code: warning.code, confidence: 'high', message: `${warning.path}${warning.size ? ` (${warning.size} bytes)` : ''}` }));
-  hygiene.warnings.forEach((warning) => result.warnings.push(`${warning.code}: ${warning.path}`));
-  const serviceManifest = customServices.loadManifest(projectDir);
-  const customServiceChecks = [];
-  const requested = new Set(requestedIds.map(String));
-  const serviceEntries = Object.values(serviceManifest.entries)
-    .filter((entry) => !resourceKeys && (!requestedType || requested.has(String(entry.resource_id))));
-  if (requestedType) {
-    for (const id of requested) {
-      if (!serviceEntries.some((entry) => String(entry.resource_id) === id)) {
-        result.errors.push(`custom_services ${id}: resource is not checked out`);
-      }
-    }
-  }
-  for (const entry of serviceEntries) {
-    try {
-      const state = customServices.diff(projectDir, entry.resource_id);
-      customServiceChecks.push({ resource_type: 'custom_services', resource_id: entry.resource_id, state: state.changed ? 'local_modified' : 'clean_local', files: state.files });
-    } catch (error) {
-      result.errors.push(`custom_services ${entry.resource_id}: ${error.message}`);
-    }
-  }
+  const hygiene = projectHealth(projectDir);
+  const hygieneWarnings = resourceKeys ? [] : hygiene.warnings;
+  hygieneWarnings.forEach((warning) => result.warningDetails.push({ code: warning.code, confidence: 'high', message: `${warning.path}${warning.size ? ` (${warning.size} bytes)` : ''}` }));
+  hygieneWarnings.forEach((warning) => result.warnings.push(`${warning.code}: ${warning.path}`));
   let remote = null;
   let remoteError = null;
   if (flags.remote) {
     try {
-      const [contentRemote, serviceRemote] = await Promise.all([
-        inspectRemoteCheckouts(projectDir, resourceKeys ? {
+      remote = await inspectRemoteCheckouts(projectDir, resourceKeys ? {
           entries: result.map.checkouts.filter((entry) => resourceKeys.includes(`${entry.resource_type}:${entry.resource_id}`)),
-        } : {}),
-        resourceKeys
-          ? Promise.resolve([])
-          : customServices.inspectRemote(projectDir, requestedType ? { ids: [...requested] } : {}),
-      ]);
-      remote = requestedType
-        ? serviceRemote.filter((entry) => requested.has(String(entry.resource_id)))
-        : [...contentRemote, ...serviceRemote];
+        } : {});
       for (const entry of remote) {
         if (!['clean', 'clean_local', 'local_modified'].includes(entry.state)) {
           const detail = `${entry.resource_type} ${entry.resource_id}: ${entry.state}`
@@ -82,25 +50,27 @@ async function check(projectDir, positional = [], flags = {}) {
     }
   }
   const output = {
-    content_validation: { map: result.map, errors: result.errors, warnings: result.warnings, warning_details: result.warningDetails, custom_services: customServiceChecks },
+    content_validation: { map: result.map, errors: result.errors, warnings: result.warnings, warning_details: result.warningDetails },
     remote_validation: { resources: remote, error: remoteError },
-    workspace_hygiene: hygiene,
+    project_hygiene: hygiene,
   };
+  const code = result.errors.length || (flags.strict && result.warnings.length) ? 1 : 0;
+  if (flags.returnResult) return { code, ...output };
+  if (quiet) return code;
   if (flags.output === 'json') {
-    console.log(JSON.stringify(output, null, 2));
+    if (!quiet) console.log(JSON.stringify(output, null, 2));
     return result.errors.length || (flags.strict && result.warnings.length) ? 1 : 0;
   }
 
-  log.title('draftgo check');
+  if (!quiet) log.title('draftgo check');
   const selectedCount = (type, entries) => resourceKeys
     ? entries.filter((entry) => resourceKeys.includes(`${type}:${entry.resource_id}`)).length
     : entries.length;
   log.info(`Checked-out pages: ${selectedCount('pages', result.map.pages)}`);
   log.info(`Checked-out navigations: ${selectedCount('navigations', result.map.navigations)}`);
   log.info(`Checked-out docs: ${selectedCount('docs', result.map.docs)}`);
-  log.info(`Checked-out custom services: ${customServiceChecks.length}`);
-  log.info(`Workspace: ${hygiene.managed_files} managed, ${hygiene.unknown_files} unknown, ${hygiene.temporary_files} temporary, ${hygiene.artifact_files} artifact file(s)`);
-  log.info(`Workspace size: ${hygiene.total_bytes} bytes; reclaimable: ${hygiene.reclaimable_bytes} bytes`);
+  log.info(`Project: ${hygiene.managed_files} managed, ${hygiene.unknown_files} unknown, ${hygiene.temporary_files} temporary, ${hygiene.artifact_files} artifact file(s)`);
+  log.info(`Project size: ${hygiene.total_bytes} bytes; reclaimable: ${hygiene.reclaimable_bytes} bytes`);
   if (remote) log.info(`Remote checkout comparison: ${remote.length} resource(s)`);
   for (const message of result.errors) log.err(message);
   for (const detail of result.warningDetails) log.warn(`[${detail.code}/${detail.confidence}] ${detail.message}`);
@@ -109,8 +79,4 @@ async function check(projectDir, positional = [], flags = {}) {
   return 0;
 }
 
-function customServicesCommand() {
-  return require('./customService');
-}
-
 module.exports = check;

package/src/commands/checkout.js

@@ -6,12 +6,9 @@ const { checkoutResources } = require('../worktree');
 async function checkout(projectDir, positional, flags = {}) {
   const [resourceType, ...ids] = positional;
   if (!resourceType || !ids.length) {
-    log.err('Usage: draftgo checkout <pages|nav|docs|custom-services> <id...>');
+    log.err('Usage: draftgo checkout <pages|nav|docs> <id...>');
     return 1;
   }
-  if (require('./customService').isServiceType(resourceType)) {
-    return require('./customService').checkout(projectDir, ids, flags);
-  }
   const results = await checkoutResources(projectDir, resourceType, ids, { force: Boolean(flags.force) });
   if (flags.output === 'json') console.log(JSON.stringify(results, null, 2));
   else for (const entry of results) log.ok(`Checked out ${entry.resource_type} ${entry.resource_id} -> ${entry.local_path}`);

package/src/commands/clean.js

@@ -5,7 +5,7 @@ const path = require('path');
 const log = require('../logger');
 const runtime = require('../runtimeFiles');
 
-const MANAGED_PREFIXES = ['tmp/', 'artifacts/ui/', 'artifacts/api/', 'artifacts/custom-services/'];
+const MANAGED_PREFIXES = ['tmp/', 'artifacts/ui/', 'artifacts/api/'];
 function fileSize(file) { try { const stat = fs.statSync(file); return stat.isFile() ? stat.size : 0; } catch { return 0; } }
 function olderThan(value) {
   if (value == null || value === '') return 0;

package/src/commands/commit.js

@@ -6,12 +6,9 @@ const { commitResources } = require('../worktree');
 async function commit(projectDir, positional, flags = {}) {
   const [resourceType, ...ids] = positional;
   if (!resourceType || !ids.length) {
-    log.err('Usage: draftgo commit <pages|nav|docs|custom-services> <id...>');
+    log.err('Usage: draftgo commit <pages|nav|docs> <id...>');
     return 1;
   }
-  if (require('./customService').isServiceType(resourceType)) {
-    return require('./customService').commit(projectDir, ids, flags);
-  }
   const streamed = [];
   const printStatus = (result) => {
     streamed.push(result);

package/src/commands/components.js

@@ -46,7 +46,7 @@ function csv(value) {
 
 function normalizeDefinition(definition = {}) {
   return {
-    html: definition.html || '', css: definition.css || '', js: definition.js || '',
+    html: definition.html || '', css: definition.css || '', js: definition.js || '', assets: definition.assets || [],
     props: definition.props || [], slots: definition.slots || [], css_variables: definition.css_variables || [],
     events: definition.events || [], dependencies: definition.dependencies || [], examples: definition.examples || [],
     usage: definition.usage || '', root_tag: definition.root_tag || '', meta: definition.meta || {},
@@ -66,12 +66,12 @@ function componentDir(projectDir, name) {
 }
 
 function contractFrom(definition = {}) {
-  const { props, slots, css_variables, events, dependencies, examples, usage, root_tag, meta } = normalizeDefinition(definition);
-  return { props, slots, css_variables, events, dependencies, examples, usage, root_tag, meta };
+  const { assets, props, slots, css_variables, events, dependencies, examples, usage, root_tag, meta } = normalizeDefinition(definition);
+  return { assets, props, slots, css_variables, events, dependencies, examples, usage, root_tag, meta };
 }
 
 function localDefinition(directory) {
-  const contract = JSON.parse(fs.readFileSync(path.join(directory, 'contract.json'), 'utf8'));
+  const contract = JSON.parse(fs.readFileSync(path.join(directory, 'component.json'), 'utf8'));
   return normalizeDefinition({
     html: fs.readFileSync(path.join(directory, 'component.html'), 'utf8'),
     css: fs.readFileSync(path.join(directory, 'component.css'), 'utf8'),
@@ -85,12 +85,12 @@ function writeComponentFiles(directory, item) {
   fs.writeFileSync(path.join(directory, 'component.html'), item.draft.html || '', 'utf8');
   fs.writeFileSync(path.join(directory, 'component.css'), item.draft.css || '', 'utf8');
   fs.writeFileSync(path.join(directory, 'component.js'), item.draft.js || '', 'utf8');
-  fs.writeFileSync(path.join(directory, 'contract.json'), `${JSON.stringify(contractFrom(item.draft), null, 2)}\n`, 'utf8');
   const metadata = {
     id: item.id, library_id: item.library_id, library_slug: item.library_slug,
     name: item.name, slug: item.slug, category: item.category || '', description: item.description || '',
     tags: item.tags || [], status: item.status || 'active', published_revision: item.published_revision || 0,
     remote_draft_hash: definitionHash(item.draft), updated_at: item.updated_at,
+    ...contractFrom(item.draft),
   };
   fs.writeFileSync(path.join(directory, 'component.json'), `${JSON.stringify(metadata, null, 2)}\n`, 'utf8');
   fs.writeFileSync(path.join(directory, '.base.json'), `${JSON.stringify(item, null, 2)}\n`, 'utf8');
@@ -231,7 +231,7 @@ async function diff(projectDir, name, flags) {
   const config = loadProjectConfig(projectDir);
   const state = localState(projectDir, name);
   const remote = await findComponent(config, name);
-  const sections = ['html', 'css', 'js', 'props', 'slots', 'css_variables', 'events', 'dependencies', 'examples', 'usage', 'root_tag', 'meta'];
+  const sections = ['html', 'css', 'js', 'assets', 'props', 'slots', 'css_variables', 'events', 'dependencies', 'examples', 'usage', 'root_tag', 'meta'];
   const changed = (left, right) => {
     const normalizedLeft = normalizeDefinition(left);
     const normalizedRight = normalizeDefinition(right);
@@ -364,9 +364,13 @@ async function exportZIP(projectDir, librarySlug, flags) {
   }
   for (const summary of components) {
     const item = await request(config, 'GET', `components/${summary.id}`);
-    const definition = `components/${item.slug}.json`;
+    const directory = `components/${item.slug}`;
+    const definition = `${directory}/component.json`;
     manifest.components.push({ name: item.name, slug: item.slug, category: item.category, description: item.description, tags: item.tags, definition });
-    zip.addFile(definition, Buffer.from(`${JSON.stringify(item.draft, null, 2)}\n`, 'utf8'));
+    zip.addFile(definition, Buffer.from(`${JSON.stringify(contractFrom(item.draft), null, 2)}\n`, 'utf8'));
+    zip.addFile(`${directory}/component.html`, Buffer.from(item.draft.html || '', 'utf8'));
+    zip.addFile(`${directory}/component.css`, Buffer.from(item.draft.css || '', 'utf8'));
+    zip.addFile(`${directory}/component.js`, Buffer.from(item.draft.js || '', 'utf8'));
   }
   zip.addFile('draftgo-components.json', Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, 'utf8'));
   const destination = path.resolve(projectDir, flags.file || `${library.slug}-components.zip`);