draftgo-cli 3.0.49 → 3.0.52

package/src/context/index.js

@@ -15,6 +15,7 @@ const LONG_CONTENT_RESOURCE_TYPES = Object.freeze([
   'pages',
   'navigations',
   'docs/articles',
+  'custom_services',
 ]);
 const DB_META_LIST_PATH = '/api/db-meta';
 const DB_META_PAGE_SIZE = 100;
@@ -292,6 +293,7 @@ function rawQuery(session, expectedName, args, server, options = {}) {
       tool,
       canonical_tool: expectedName,
       arguments: args,
+      fetched_at: new Date().toISOString(),
     },
     result,
   }));
@@ -600,28 +602,41 @@ async function collectContext(projectDir, taskValue, options = {}) {
   }
 
   return {
-    schema_version: '1.1',
+    schema_version: '2.0',
     task,
-    reference_bundle: {
+    bundled_references: {
       source: 'draftgo-cli',
       version: pkg.version,
       installed_skill_version: installedSkillVersion,
       synchronized: installedSkillVersion == null ? null : installedSkillVersion === pkg.version,
+      sections: references.map((entry) => ({
+        ...entry,
+        source: { ...entry.source, source: 'cli_bundle', version: pkg.version },
+      })),
     },
-    references,
-    live: {
-      session: {
-        server: config.server,
-        protocol_version: session.client.protocolVersion,
-      },
-      project,
-      resources,
-      api,
-      data_structures: dataStructures,
+    live_project: project,
+    live_resources: resources,
+    live_apis: api,
+    live_db_meta: dataStructures,
+    live_session: {
+      server: config.server,
+      protocol_version: session.client.protocolVersion,
+      fetched_at: new Date().toISOString(),
     },
   };
 }
 
+function compactContext(value) {
+  if (Array.isArray(value)) return value.map(compactContext);
+  if (!value || typeof value !== 'object') return value;
+  if (value.source && Object.prototype.hasOwnProperty.call(value, 'result')) {
+    return { source: compactContext(value.source), value: structuredValueFromRaw(value.result) };
+  }
+  const result = {};
+  for (const [key, child] of Object.entries(value)) result[key] = compactContext(child);
+  return result;
+}
+
 function readInstalledSkillVersion(projectDir) {
   return readInstalledVersion(projectDir);
 }
@@ -643,4 +658,5 @@ module.exports = {
   collectDataStructures,
   readInstalledSkillVersion,
   collectContext,
+  compactContext,
 };

package/src/customServices.js

@@ -0,0 +1,246 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const AdmZip = require('adm-zip');
+const { loadProjectConfig } = require('./projectConfig');
+const { WorktreeError } = require('./worktree/errors');
+
+const FILES = ['service.go', 'go.mod', 'go.sum', 'service.json'];
+function root(projectDir) { return path.join(projectDir, '.draftgo', 'worktree', 'custom-services'); }
+function baseRoot(projectDir) { return path.join(projectDir, '.draftgo', 'worktree', '.base', 'custom-services'); }
+function conflictRoot(projectDir, id) { return path.join(projectDir, '.draftgo', 'conflicts', 'custom-services', safe(id)); }
+function manifestPath(projectDir) { return path.join(root(projectDir), 'manifest.json'); }
+function safe(value) { return String(value).replace(/[^A-Za-z0-9._-]+/g, '_').replace(/^\.+/, '').slice(0, 80) || 'service'; }
+function sha256(value) { return crypto.createHash('sha256').update(value).digest('hex'); }
+function relative(projectDir, file) { return path.relative(projectDir, file).replace(/\\/g, '/'); }
+function loadManifest(projectDir) {
+  const file = manifestPath(projectDir);
+  if (!fs.existsSync(file)) return { schema_version: 1, entries: {} };
+  const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!value || value.schema_version !== 1 || !value.entries || Array.isArray(value.entries)) throw new WorktreeError('INVALID_WORKTREE_MANIFEST', 'Invalid custom-service manifest.');
+  return value;
+}
+function atomicWrite(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(temporary, value); fs.renameSync(temporary, file);
+}
+function saveManifest(projectDir, value) { value.updated_at = new Date().toISOString(); atomicWrite(manifestPath(projectDir), `${JSON.stringify(value, null, 2)}\n`); }
+function entryKey(id) { return String(id); }
+function serviceDir(projectDir, id, slug) { return path.join(root(projectDir), `${safe(slug || id)}-${safe(id)}`); }
+function serviceBaseDir(projectDir, id) { return path.join(baseRoot(projectDir), safe(id)); }
+function parseEnvelope(text, response) {
+  let payload = {};
+  try { payload = text ? JSON.parse(text) : {}; } catch { payload = { message: text }; }
+  if (!response.ok || (payload.code && Number(payload.code) >= 400)) {
+    const details = payload.error?.details || payload.details || payload;
+    const error = new WorktreeError(payload.error?.code || payload.code || `HTTP_${response.status}`, payload.error?.message || payload.message || `DraftGo HTTP ${response.status}`, details);
+    error.status = response.status; throw error;
+  }
+  return payload.data === undefined ? payload : payload.data;
+}
+async function jsonRequest(config, method, endpoint, body, options = {}) {
+  const response = await (options.fetch || fetch)(`${config.server.replace(/\/+$/, '')}/api/${endpoint.replace(/^\/+/, '')}`, {
+    method, headers: { Authorization: `Bearer ${config.token || config.sat}`, ...(body === undefined ? {} : { 'Content-Type': 'application/json' }) },
+    body: body === undefined ? undefined : JSON.stringify(body), signal: options.signal,
+  });
+  return parseEnvelope(await response.text(), response);
+}
+async function metadata(config, id, options = {}) { return jsonRequest(config, 'GET', `content/custom-services/${encodeURIComponent(id)}/checkout`, undefined, options); }
+async function download(config, metadataValue, options = {}) {
+  const url = new URL(metadataValue.download_url, `${config.server.replace(/\/+$/, '')}/`).toString();
+  const response = await (options.fetch || fetch)(url, { headers: { Authorization: `Bearer ${config.token || config.sat}` }, signal: options.signal });
+  if (!response.ok) parseEnvelope(await response.text(), response);
+  const archive = Buffer.from(await response.arrayBuffer());
+  if (sha256(archive) !== metadataValue.content_hash) throw new WorktreeError('HASH_MISMATCH', 'Downloaded custom-service archive hash mismatch.');
+  return archive;
+}
+function archiveFiles(archive) {
+  const zip = new AdmZip(archive); const result = {};
+  for (const filename of FILES) {
+    const entry = zip.getEntry(filename);
+    if (!entry || entry.isDirectory) throw new WorktreeError('INVALID_SERVICE_ARCHIVE', `Custom-service archive is missing ${filename}.`);
+    result[filename] = entry.getData();
+  }
+  const unexpected = zip.getEntries().filter((entry) => !entry.isDirectory && !FILES.includes(entry.entryName));
+  if (unexpected.length) throw new WorktreeError('INVALID_SERVICE_ARCHIVE', `Unexpected archive entry ${unexpected[0].entryName}.`);
+  JSON.parse(result['service.json'].toString('utf8'));
+  return result;
+}
+function writeFiles(directory, files) { fs.mkdirSync(directory, { recursive: true }); for (const filename of FILES) atomicWrite(path.join(directory, filename), files[filename]); }
+function readFiles(directory) {
+  const result = {};
+  for (const filename of FILES) {
+    const file = path.join(directory, filename);
+    if (!fs.existsSync(file)) throw new WorktreeError('SERVICE_FILE_MISSING', `Custom-service worktree is missing ${filename}.`);
+    result[filename] = fs.readFileSync(file);
+  }
+  try { JSON.parse(result['service.json'].toString('utf8')); } catch (error) { throw new WorktreeError('INVALID_SERVICE_METADATA', `service.json is invalid: ${error.message}`); }
+  return result;
+}
+function createArchive(files) {
+  const zip = new AdmZip();
+  for (const filename of FILES) zip.addFile(filename, files[filename]);
+  return zip.toBuffer();
+}
+function fileHashes(files) { return Object.fromEntries(FILES.map((filename) => [filename, sha256(files[filename])])); }
+function checkoutHash(files) { return sha256(createArchive(files)); }
+function remoteFileHashes(remote) {
+  return { 'service.go': remote.source_hash, 'go.mod': remote.go_mod_hash, 'go.sum': remote.go_sum_hash, 'service.json': remote.metadata_hash };
+}
+function filesMatchRemote(files, remote) {
+  const local = fileHashes(files); const expected = remoteFileHashes(remote);
+  return FILES.every((filename) => expected[filename] && local[filename] === expected[filename]);
+}
+function localState(entry) {
+  const local = readFiles(entry.local_dir); const base = readFiles(entry.base_dir);
+  const localHashes = fileHashes(local); const baseHashes = fileHashes(base);
+  const baseValid = FILES.every((filename) => baseHashes[filename] === entry.file_hashes[filename]);
+  return { local, base, local_hashes: localHashes, base_hashes: baseHashes, base_valid: baseValid,
+    modified: FILES.some((filename) => localHashes[filename] !== baseHashes[filename]) };
+}
+async function checkout(projectDir, ids, options = {}) {
+  const config = options.config || loadProjectConfig(projectDir); const manifest = loadManifest(projectDir); const results = [];
+  for (const id of ids) {
+    const remote = await metadata(config, id, options); const key = entryKey(id); const old = manifest.entries[key];
+    if (old && fs.existsSync(old.local_dir) && !options.force && localState(old).modified) {
+      throw new WorktreeError('LOCAL_CHANGES_PRESENT', `Refusing to replace locally modified custom service ${id}; commit it or use checkout --force.`);
+    }
+    const archive = await download(config, remote, options); const files = archiveFiles(archive);
+    const service = JSON.parse(files['service.json'].toString('utf8')); const localDir = old?.local_dir || serviceDir(projectDir, id, service.slug); const baseDir = serviceBaseDir(projectDir, id);
+    writeFiles(localDir, files); writeFiles(baseDir, files);
+    const entry = { server: config.server, resource_type: 'custom_services', resource_id: String(id), title: remote.title,
+      slug: service.slug, local_dir: localDir, base_dir: baseDir, local_path: relative(projectDir, localDir), base_path: relative(projectDir, baseDir),
+      content_type: remote.content_type, base_revision: remote.base_revision, base_etag: remote.etag,
+      base_hash: remote.content_hash, file_hashes: fileHashes(files), checkout_source: remote.checkout_source,
+      checked_out_at: new Date().toISOString(), updated_at: remote.updated_at, updated_by: remote.updated_by };
+    manifest.entries[key] = entry; saveManifest(projectDir, manifest); results.push(entry);
+  }
+  return results;
+}
+function getEntry(projectDir, id) { return loadManifest(projectDir).entries[entryKey(id)] || null; }
+function diffFile(baseFile, localFile, filename) {
+  if (fs.readFileSync(baseFile).equals(fs.readFileSync(localFile))) return '';
+  const result = spawnSync('git', ['diff', '--no-index', '--', baseFile, localFile], { encoding: 'utf8', windowsHide: true });
+  if (result.error || ![0, 1].includes(result.status)) return `${filename}: changed\n`;
+  return String(result.stdout || '').replaceAll(baseFile, `a/${filename}`).replaceAll(localFile, `b/${filename}`);
+}
+function diff(projectDir, id) {
+  const entry = getEntry(projectDir, id); if (!entry) throw new WorktreeError('RESOURCE_NOT_CHECKED_OUT', `Custom service ${id} is not checked out.`);
+  const state = localState(entry); const differences = FILES.map((filename) => diffFile(path.join(entry.base_dir, filename), path.join(entry.local_dir, filename), filename)).filter(Boolean);
+  return { changed: differences.length > 0, entry, files: FILES.map((filename) => ({ filename, changed: state.local_hashes[filename] !== state.base_hashes[filename] })), output: differences.join('\n') };
+}
+async function writeConflict(projectDir, entry, remote, archive) {
+  const directory = conflictRoot(projectDir, entry.resource_id); const baseDir = path.join(directory, 'base'); const localDir = path.join(directory, 'local'); const remoteDir = path.join(directory, 'remote');
+  writeFiles(baseDir, readFiles(entry.base_dir)); writeFiles(localDir, readFiles(entry.local_dir)); writeFiles(remoteDir, archiveFiles(archive));
+  const record = { schema_version: 1, status: 'unresolved', code: 'RESOURCE_VERSION_CONFLICT', resource_type: 'custom_services', resource_id: entry.resource_id,
+    base_path: relative(projectDir, baseDir), local_path: relative(projectDir, localDir), remote_path: relative(projectDir, remoteDir), worktree_local_path: entry.local_path,
+    expected_revision: entry.base_revision, actual_revision: remote.base_revision, expected_hash: entry.base_hash, actual_hash: remote.content_hash,
+    actual_etag: remote.etag, actual_updated_at: remote.updated_at, created_at: new Date().toISOString() };
+  atomicWrite(path.join(directory, 'conflict.json'), `${JSON.stringify(record, null, 2)}\n`); return record;
+}
+function serviceConflicts(projectDir, options = {}) {
+  const directory = path.join(projectDir, '.draftgo', 'conflicts', 'custom-services'); if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+    const file = path.join(directory, entry.name, 'conflict.json'); if (!fs.existsSync(file)) return [];
+    const record = JSON.parse(fs.readFileSync(file, 'utf8')); return options.all || record.status === 'unresolved' ? [{ ...record, manifest_path: relative(projectDir, file) }] : [];
+  });
+}
+function showConflict(projectDir, id) {
+  const record = serviceConflicts(projectDir, { all: true }).find((entry) => String(entry.resource_id) === String(id));
+  if (!record) throw new WorktreeError('CONFLICT_NOT_FOUND', `No custom-service conflict found for ${id}.`); return record;
+}
+function resolveConflict(projectDir, id) {
+  const record = showConflict(projectDir, id); if (record.status !== 'unresolved') throw new WorktreeError('CONFLICT_ALREADY_RESOLVED', `Custom-service conflict ${id} is already resolved.`);
+  const manifest = loadManifest(projectDir); const entry = manifest.entries[entryKey(id)]; if (!entry) throw new WorktreeError('RESOURCE_NOT_CHECKED_OUT', `Custom service ${id} is not checked out.`);
+  const remoteDir = path.resolve(projectDir, record.remote_path); const remoteFiles = readFiles(remoteDir); writeFiles(entry.base_dir, remoteFiles);
+  entry.file_hashes = fileHashes(remoteFiles); entry.base_hash = record.actual_hash; entry.base_revision = record.actual_revision; entry.base_etag = record.actual_etag; entry.updated_at = record.actual_updated_at; entry.conflict_resolved_at = new Date().toISOString();
+  manifest.entries[entryKey(id)] = entry; saveManifest(projectDir, manifest);
+  const resolved = { ...record, status: 'resolved', resolved_at: new Date().toISOString() }; delete resolved.manifest_path;
+  atomicWrite(path.resolve(projectDir, record.manifest_path), `${JSON.stringify(resolved, null, 2)}\n`); return { ...resolved, manifest_path: record.manifest_path };
+}
+async function commit(projectDir, ids, options = {}) {
+  const config = options.config || loadProjectConfig(projectDir); const manifest = loadManifest(projectDir); const results = [];
+  const prepared = [];
+  for (const id of ids) {
+    const entry = manifest.entries[entryKey(id)]; if (!entry) throw new WorktreeError('RESOURCE_NOT_CHECKED_OUT', `Custom service ${id} is not checked out.`);
+    if (entry.server !== config.server) throw new WorktreeError('CHECKOUT_SERVER_MISMATCH', 'Checkout belongs to a different DraftGo server.');
+    const state = localState(entry); if (!state.base_valid) throw new WorktreeError('BASE_HASH_MISMATCH', `Custom service ${id} base does not match its manifest.`);
+    if (!state.modified) { prepared.push({ id, entry, state, unchanged: true }); continue; }
+    const current = await metadata(config, id, options);
+    if (current.content_hash !== entry.base_hash || String(current.base_revision) !== String(entry.base_revision)) {
+      const remoteArchive = await download(config, current, options); const conflict = await writeConflict(projectDir, entry, current, remoteArchive);
+      throw new WorktreeError('RESOURCE_VERSION_CONFLICT', `Custom service ${id} changed remotely; conflict materials were preserved.`, conflict);
+    }
+    prepared.push({ id, entry, state, current, archive: createArchive(state.local) });
+  }
+  for (const item of prepared) {
+    const { id, entry, current, archive } = item;
+    if (item.unchanged) { results.push({ resource_type: 'custom_services', resource_id: String(id), status: 'unchanged' }); continue; }
+    const url = new URL(current.commit_url, `${config.server.replace(/\/+$/, '')}/`).toString();
+    const response = await (options.fetch || fetch)(url, { method: 'PUT', headers: { Authorization: `Bearer ${config.token || config.sat}`, 'Content-Type': current.content_type,
+      'Content-Length': String(archive.length), 'X-Content-SHA256': sha256(archive), 'If-Match': entry.base_etag }, body: archive, signal: options.signal });
+    let committed;
+    try { committed = parseEnvelope(await response.text(), response); } catch (error) {
+      if ([409, 412].includes(error.status)) { const latest = await metadata(config, id, options); const remoteArchive = await download(config, latest, options); error.details = await writeConflict(projectDir, entry, latest, remoteArchive); }
+      throw error;
+    }
+    const canonicalArchive = await download(config, committed, options); const canonicalFiles = archiveFiles(canonicalArchive);
+    writeFiles(entry.local_dir, canonicalFiles); writeFiles(entry.base_dir, canonicalFiles);
+    entry.file_hashes = fileHashes(canonicalFiles); entry.base_hash = committed.content_hash;
+    entry.base_revision = committed.base_revision; entry.base_etag = committed.etag; entry.updated_at = committed.updated_at; entry.updated_by = committed.updated_by; entry.committed_at = new Date().toISOString();
+    manifest.entries[entryKey(id)] = entry; saveManifest(projectDir, manifest);
+    results.push({ resource_type: 'custom_services', resource_id: String(id), status: 'committed', revision: committed.base_revision, hash: committed.content_hash });
+  }
+  return results;
+}
+async function inspectRemote(projectDir, options = {}) {
+  const config = options.config || loadProjectConfig(projectDir);
+  const requested = options.ids ? new Set(options.ids.map(String)) : null;
+  const entries = Object.values(loadManifest(projectDir).entries)
+    .filter((entry) => !requested || requested.has(String(entry.resource_id)));
+  const result = [];
+  for (const entry of entries) {
+    const state = localState(entry); const remote = await metadata(config, entry.resource_id, options); const remoteMatches = remote.content_hash === entry.base_hash && String(remote.base_revision) === String(entry.base_revision);
+    const localArchiveHash = checkoutHash(state.local); let status;
+    if (remoteMatches) status = state.modified ? 'local_modified' : 'clean';
+    else if (!state.modified) status = 'remote_changed';
+    else if (filesMatchRemote(state.local, remote)) status = 'committed_unrecorded';
+    else status = 'diverged';
+    result.push({ ...entry, state: status, remote_hash: remote.content_hash, remote_revision: remote.base_revision, remote_etag: remote.etag, local_hash: localArchiveHash });
+  }
+  return result;
+}
+async function validate(projectDir, id, options = {}) {
+  const config = options.config || loadProjectConfig(projectDir); await commit(projectDir, [id], options);
+  const result = await jsonRequest(config, 'POST', `scripts/${encodeURIComponent(id)}/draft/validate`, {}, options);
+  await checkout(projectDir, [id], { ...options, config, force: true }); return result;
+}
+function parseHandler(handler) {
+  const value = String(handler || '').trim(); if (!value) return undefined;
+  const parts = value.split(':');
+  if (parts[0] === 'route' && parts.length >= 3) return { kind: 'route', method: parts[1], path: parts.slice(2).join(':') };
+  if (parts[0] === 'event') return { kind: 'event', event: parts.slice(1).join(':') };
+  if (parts[0] === 'scheduled') return { kind: 'scheduled', name: parts.slice(1).join(':') };
+  return { kind: 'manual', name: value };
+}
+async function test(projectDir, id, input = {}, options = {}) {
+  const config = options.config || loadProjectConfig(projectDir); await validate(projectDir, id, options);
+  return jsonRequest(config, 'POST', `scripts/${encodeURIComponent(id)}/draft/execute`, {
+    input, selector: parseHandler(options.handler), headers: options.headers, user: options.user,
+    test_write: Boolean(options.testWrite), side_effect_policy: options.sideEffectPolicy || 'deny',
+  }, options);
+}
+async function publish(projectDir, ids, options = {}) {
+  const config = options.config || loadProjectConfig(projectDir); const results = [];
+  for (const id of ids) {
+    await validate(projectDir, id, options); results.push(await jsonRequest(config, 'POST', `scripts/${encodeURIComponent(id)}/draft/publish`, {}, options));
+    await checkout(projectDir, [id], { ...options, config, force: true });
+  }
+  return results;
+}
+
+module.exports = { FILES, checkout, commit, diff, validate, test, publish, inspectRemote, loadManifest, getEntry, metadata, archiveFiles, createArchive, serviceConflicts, showConflict, resolveConflict, parseHandler };

