draftgo-cli 4.0.25 → 4.0.26

package/src/mcp/protocol.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const DEFAULT_PROTOCOL_VERSION = '2026-07-28';
+const DEFAULT_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
 
 class McpHttpError extends Error {
   constructor(message, { status = 0, rpc = null, code = null } = {}) {
@@ -62,13 +63,14 @@ function routingHeaders(message) {
   return headers;
 }
 
-async function parseEventStream(body, onMessage) {
+async function parseEventStream(body, onMessage, maxBytes = DEFAULT_MAX_RESPONSE_BYTES) {
   if (!body) return [];
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let pending = '';
   let dataLines = [];
-  const messages = [];
+  const messages = [];
+  let size = 0;
   const consume = () => {
     if (!dataLines.length) return;
     const data = dataLines.join('\n');
@@ -84,7 +86,12 @@ async function parseEventStream(body, onMessage) {
     }
   };
   while (true) {
-    const { done, value } = await reader.read();
+    const { done, value } = await reader.read();
+    size += value ? value.byteLength : 0;
+    if (size > maxBytes) {
+      await reader.cancel().catch(() => {});
+      throw new McpHttpError(`DraftGo MCP response exceeds ${maxBytes} bytes.`);
+    }
     pending += decoder.decode(value || new Uint8Array(), { stream: !done });
     const lines = pending.split(/\r?\n/);
     pending = lines.pop() || '';
@@ -99,7 +106,7 @@ async function parseEventStream(body, onMessage) {
   return messages;
 }
 
-async function readLimitedText(response, maxBytes = 65536) {
+async function readLimitedText(response, maxBytes = 65536) {
   if (!response.body) return '';
   const reader = response.body.getReader();
   const chunks = [];
@@ -112,7 +119,26 @@ async function readLimitedText(response, maxBytes = 65536) {
     size += chunk.length;
   }
   return Buffer.concat(chunks).toString('utf8');
-}
+}
+
+async function readBoundedText(response, maxBytes) {
+  if (!response.body) return '';
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const chunk = Buffer.from(value);
+    size += chunk.length;
+    if (size > maxBytes) {
+      await reader.cancel().catch(() => {});
+      throw new McpHttpError(`DraftGo MCP response exceeds ${maxBytes} bytes.`);
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
 
 async function postJsonRpc(config, message, options = {}) {
   const token = String(config.token || config.sat || '');
@@ -163,9 +189,11 @@ async function postJsonRpc(config, message, options = {}) {
     }
 
     if (contentType.includes('text/event-stream')) {
-      return await parseEventStream(response.body, options.onMessage);
-    }
-    const text = await response.text();
+      return await parseEventStream(response.body, options.onMessage,
+        Number(options.maxResponseBytes || config.mcp_max_response_bytes || DEFAULT_MAX_RESPONSE_BYTES));
+    }
+    const text = await readBoundedText(response,
+      Number(options.maxResponseBytes || config.mcp_max_response_bytes || DEFAULT_MAX_RESPONSE_BYTES));
     if (!text.trim()) return [];
     let parsed;
     try { parsed = JSON.parse(text); } catch {
@@ -183,7 +211,8 @@ async function postJsonRpc(config, message, options = {}) {
   }
 }
 
-module.exports = {
+module.exports = {
+  DEFAULT_MAX_RESPONSE_BYTES,
   DEFAULT_PROTOCOL_VERSION,
   McpHttpError,
   redactText,

package/src/mcp/tools.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { DraftGoMcpClient } = require('./client');
+const { DraftGoMcpClient, TOOL_ALIASES } = require('./client');
 const { WorktreeError } = require('../worktree/errors');
 const { unwrapToolResult, unwrapProtectedResult, toolNameMatches } = require('../worktree/backend');
 
@@ -15,6 +15,8 @@ const TOOL_NAMES = Object.freeze({
   apiCall: 'draftgo_api_call',
 });
 
+// Keep server-generation naming compatibility at the protocol boundary so
+// commands only deal with one canonical Registry contract.
 const PROTECTED_RESOURCE_TOOLS = new Set([
   TOOL_NAMES.resourceList,
   TOOL_NAMES.resourceSearch,
@@ -24,28 +26,17 @@ const PROTECTED_RESOURCE_TOOLS = new Set([
 
 async function openToolSession(config, expected = [], options = {}) {
   const client = options.client || new DraftGoMcpClient(config);
-  await client.initialize(options);
-  const tools = await client.listAllTools(options);
+  const initialized = options.clientInitialized ? null : await client.initialize(options);
+  const tools = options.tools || await client.listAllTools(options);
   const names = {};
   for (const expectedName of expected) {
-    const found = tools.find((tool) => tool && toolNameMatches(String(tool.name || ''), expectedName));
+    const aliases = TOOL_ALIASES[expectedName] || [expectedName];
+    const found = aliases.map((alias) => tools.find((tool) => tool
+      && toolNameMatches(String(tool.name || ''), alias))).find(Boolean);
     if (!found) throw new WorktreeError('MCP_TOOL_UNAVAILABLE', `${expectedName} is not available.`);
     names[expectedName] = found.name;
   }
-  return { client, tools, names };
-}
-
-function configuredScope(config, description = null) {
-  const operation = description && (description.operation || description) || {};
-  if (String(operation.ownership_mode || '').toLowerCase() === 'platform_only') return {};
-  const supported = Array.isArray(operation.supported_scopes)
-    ? operation.supported_scopes.map(value => String(value).toLowerCase()) : [];
-  const needsSpace = String(operation.ownership_mode || '').toLowerCase() === 'workspace_required'
-    && supported.length > 0 && !supported.includes('platform');
-  if (config && config.scope_type === 'space' && Number(config.space_id) > 0 && (needsSpace || supported.includes('space'))) {
-    return { scope_type: 'space', space_id: Number(config.space_id) };
-  }
-  return {};
+  return { client, initialized, tools, names };
 }
 
 async function callStructured(session, expectedName, args = {}, options = {}) {
@@ -57,4 +48,4 @@ async function callStructured(session, expectedName, args = {}, options = {}) {
     : data;
 }
 
-module.exports = { TOOL_NAMES, openToolSession, callStructured, configuredScope };
+module.exports = { TOOL_NAMES, TOOL_ALIASES, openToolSession, callStructured };

package/src/projectConfig.js

@@ -100,13 +100,10 @@ function writeProjectConfig(projectDir, server, token, options = {}) {
   if (!apiKey) throw new Error('DraftGo API Key is required.');
   const existing = readExisting(projectDir);
   const config = {
-    ...existing,
     server: normalizedServer,
     token: apiKey,
     auto_push: existing.auto_push === true,
   };
-  if (options.scope_type) config.scope_type = String(options.scope_type).trim().toLowerCase();
-  if (options.space_id) config.space_id = Number(options.space_id);
   if (options.mcp_url) config.mcp_url = normalizeMcpEndpoint(options.mcp_url);
   else delete config.mcp_url;
   const file = configPath(projectDir);
@@ -124,7 +121,7 @@ function loadProjectConfig(projectDir, { requireToken = true } = {}) {
   const token = String(config.token || config.sat || '').trim();
   if (!server) throw new Error('DraftGo project config is missing server.');
   if (requireToken && !token) throw new Error('DraftGo project config is missing API Key.');
-  const result = { ...config, server, token, path: file };
+  const result = { server, token, auto_push: config.auto_push === true, path: file };
   if (mcpUrl) result.mcp_url = mcpUrl;
   else delete result.mcp_url;
   return result;

package/src/{workspaceHealth.js → projectHealth.js}

@@ -5,7 +5,7 @@ const path = require('path');
 const runtime = require('./runtimeFiles');
 
 const PROTECTED_PREFIXES = ['worktree/', 'conflicts/', 'lessons/', 'tmp/', 'config.json', 'api-contract-cache.json', 'api-contract-cache.json.lock', 'worklog.md', 'story.yaml', '.version', 'runtime-manifest.json'];
-function workspaceHealth(projectDir) {
+function projectHealth(projectDir) {
   const root = runtime.draftgoRoot(projectDir); const registered = new Set(runtime.load(projectDir).entries.map((entry) => String(entry.path).replace(/\\/g, '/')));
   const summary = { managed_files: 0, unknown_files: 0, temporary_files: 0, artifact_files: 0, total_bytes: 0, reclaimable_bytes: 0, warnings: [] };
   if (!fs.existsSync(root)) return summary;
@@ -13,7 +13,7 @@ function workspaceHealth(projectDir) {
     for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
       const absolute = path.join(directory, item.name); const relative = path.relative(root, absolute).replace(/\\/g, '/');
       if (item.isDirectory()) {
-        if ((/^(.+\/)?(build|dist|node_modules|tmp-build|build-)/i.test(relative)) && directorySize(absolute) > 50 * 1024 * 1024) summary.warnings.push({ code: 'DG-WORKSPACE-LARGE-BUILD', path: relative });
+        if ((/^(.+\/)?(build|dist|node_modules|tmp-build|build-)/i.test(relative)) && directorySize(absolute) > 50 * 1024 * 1024) summary.warnings.push({ code: 'DG-PROJECT-LARGE-BUILD', path: relative });
         visit(absolute); continue;
       }
       if (!item.isFile()) continue;
@@ -23,11 +23,11 @@ function workspaceHealth(projectDir) {
       if (relative.startsWith('tmp/')) summary.temporary_files += 1;
       if (relative.startsWith('artifacts/')) summary.artifact_files += 1;
       if (registered.has(relative) || relative.startsWith('tmp/')) summary.reclaimable_bytes += size;
-      if (!managed && (/\.exe$/i.test(relative) || (/^[^/]+\.(go|json)$/i.test(relative) && !['config.json', 'runtime-manifest.json'].includes(relative)))) summary.warnings.push({ code: 'DG-WORKSPACE-UNKNOWN-FILE', path: relative, size });
-      if (relative.startsWith('artifacts/') && !registered.has(relative)) summary.warnings.push({ code: 'DG-WORKSPACE-UNREGISTERED-ARTIFACT', path: relative, size });
+      if (!managed && (/\.exe$/i.test(relative) || (/^[^/]+\.(go|json)$/i.test(relative) && !['config.json', 'runtime-manifest.json'].includes(relative)))) summary.warnings.push({ code: 'DG-PROJECT-UNKNOWN-FILE', path: relative, size });
+      if (relative.startsWith('artifacts/') && !registered.has(relative)) summary.warnings.push({ code: 'DG-PROJECT-UNREGISTERED-ARTIFACT', path: relative, size });
     }
   };
   visit(root); return summary;
 }
 function directorySize(directory) { let total = 0; const visit = (current) => { for (const item of fs.readdirSync(current, { withFileTypes: true })) { const absolute = path.join(current, item.name); if (item.isDirectory()) visit(absolute); else if (item.isFile()) total += fs.statSync(absolute).size; if (total > 50 * 1024 * 1024) return; } }; visit(directory); return total; }
-module.exports = { workspaceHealth };
+module.exports = { projectHealth };

package/src/projectMap.js

@@ -110,7 +110,7 @@ function buildProjectMap(projectDir) {
     docs,
     pageGroups: collectGroups(pages),
     routeRefs: Object.fromEntries([...routeRefs].map(([route, sources]) => [route, [...sources]])),
-    remote_only: ['db_meta', 'aihub', 'system_config', 'roles', 'users', 'doc_categories', 'custom_services'],
+    remote_only: ['db_meta', 'models', 'prompts', 'plugins', 'knowledge', 'memory', 'agents', 'custom_services', 'system_config', 'roles', 'users', 'doc_categories'],
   };
 }
 

package/src/runtimeFiles.js

@@ -8,7 +8,7 @@ const RETRYABLE_RENAME_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
 const sleepBuffer = new Int32Array(new SharedArrayBuffer(4));
 function draftgoRoot(projectDir) { return path.resolve(projectDir, '.draftgo'); }
 function manifestPath(projectDir) { return path.join(draftgoRoot(projectDir), 'runtime-manifest.json'); }
-function inside(root, target) { const relation = path.relative(root, target); return relation && !relation.startsWith('..') && !path.isAbsolute(relation); }
+function inside(root, target) { const relation = path.relative(path.resolve(root), path.resolve(target)); return relation && !relation.startsWith('..') && !path.isAbsolute(relation); }
 function load(projectDir) {
   const file = manifestPath(projectDir);
   if (!fs.existsSync(file)) return { schema_version: SCHEMA_VERSION, entries: [] };
@@ -36,6 +36,7 @@ function save(projectDir, value) {
 function register(projectDir, file, type, command, options = {}) {
   const root = draftgoRoot(projectDir); const absolute = path.resolve(file);
   if (!inside(root, absolute)) throw new Error('Managed runtime files must stay inside .draftgo.');
+  if (fs.existsSync(absolute) && !inside(fs.realpathSync(root), fs.realpathSync(absolute))) throw new Error('Managed runtime file escapes .draftgo.');
   const relative = path.relative(root, absolute).replace(/\\/g, '/'); const value = load(projectDir);
   const entry = { path: relative, type: String(type), command: String(command), created_at: new Date().toISOString(), cleanable: options.cleanable !== false };
   value.entries = value.entries.filter((item) => item.path !== relative); value.entries.push(entry); save(projectDir, value); return entry;

package/src/worklog.js

@@ -5,7 +5,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { dgDir } = require('./paths');
 
-const STATUS = Object.freeze({ pending: '', active: '●', completed: '√' });
+const STATUS = Object.freeze({ pending: '', active: '●', waiting: '?', completed: '√' });
 const LOCK_WAIT_ARRAY = new Int32Array(new SharedArrayBuffer(4));
 
 function formatLocalDate(value = new Date()) {
@@ -47,6 +47,7 @@ function normalizeDate(value, now = new Date()) {
 function parseStatus(marker) {
   if (marker === '●') return 'active';
   if (marker === '√') return 'completed';
+  if (marker === '?') return 'waiting';
   if (marker === '') return 'pending';
   throw invalid(`unsupported status marker ${JSON.stringify(marker)}.`);
 }
@@ -72,7 +73,7 @@ function parseWorklog(source) {
     cursor += 1;
     const entries = [];
     while (cursor < lines.length && lines[cursor] !== '') {
-      const itemMatch = /^([1-9]\d*)\.\s+\[\s*(●|√)?\s*\]\s+(.+)$/.exec(lines[cursor]);
+      const itemMatch = /^([1-9]\d*)\.\s+\[\s*(●|√|\?)?\s*\]\s+(.+)$/.exec(lines[cursor]);
       if (!itemMatch) throw invalid(`invalid item at line ${cursor + 1}.`);
       const number = Number(itemMatch[1]);
       if (!Number.isSafeInteger(number) || number !== entries.length + 1) {

package/src/worktree/backend.js

@@ -10,6 +10,12 @@ const { normalizeSha256 } = require('./streams');
 const METADATA_TOOL = 'draftgo_resource_get_metadata';
 const MAX_ERROR_BYTES = 64 * 1024;
 const MAX_JSON_BYTES = 1024 * 1024;
+const MAX_CHECKOUT_JSON_BYTES = 64 * 1024 * 1024;
+const FINAL_OPERATIONS = Object.freeze({
+  pages: Object.freeze({ checkout: 'listPageCheckout', commit: 'updatePageCommit', contentType: 'text/html; charset=utf-8' }),
+  navigations: Object.freeze({ checkout: 'listNavigationCheckout', commit: 'updateNavigationCommit', contentType: 'text/html; charset=utf-8' }),
+  docs: Object.freeze({ checkout: 'listContentArticleCheckout', commit: 'updateContentArticleCommit', contentType: 'text/html; charset=utf-8', jsonCommit: true }),
+});
 
 function isObject(value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -139,6 +145,68 @@ function firstValue(...values) {
   return values.find((value) => value !== undefined && value !== null && value !== '');
 }
 
+function operationPath(config, template, resourceId) {
+  const encoded = encodeURIComponent(String(resourceId));
+  const relative = String(template || '').replace(/\{[^}]+\}/, encoded);
+  if (!relative.startsWith('/api/')) {
+    throw new WorktreeError('INVALID_WORKFLOW_PATH', 'DraftGo checkout workflow returned an invalid API path.');
+  }
+  return new URL(relative, `${config.server.replace(/\/+$/, '')}/`).toString();
+}
+
+async function finalMetadata(config, resourceType, resourceId, session, options = {}) {
+  // Loaded lazily to avoid the API command's dependency on this backend module.
+  const { registryRevision, describeOperation } = require('../commands/api');
+  const { TOOL_NAMES, callStructured } = require('../mcp/tools');
+  const type = canonicalResourceType(resourceType);
+  const spec = FINAL_OPERATIONS[type];
+  const revision = await registryRevision(session, spec.checkout);
+  const checkout = await describeOperation(options.projectDir || process.cwd(), config, session, spec.checkout, revision);
+  const commit = await describeOperation(options.projectDir || process.cwd(), config, session, spec.commit, revision);
+  const checkoutOperation = checkout && checkout.operation || {};
+  const commitOperation = commit && commit.operation || {};
+  const checkoutResult = await callStructured(session, TOOL_NAMES.apiCall, {
+    operation_id: spec.checkout,
+    registry_revision: revision,
+    path: { id: Number(resourceId) },
+  }, options);
+  const workflow = checkoutResult && checkoutResult.workflow || {};
+  if (workflow.required !== true || workflow.workflow !== 'checkout_commit') {
+    throw new WorktreeError('INVALID_WORKFLOW_DESCRIPTOR', 'DraftGo did not return a checkout/commit workflow descriptor.');
+  }
+  const checkoutURL = operationPath(config, checkoutOperation.path || workflow.path, resourceId);
+  const response = await (options.fetch || fetch)(checkoutURL, {
+    method: String(checkoutOperation.method || 'GET').toUpperCase(),
+    headers: authHeaders(config, { Accept: 'application/json' }),
+    signal: options.signal,
+    redirect: 'error',
+  });
+  if (!response.ok) throw await errorForResponse(response, config.token || config.sat);
+  const raw = await readBounded(response, MAX_CHECKOUT_JSON_BYTES, true);
+  const value = parseJsonText(raw, 'DraftGo checkout endpoint');
+  const version = firstValue(value.content_version, value.revision);
+  const content = typeof value.content === 'string' ? value.content : null;
+  const contentURL = firstValue(value.content_url, checkoutURL);
+  const contentType = type === 'docs' ? spec.contentType : spec.contentType;
+  const size = content == null ? null : Buffer.byteLength(content, 'utf8');
+  return normalizeMetadata(config, type, resourceId, {
+    resource_type: type,
+    resource_id: String(resourceId),
+    title: value.title || '', route: value.route || null, code: value.code || null, slug: value.slug || null,
+    content_type: contentType,
+    file_extension: '.html',
+    content_size: size,
+    content_hash: value.content_hash,
+    ...(type === 'docs' ? { base_revision: version } : { base_version: version }),
+    etag: value.content_hash,
+    download_url: contentURL,
+    commit_url: operationPath(config, commitOperation.path, resourceId),
+    commit_method: String(commitOperation.method || 'PUT').toUpperCase(),
+    inline_content: content,
+    json_commit: spec.jsonCommit === true,
+  });
+}
+
 function normalizeUrl(config, value, purpose) {
   if (!value) return null;
   let url;
@@ -219,7 +287,23 @@ async function resolveMetadata(config, resourceType, resourceId, options = {}) {
   if (typeof client.listAllTools === 'function') {
     const tools = options.tools || await client.listAllTools(options);
     const found = tools.find((tool) => tool && toolNameMatches(String(tool.name || ''), METADATA_TOOL));
-    if (!found) throw new WorktreeError('MCP_TOOL_UNAVAILABLE', `${METADATA_TOOL} is not available.`);
+    if (!found) {
+      const { TOOL_NAMES, openToolSession } = require('../mcp/tools');
+      const session = await openToolSession(config, [
+        TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall,
+      ], { ...options, client });
+      return finalMetadata(config, resourceType, resourceId, session, options);
+    }
+    toolName = found.name;
+  } else if (Array.isArray(options.tools)) {
+    const found = options.tools.find((tool) => tool && toolNameMatches(String(tool.name || ''), METADATA_TOOL));
+    if (!found) {
+      const { TOOL_NAMES, openToolSession } = require('../mcp/tools');
+      const session = await openToolSession(config, [
+        TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall,
+      ], { ...options, client });
+      return finalMetadata(config, resourceType, resourceId, session, options);
+    }
     toolName = found.name;
   }
   const result = await client.toolsCall(toolName, {
@@ -233,21 +317,26 @@ function authHeaders(config, extra = {}) {
   return { Authorization: `Bearer ${config.token || config.sat}`, ...extra };
 }
 
-async function readBounded(response, maximum = MAX_ERROR_BYTES) {
+async function readBounded(response, maximum = MAX_ERROR_BYTES, rejectOverflow = false) {
   if (!response.body) return '';
   const reader = response.body.getReader();
   const chunks = [];
   let size = 0;
-  let ended = false;
-  while (size < maximum) {
-    const { done, value } = await reader.read();
-    if (done) { ended = true; break; }
-    const chunk = Buffer.from(value);
-    const remaining = maximum - size;
-    chunks.push(chunk.subarray(0, remaining));
-    size += Math.min(chunk.length, remaining);
-  }
-  if (!ended) await reader.cancel().catch(() => {});
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = Buffer.from(value);
+      if (size + chunk.length > maximum) {
+        if (rejectOverflow) throw new WorktreeError('RESPONSE_TOO_LARGE',
+          'DraftGo response exceeds the explicit ' + maximum + '-byte limit; local content was preserved.', { max_bytes: maximum });
+        chunks.push(chunk.subarray(0, maximum - size));
+        break;
+      }
+      chunks.push(chunk);
+      size += chunk.length;
+    }
+  } finally { await reader.cancel().catch(() => {}); }
   return Buffer.concat(chunks).toString('utf8');
 }
 
@@ -264,10 +353,15 @@ async function errorForResponse(response, token) {
 }
 
 async function download(config, metadata, options = {}) {
+  const raw = metadata.raw && typeof metadata.raw === 'object' ? metadata.raw : {};
+  if (typeof raw.inline_content === 'string') {
+    return new Response(raw.inline_content, { headers: { 'content-type': metadata.content_type } });
+  }
   const response = await (options.fetch || fetch)(metadata.download_url, {
     method: 'GET',
     headers: authHeaders(config, { Accept: '*/*' }),
     signal: options.signal,
+    redirect: 'error',
   });
   if (!response.ok) throw await errorForResponse(response, config.token || config.sat);
   return response;
@@ -294,15 +388,31 @@ async function commit(config, metadata, localPath, current, options = {}) {
   if (metadata.base_version != null) headers['DraftGo-Base-Version'] = String(metadata.base_version);
   if (metadata.base_revision != null) headers['DraftGo-Base-Revision'] = String(metadata.base_revision);
 
+  let body;
+  let duplex;
+  if (metadata.raw && metadata.raw.json_commit === true) {
+    const content = fs.readFileSync(localPath, 'utf8');
+    body = JSON.stringify({
+      content,
+      ...(metadata.base_revision != null ? { base_revision: metadata.base_revision } : {}),
+      ...(metadata.base_revision == null && metadata.content_hash ? { base_hash: metadata.content_hash } : {}),
+    });
+    headers['Content-Type'] = 'application/json';
+    headers['Content-Length'] = String(Buffer.byteLength(body, 'utf8'));
+  } else {
+    body = fs.createReadStream(localPath);
+    duplex = 'half';
+  }
   const response = await (options.fetch || fetch)(metadata.commit_url, {
     method: metadata.commit_method,
     headers,
-    body: fs.createReadStream(localPath),
-    duplex: 'half',
+    body,
+    ...(duplex ? { duplex } : {}),
     signal: options.signal,
+    redirect: 'error',
   });
   if (!response.ok) throw await errorForResponse(response, config.token || config.sat);
-  const text = await readBounded(response, MAX_JSON_BYTES);
+  const text = await readBounded(response, MAX_JSON_BYTES, true);
   if (!text.trim()) return {};
   return parseJsonText(text, 'DraftGo commit endpoint');
 }
@@ -314,6 +424,8 @@ function nodeReadable(response) {
 
 module.exports = {
   METADATA_TOOL,
+  readBounded,
+  MAX_CHECKOUT_JSON_BYTES,
   toolNameMatches,
   unwrapToolResult,
   unwrapProtectedResult,