package/src/projectMap.js

@@ -6,6 +6,7 @@ const path = require('path');
 const parse5 = require('parse5');
 const { loadManifest, absolutePath } = require('./worktree/manifest');
 const { mediaType } = require('./worktree/types');
+const { validateInlineScripts } = require('./worktree/inlineScripts');
 
 function normalizeRoute(route) {
   if (!route || typeof route !== 'string') return '';
@@ -121,7 +122,7 @@ function worktreeFiles(projectDir, directory) {
     .map((entry) => path.join(root, entry.name));
 }
 
-function analyzeProject(projectDir) {
+function analyzeProject(projectDir, options = {}) {
   const map = buildProjectMap(projectDir);
   const errors = [];
   const warnings = [];
@@ -132,7 +133,12 @@ function analyzeProject(projectDir) {
   };
   const registered = new Set();
 
-  for (const entry of map.checkouts) {
+  const resourceKeys = options.resourceKeys ? new Set(options.resourceKeys) : null;
+  const selectedCheckouts = resourceKeys
+    ? map.checkouts.filter((entry) => resourceKeys.has(`${entry.resource_type}:${entry.resource_id}`))
+    : map.checkouts;
+
+  for (const entry of selectedCheckouts) {
     let local;
     let base;
     try {
@@ -176,18 +182,24 @@ function analyzeProject(projectDir) {
         const position = issue.line ? ` at ${issue.line}:${issue.column || 1}` : '';
         addWarning('DG-HTML-001', 'high', `${entry.resource_type} ${entry.resource_id}: ${issue.code}${position}.`);
       }
+      for (const issue of validateInlineScripts(source).slice(0, 20)) {
+        errors.push(`${entry.resource_type} ${entry.resource_id}: inline script #${issue.script} `
+          + `(${issue.script_type}) ${issue.message} at ${entry.local_path}:${issue.line}:${issue.column}.`);
+      }
     }
   }
 
-  for (const directory of ['pages', 'navigations', 'docs']) {
-    for (const file of worktreeFiles(projectDir, directory)) {
-      if (!registered.has(path.resolve(file).toLowerCase())) {
-        const relative = path.relative(projectDir, file).replace(/\\/g, '/');
-        addWarning('DG-WORKTREE-ORPHAN', 'high', `Unregistered worktree file: ${relative}.`);
+  if (!resourceKeys) {
+    for (const directory of ['pages', 'navigations', 'docs']) {
+      for (const file of worktreeFiles(projectDir, directory)) {
+        if (!registered.has(path.resolve(file).toLowerCase())) {
+          const relative = path.relative(projectDir, file).replace(/\\/g, '/');
+          addWarning('DG-WORKTREE-ORPHAN', 'high', `Unregistered worktree file: ${relative}.`);
+        }
       }
     }
   }
-  for (const page of map.pages) {
+  for (const page of map.pages.filter((entry) => !resourceKeys || resourceKeys.has(`pages:${entry.resource_id}`))) {
     if (!page.route || page.route === '/' || page.area === 'system') continue;
     const sources = map.routeRefs[normalizeRoute(page.route)] || [];
     if (!sources.some((source) => source.startsWith('navigations:'))) {

package/src/runtimeFiles.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SCHEMA_VERSION = 1;
+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 load(projectDir) {
+  const file = manifestPath(projectDir);
+  if (!fs.existsSync(file)) return { schema_version: SCHEMA_VERSION, entries: [] };
+  const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!value || value.schema_version !== SCHEMA_VERSION || !Array.isArray(value.entries)) throw new Error('Invalid .draftgo/runtime-manifest.json.');
+  return value;
+}
+function replaceFile(temporary, file, rename = fs.renameSync, wait = (ms) => Atomics.wait(sleepBuffer, 0, 0, ms)) {
+  for (let attempt = 0; ; attempt += 1) {
+    try { rename(temporary, file); return; } catch (error) {
+      if (!RETRYABLE_RENAME_CODES.has(error.code) || attempt >= 5) throw error;
+      wait(20 * (attempt + 1));
+    }
+  }
+}
+function save(projectDir, value) {
+  const file = manifestPath(projectDir); fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`);
+  try { replaceFile(temporary, file); } catch (error) {
+    try { fs.rmSync(temporary, { force: true }); } catch { /* retain the original rename error */ }
+    throw error;
+  }
+}
+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.');
+  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;
+}
+function managedPath(projectDir, ...parts) { const file = path.join(draftgoRoot(projectDir), ...parts); if (!inside(draftgoRoot(projectDir), file)) throw new Error('Managed path escapes .draftgo.'); return file; }
+module.exports = { SCHEMA_VERSION, draftgoRoot, manifestPath, load, save, register, managedPath, inside, replaceFile };

package/src/skill.js

@@ -187,15 +187,6 @@ function validateRenderedSkill(assetDir) {
 }
 
 function ensureRuntime(projectDir) {
-  const dg = paths.dgDir(projectDir);
-  ensureDir(dg);
-  for (const sub of ['Task', 'lessons']) {
-    ensureDir(path.join(dg, sub));
-  }
-  const changelog = path.join(dg, 'changelog.md');
-  if (!exists(changelog)) {
-    writeText(changelog, '');
-  }
   appendGitignoreLine(projectDir, '.draftgo/config.json');
   appendGitignoreLine(projectDir, '.draftgo/token');
   appendGitignoreLine(projectDir, '.draftgo/worktree/');

package/src/workspaceHealth.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const runtime = require('./runtimeFiles');
+
+const PROTECTED_PREFIXES = ['worktree/', 'conflicts/', 'Task/', 'lessons/', 'tmp/', 'config.json', 'changelog.md', 'story.yaml', '.version', 'runtime-manifest.json'];
+function workspaceHealth(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;
+  const visit = (directory) => {
+    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 });
+        visit(absolute); continue;
+      }
+      if (!item.isFile()) continue;
+      const size = fs.statSync(absolute).size; summary.total_bytes += size;
+      const managed = registered.has(relative) || PROTECTED_PREFIXES.some((prefix) => relative === prefix || relative.startsWith(prefix));
+      if (managed) summary.managed_files += 1; else summary.unknown_files += 1;
+      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 });
+    }
+  };
+  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 };

package/src/worktree/inlineScripts.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const vm = require('vm');
+const { spawnSync } = require('child_process');
+const parse5 = require('parse5');
+
+const DATA_SCRIPT_TYPES = new Set([
+  'application/json',
+  'application/ld+json',
+  'importmap',
+  'speculationrules',
+]);
+
+function attribute(node, name) {
+  const item = (node.attrs || []).find((candidate) => candidate.name.toLowerCase() === name);
+  return item ? item.value : '';
+}
+
+function scriptSource(node) {
+  return (node.childNodes || [])
+    .filter((child) => child.nodeName === '#text')
+    .map((child) => child.value || '')
+    .join('');
+}
+
+function collectInlineScripts(html) {
+  const document = parse5.parse(String(html || ''), { sourceCodeLocationInfo: true });
+  const scripts = [];
+  const visit = (node) => {
+    if (node.tagName === 'script' && !attribute(node, 'src')) {
+      const type = attribute(node, 'type').trim().toLowerCase();
+      if (!DATA_SCRIPT_TYPES.has(type) && (!type || type === 'module' || /(?:java|ecma)script/.test(type))) {
+        const location = node.sourceCodeLocation || {};
+        const startTag = location.startTag || {};
+        scripts.push({
+          index: scripts.length + 1,
+          type: type === 'module' ? 'module' : 'classic',
+          source: scriptSource(node),
+          startLine: startTag.endLine || location.startLine || 1,
+          startColumn: startTag.endCol || 1,
+        });
+      }
+    }
+    for (const child of node.childNodes || []) visit(child);
+    if (node.content) visit(node.content);
+  };
+  visit(document);
+  return scripts;
+}
+
+function syntaxPosition(message) {
+  const line = String(message || '').match(/(?:\[stdin\]|inline-script):(\d+)(?::(\d+))?/);
+  if (line) return { line: Number(line[1]), column: Number(line[2] || 1) };
+  const caretLines = String(message || '').split(/\r?\n/);
+  const caretIndex = caretLines.findIndex((value) => /^\s*\^/.test(value));
+  return { line: null, column: caretIndex > 0 ? caretLines[caretIndex].indexOf('^') + 1 : null };
+}
+
+function conciseMessage(error) {
+  const lines = String(error && (error.stderr || error.message) || error || '').split(/\r?\n/);
+  return lines.find((line) => /^SyntaxError:/.test(line))
+    || lines.find((line) => line.trim() && !/^\s*at\s/.test(line))
+    || 'Invalid JavaScript syntax';
+}
+
+function validateInlineScripts(html) {
+  const issues = [];
+  for (const script of collectInlineScripts(html)) {
+    if (!script.source.trim()) continue;
+    let failure = null;
+    if (script.type === 'module') {
+      const result = spawnSync(process.execPath, ['--check', '--input-type=module'], {
+        input: script.source,
+        encoding: 'utf8',
+        windowsHide: true,
+      });
+      if (result.error || result.status !== 0) failure = { message: result.stderr || result.stdout || result.error.message };
+    } else {
+      try { new vm.Script(script.source, { filename: 'inline-script' }); }
+      catch (error) { failure = error; }
+    }
+    if (!failure) continue;
+    const diagnostic = failure.stack || failure.message;
+    const position = syntaxPosition(diagnostic);
+    issues.push({
+      code: 'DG-JS-001',
+      script: script.index,
+      script_type: script.type,
+      line: position.line ? script.startLine + position.line - 1 : script.startLine,
+      column: position.column
+        ? position.column + (position.line === 1 ? script.startColumn - 1 : 0)
+        : script.startColumn,
+      message: conciseMessage(failure),
+    });
+  }
+  return issues;
+}
+
+module.exports = { DATA_SCRIPT_TYPES, collectInlineScripts, validateInlineScripts };

package/src/worktree/status.js

@@ -101,7 +101,7 @@ async function inspectRemoteCheckouts(projectDir, options = {}) {
   const session = options.backend && typeof options.backend.resolveMetadata === 'function'
     ? { client: options.client || {}, tools: options.tools || [] }
     : await openMetadataSession(config, options);
-  const entries = Object.values(manifest.entries);
+  const entries = options.entries || Object.values(manifest.entries);
   return Promise.all(entries.map(async (entry) => {
     const remote = await backend.resolveMetadata(config, entry.resource_type, entry.resource_id, {
       ...options,