codex-overleaf-link 2.4.1 → 2.5.1

package/native-host/src/writingStyleRuntime.js

@@ -0,0 +1,475 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { Worker } = require('node:worker_threads');
+const { getCodexOverleafHome } = require('./nativeHostPlatform');
+const Shared = require('../../extension/src/shared/writingStyle');
+const REFERENCE_LIMITS = Shared.REFERENCE_LIMITS;
+const StyleProfile = require('./writingStyleProfile');
+const { writeJson, withConfigLock } = require('./writingStyleStore');
+const sha = value => crypto.createHash('sha256').update(value).digest('hex');
+const fail = (code, message) => Object.assign(new Error(message), { code });
+const checkAbort = signal => { if (signal?.aborted) throw signal.reason || fail('codex_cancelled', 'Writing-style generation was cancelled.'); };
+
+function scopeOf(params, env) {
+  const accountScopeId = String(params.accountScopeId || '');
+  const projectId = String(params.projectId || '');
+  if (!accountScopeId || accountScopeId.length > 256 || !/^[a-zA-Z0-9_-]{1,80}$/.test(projectId)) {
+    throw fail('writing_style_scope_invalid', 'A current account and project are required.');
+  }
+  const base = path.resolve(env.CODEX_OVERLEAF_WRITING_STYLE_ROOT || path.join(getCodexOverleafHome({ env }), 'writing-styles'));
+  const root = path.join(base, sha(accountScopeId).slice(0, 32), projectId);
+  fs.mkdirSync(base, { recursive: true, mode: 0o700 });
+  let cursor = base;
+  for (const part of path.relative(base, root).split(path.sep)) {
+    cursor = path.join(cursor, part);
+    try { if (fs.lstatSync(cursor).isSymbolicLink()) throw fail('writing_style_path_invalid', 'Writing-style storage cannot use symlinks.'); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    fs.mkdirSync(cursor, { recursive: true, mode: 0o700 });
+  }
+  return { root, accountScopeId, projectId };
+}
+
+function readJson(file, fallback, max = 2 * 1024 * 1024) {
+  try {
+    if (fs.statSync(file).size > max) throw fail('writing_style_data_too_large', 'Writing-style data exceeds its limit.');
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) { if (error.code === 'ENOENT') return fallback; throw error; }
+}
+
+function config(scope) { return readJson(path.join(scope.root, 'config.json'), { revision: 0, enabled: false, version: '' }); }
+function saveConfig(scope, value) { const next = { ...value, revision: (Number(value.revision) || 0) + 1 }; writeJson(path.join(scope.root, 'config.json'), next); return next; }
+function alive(pid) { try { process.kill(Number(pid), 0); return true; } catch (error) { return error.code !== 'ESRCH'; } }
+
+function versionRoot(scope, version) {
+  if (!/^[a-f0-9-]{36}$/i.test(version || '')) throw fail('writing_style_version_invalid', 'Writing-style version is invalid.');
+  const target = path.join(scope.root, 'versions', version);
+  if (fs.lstatSync(target).isSymbolicLink()) throw fail('writing_style_path_invalid', 'Writing-style versions cannot be symlinks.');
+  return target;
+}
+
+function readBundle(scope, version, bundleHash) {
+  const root = versionRoot(scope, version);
+  return readBundleAtRoot(scope, version, root, bundleHash);
+}
+
+function readBundleAtRoot(scope, version, root, bundleHash) {
+  const raw = fs.readFileSync(path.join(root, 'manifest.json'), 'utf8');
+  if (raw.length > 100000 || (bundleHash && sha(raw) !== bundleHash)) throw fail('writing_style_changed', 'The saved writing skill changed. Rebuild it in General settings.');
+  const manifest = JSON.parse(raw);
+  if (manifest.projectId !== scope.projectId || manifest.accountHash !== sha(scope.accountScopeId) || manifest.version !== version) {
+    throw fail('writing_style_scope_invalid', 'The writing skill does not belong to this project and account.');
+  }
+  return { root, manifest, bundleHash: sha(raw) };
+}
+
+function publicBundle(scope, bundle) {
+  const { manifest, bundleHash } = bundle;
+  return { label: manifest.label, createdAt: manifest.createdAt,
+    model: manifest.model, reasoningEffort: manifest.reasoningEffort,
+    sources: manifest.sources, sections: manifest.sections,
+    traits: Array.isArray(manifest.traits) ? manifest.traits : [],
+    snapshot: Shared.normalizeSnapshot({ accountScopeId: scope.accountScopeId, projectId: scope.projectId,
+      version: manifest.version, bundleHash, label: manifest.label }) };
+}
+
+function get(params, env, isRequestActive) {
+  const scope = scopeOf(params, env);
+  let state = config(scope);
+  const interrupted = value => value.building && (!alive(value.building.pid)
+    || (value.building.pid === process.pid && isRequestActive && !isRequestActive(value.building.requestId)));
+  if (interrupted(state)) {
+    state = withConfigLock(scope, () => {
+      const latest = config(scope);
+      return interrupted(latest) ? saveConfig(scope, { ...latest, building: null, error: 'The previous style-generation task was interrupted.' }) : latest;
+    });
+  }
+  let bundle = null, unavailable = '';
+  if (state.version) {
+    try { bundle = readBundle(scope, state.version); }
+    catch (error) {
+      if (state.enabled === true || params.includePreview) throw error;
+      unavailable = 'The saved writing skill changed. Rebuild it in General settings.';
+    }
+  }
+  const result = { enabled: state.enabled === true, ready: Boolean(bundle),
+    revision: state.revision, building: state.building || null, error: state.error || unavailable,
+    errorCode: !state.error && unavailable ? 'writing_style_changed' : '',
+    ...(bundle ? publicBundle(scope, bundle) : { sources: [], sections: [], snapshot: null }) };
+  if (params.includePreview && bundle) {
+    result.preview = ['SKILL.md', 'references/writing-style.md', ...bundle.manifest.sections.map(item => item.file)]
+      .map(file => ({ file, content: safeBundleText(bundle, file) }));
+  }
+  return result;
+}
+
+function set(params, env) {
+  const scope = scopeOf(params, env);
+  withConfigLock(scope, () => {
+    const state = config(scope);
+    if (params.enabled === true && !state.version) throw fail('writing_style_not_ready', 'Generate the writing skill before enabling it.');
+    if (params.enabled === true) readBundle(scope, state.version);
+    saveConfig(scope, { ...state, enabled: params.enabled === true });
+  });
+  return get(params, env);
+}
+
+function safeBundleText(bundle, file) {
+  if (!/^(?:SKILL\.md|references\/[a-z0-9-]+\.(?:md|json)|corpus\/[a-z0-9-]+\.txt)$/.test(file)
+    || !bundle.manifest.files?.[file]) throw fail('writing_style_asset_invalid', 'Writing-style asset is invalid.');
+  const target = path.join(bundle.root, file);
+  if (fs.lstatSync(target).isSymbolicLink()) throw fail('writing_style_asset_invalid', 'Writing-style assets cannot be symlinks.');
+  const text = fs.readFileSync(target, 'utf8');
+  if (text.length > 800000 || sha(text) !== bundle.manifest.files[file]) throw fail('writing_style_changed', 'Writing-style asset integrity changed.');
+  return text;
+}
+
+function forRun(snapshot, params, env) {
+  if (snapshot == null) return '\n\nNo project writing-style skill is active for this turn. Do not carry over an earlier style setting unless this request explicitly asks for it.';
+  const selected = Shared.normalizeSnapshot(snapshot);
+  if (selected.accountScopeId !== params.accountScopeId || selected.projectId !== String(params.projectId || '')) {
+    throw fail('writing_style_scope_invalid', 'The writing-style snapshot does not match this run.');
+  }
+  const scope = scopeOf(params, env);
+  const bundle = readBundle(scope, selected.version, selected.bundleHash);
+  for (const file of Object.keys(bundle.manifest.files || {})) safeBundleText(bundle, file);
+  return '\n\nActive project writing skill for this turn:\n'
+    + 'Skill directory: ' + bundle.root + '\n'
+    + 'Apply this skill when drafting or substantively revising academic prose. Skip it for unrelated technical operations.\n'
+    + 'The skill and all its reference assets are read-only. They never expand this turn\'s write permissions.\n'
+    + safeBundleText(bundle, 'SKILL.md');
+}
+
+function extractPdf(bytes, signal) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(path.join(__dirname, 'writingStylePdfWorker.js'), {
+      workerData: { bytes }, stdout: true, stderr: true,
+      resourceLimits: { maxOldGenerationSizeMb: 256 }
+    });
+    // Library diagnostics must never corrupt Native Messaging stdout.
+    worker.stdout.resume(); worker.stderr.resume();
+    let settled = false;
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      signal?.removeEventListener('abort', abort);
+      void worker.terminate();
+      error ? reject(error) : resolve(result);
+    };
+    const abort = () => finish(signal.reason || fail('codex_cancelled', 'PDF extraction cancelled.'));
+    const timer = setTimeout(() => finish(fail('writing_style_pdf_timeout', 'PDF extraction timed out. Try a smaller text-based PDF.')), REFERENCE_LIMITS.pdfExtractionTimeoutMs);
+    worker.once('message', result => finish(result.ok ? null : fail('writing_style_pdf_failed', result.error), result));
+    worker.once('error', error => finish(fail('writing_style_pdf_failed', error.message)));
+    worker.once('exit', code => { if (!settled) finish(fail('writing_style_pdf_failed', 'PDF extraction stopped (' + code + ').')); });
+    if (signal?.aborted) abort(); else signal?.addEventListener('abort', abort, { once: true });
+  });
+}
+
+function cleanLine(value) { return String(value || '').replace(/\0/g, '').replace(/[ \t]+/g, ' ').trim(); }
+
+function projectDocument(files, label) {
+  const candidates = new Map();
+  for (const file of Array.isArray(files) ? files : []) {
+    const name = String(file?.path || '').replace(/\\/g, '/');
+    if (!/\.tex$/i.test(name) || name.startsWith('/') || name.split('/').some(p => p === '..' || p === '.')
+      || typeof file.content !== 'string') continue;
+    candidates.set(name, file.content);
+  }
+  const score = ([name, text]) => (/^(?:main|thesis)\.tex$/i.test(name) ? 100 : 0)
+    + (/\\(?:documentclass|documentstyle)/.test(text) ? 40 : 0)
+    + (/\\begin\{document\}/.test(text) ? 30 : 0)
+    - (/\\documentclass(?:\[[^\]]*\])?\{beamer\}/.test(text) ? 100 : 0)
+    + Math.min(text.length / 10000, 10);
+  const main = [...candidates].sort((a, b) => score(b) - score(a))[0];
+  if (!main) throw fail('writing_style_reference_empty', 'No readable TeX document was found in ' + label + '.');
+  const lines = [], origins = [], visited = new Set();
+  let chars = 0, truncated = false;
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visited.size >= 80) { truncated = true; return; }
+    const text = candidates.get(name);
+    if (text === undefined) throw fail('writing_style_reference_incomplete', 'A referenced TeX component is missing: ' + name);
+    visited.add(name);
+    let inDocument = !/\\begin\{document\}/.test(text), inComment = false, inBibliography = false;
+    for (const [index, original] of text.split(/\r?\n/).entries()) {
+      checkLimit: {
+        if (chars >= 60000) { truncated = true; return; }
+        if (/\\begin\{comment\}/.test(original)) inComment = true;
+        if (/\\end\{comment\}/.test(original)) { inComment = false; break checkLimit; }
+        if (inComment || /^\s*%/.test(original)) break checkLimit;
+        const line = cleanLine(original.replace(/(^|[^\\])%.*/, '$1'));
+        if (/\\begin\{document\}/.test(line)) { inDocument = true; break checkLimit; }
+        if (!inDocument) break checkLimit;
+        if (/\\begin\{thebibliography\}/.test(line)) inBibliography = true;
+        if (/\\end\{thebibliography\}/.test(line)) { inBibliography = false; break checkLimit; }
+        if (inBibliography || /\\(?:bibliography|bibliographystyle|maketitle|end\{document\})/.test(line)) break checkLimit;
+        const includes = [...line.matchAll(/\\(?:input|include)\s*\{([^}]+)\}/g)];
+        if (includes.length) {
+          for (const match of includes) {
+            const relative = path.posix.normalize(path.posix.join(path.posix.dirname(name), match[1].trim()));
+            if (relative.startsWith('../') || path.posix.isAbsolute(relative)) throw fail('writing_style_reference_path', 'A TeX include leaves its reference project.');
+            visit(candidates.has(relative) ? relative : relative + '.tex');
+          }
+          break checkLimit;
+        }
+        if (!line) break checkLimit;
+        lines.push(line); origins.push({ path: name, line: index + 1 }); chars += line.length;
+      }
+    }
+  }
+  visit(main[0]);
+  return { lines, origins, mainPath: main[0], truncated };
+}
+
+function readReferenceProjectAttachment(item, params) {
+  const attachment = (params.attachments || []).find(value => value.id === item.attachmentId);
+  if (!attachment || typeof attachment.contentBase64 !== 'string'
+    || attachment.contentBase64.length > Math.ceil(4 * 1024 * 1024 / 3) * 4
+    || !/^[A-Za-z0-9+/]*={0,2}$/.test(attachment.contentBase64)) {
+    throw fail('writing_style_reference_invalid', 'The selected project text is missing or exceeds 4 MiB.');
+  }
+  const bytes = Buffer.from(attachment.contentBase64, 'base64');
+  if (bytes.length > 4 * 1024 * 1024) throw fail('writing_style_reference_invalid', 'The selected project text exceeds 4 MiB.');
+  let snapshot;
+  try { snapshot = JSON.parse(bytes.toString('utf8')); }
+  catch (_) { throw fail('writing_style_reference_invalid', 'The selected project snapshot is unreadable.'); }
+  if (snapshot?.projectId !== item.projectId || snapshot?.capabilities?.referenceTextComplete !== true
+    || !Array.isArray(snapshot.files) || !snapshot.files.length || snapshot.files.length > 1000
+    || !Number.isFinite(Date.parse(snapshot.capturedAt))) {
+    throw fail('writing_style_reference_invalid', 'A complete, identified project reference is required. Reload the reference and retry.');
+  }
+  let textBytes = 0;
+  for (const file of snapshot.files) {
+    const name = String(file?.path || '').replace(/\\/g, '/');
+    if (!/\.tex$/i.test(name) || name.startsWith('/') || name.split('/').some(part => !part || part === '.' || part === '..')
+      || typeof file.content !== 'string') {
+      throw fail('writing_style_reference_invalid', 'The reference project contains an invalid TeX file entry.');
+    }
+    textBytes += Buffer.byteLength(file.content, 'utf8');
+    if (textBytes > 4 * 1024 * 1024) throw fail('writing_style_reference_invalid', 'The selected project text exceeds 4 MiB.');
+  }
+  return snapshot;
+}
+
+async function prepareSources(input, params, scope, env, signal) {
+  const selected = input.sources;
+  if (!Array.isArray(selected) || selected.length < 1 || selected.length > 3) throw fail('writing_style_sources_invalid', 'Select one to three reference sources.');
+  let cached = [];
+  if (input.reuseSnapshot) {
+    const snapshot = Shared.normalizeSnapshot(input.reuseSnapshot);
+    if (snapshot.projectId !== scope.projectId || snapshot.accountScopeId !== scope.accountScopeId) throw fail('writing_style_scope_invalid', 'Cached references belong to another scope.');
+    const bundle = readBundle(scope, snapshot.version, snapshot.bundleHash);
+    cached = JSON.parse(safeBundleText(bundle, 'references/source-index.json')).documents || [];
+  }
+  const documents = [], hashes = new Set();
+  let pdfBytes = 0;
+  for (const item of selected) {
+    checkAbort(signal);
+    let doc;
+    if (item.kind === 'project') {
+      const id = String(item.projectId || '');
+      if (!/^[a-zA-Z0-9_-]{1,80}$/.test(id)) throw fail('writing_style_project_invalid', 'Reference project identity is invalid.');
+      let files, capturedAt;
+      if (item.attachmentId) {
+        const snapshot = readReferenceProjectAttachment(item, params);
+        files = snapshot.files; capturedAt = snapshot.capturedAt;
+      } else if (id === scope.projectId && params.project?.capabilities?.fullProjectSnapshot === true) {
+        files = params.project.files; capturedAt = new Date().toISOString();
+      } else {
+        throw fail('writing_style_reference_required', 'Read the latest reference project from Overleaf before generating the style.');
+      }
+      doc = { kind: 'project', projectId: id, name: String(item.name || id).slice(0, 160),
+        capturedAt, ...projectDocument(files, item.name || id) };
+    } else if (item.kind === 'pdf') {
+      const attachment = (params.attachments || []).find(value => value.id === item.attachmentId);
+      if (!attachment || typeof attachment.contentBase64 !== 'string'
+        || attachment.contentBase64.length > Math.ceil(REFERENCE_LIMITS.maxPdfBytes / 3) * 4) {
+        throw fail('writing_style_pdf_invalid', 'The selected PDF is missing or too large.');
+      }
+      const bytes = Buffer.from(attachment.contentBase64, 'base64');
+      pdfBytes += bytes.length;
+      if (bytes.length > REFERENCE_LIMITS.maxPdfBytes || pdfBytes > REFERENCE_LIMITS.maxPdfTotalBytes
+        || bytes.subarray(0, 1024).indexOf('%PDF-') < 0) {
+        throw fail('writing_style_pdf_invalid', 'Use PDF files up to 20 MiB each, 40 MiB in total.');
+      }
+      const result = await extractPdf(bytes, signal);
+      const lines = [], origins = [];
+      const marginCounts = new Map();
+      for (const page of result.pages) {
+        for (const line of new Set([...page.lines.slice(0, 2), ...page.lines.slice(-2)].map(cleanLine))) {
+          if (line.length > 2 && line.length < 140) marginCounts.set(line, (marginCounts.get(line) || 0) + 1);
+        }
+      }
+      let count = 0;
+      for (const page of result.pages) {
+        for (const raw of page.lines) {
+          const line = cleanLine(raw);
+          if (!line || /^\d+$/.test(line) || (result.pages.length >= 3 && marginCounts.get(line) >= Math.ceil(result.pages.length * .6))) continue;
+          if (count >= 60000) break;
+          lines.push(line); origins.push({ page: page.number }); count += line.length;
+        }
+        if (count >= 60000) break;
+      }
+      doc = { kind: 'pdf', name: String(attachment.name || 'reference.pdf').slice(0, 160),
+        lines, origins, fileHash: sha(bytes), totalPages: result.totalPages,
+        pagesRead: result.pages.length, truncated: count >= 60000 || result.pages.length < result.totalPages };
+    } else if (item.kind === 'saved') {
+      const existing = cached.find(value => value.id === item.sourceId);
+      if (!existing) throw fail('writing_style_source_missing', 'A saved reference is unavailable. Add it again.');
+      doc = { ...existing };
+    } else throw fail('writing_style_sources_invalid', 'Unsupported writing reference.');
+    const text = doc.lines.join('\n');
+    if (text.length < 400 || (text.match(/\p{L}/gu) || []).length < 150
+      || (text.match(/\ufffd/g) || []).length > text.length * .02) {
+      throw fail('writing_style_reference_unreadable', 'Not enough readable prose in ' + doc.name + '. Use a text-based PDF or a fuller TeX document.');
+    }
+    const contentHash = sha(text);
+    if (hashes.has(contentHash)) continue;
+    hashes.add(contentHash);
+    documents.push({ ...doc, id: 'source-' + (documents.length + 1), contentHash });
+  }
+  if (!documents.length) throw fail('writing_style_reference_empty', 'No usable writing references were selected.');
+  return documents;
+}
+
+function parseResult(text, documents) {
+  const raw = String(text || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+  const begin = raw.indexOf('{'), end = raw.lastIndexOf('}');
+  let result;
+  try { result = JSON.parse(raw.slice(begin, end + 1)); } catch (_) { throw fail('writing_style_generation_invalid', 'The agent did not return a valid writing-skill result. The previous skill was kept.'); }
+  return StyleProfile.validate(result, documents);
+}
+
+async function build({ params, env, signal, execute, providerLaunch, onControlReady, onStopUnconfirmed }) {
+  const scope = scopeOf(params, env), input = params.writingStyleBuild;
+  const id = crypto.randomUUID();
+  const staging = path.join(scope.root, '.build-' + id);
+  let keepStaging = false, registered = false;
+  try {
+    fs.mkdirSync(path.join(staging, 'corpus'), { recursive: true, mode: 0o700 });
+    const before = withConfigLock(scope, () => {
+      const state = config(scope);
+      saveConfig(scope, { ...state, error: '', building: { id, pid: process.pid,
+        requestId: String(input.requestId || ''), startedAt: new Date().toISOString() } });
+      return state;
+    });
+    registered = true;
+    const documents = await prepareSources(input, params, scope, env, signal);
+    checkAbort(signal);
+    for (const doc of documents) {
+      const text = doc.lines.map((line, index) => String(index + 1).padStart(5, '0') + ' | ' + line).join('\n');
+      fs.writeFileSync(path.join(staging, 'corpus', doc.id + '.txt'), text, { mode: 0o600 });
+    }
+    const index = documents.map(doc => ({ id: doc.id, name: doc.name, kind: doc.kind,
+      file: 'corpus/' + doc.id + '.txt', lines: doc.lines.length, truncated: doc.truncated === true }));
+    fs.writeFileSync(path.join(staging, 'source-index.json'), JSON.stringify(index, null, 2), { mode: 0o600 });
+    const instructions = fs.readFileSync(path.join(__dirname, 'skills', 'writing-style-builder', 'SKILL.md'), 'utf8');
+    const execution = {
+      workspacePath: staging, task: instructions + '\n\nAvailable references:\n' + JSON.stringify(index)
+        + '\nRespond in ' + (params.locale === 'zh' ? 'Chinese' : 'English') + ' for guidance; preserve source-example language.',
+      userTask: 'Build the project writing-style skill from the supplied corpus.',
+      session: null, threadId: '', mode: 'ask', model: params.model || '',
+      reasoningEffort: params.reasoningEffort || '', speedTier: params.speedTier || 'standard',
+      sandboxMode: 'read-only', approvalPolicy: 'never',
+      loadCodexLocalSkills: false, loadCodexOverleafSkills: false,
+      disableCodexOverleafSkillIds: ['annotated-rewrite', 'parallel-subagents'],
+      skillInvocation: null, projectLocalSkills: null, providerLaunch, env, signal,
+      onControlReady, emit: () => {}
+    };
+    let result, repairMessage = '';
+    for (let attempt = 0; attempt < 2; attempt++) {
+      checkAbort(signal);
+      const response = await execute({
+        ...execution,
+        task: execution.task + (repairMessage
+          ? '\n\nThe previous draft did not pass validation: ' + repairMessage
+            + '\nUse the same source corpus, correct this issue, and return the complete JSON. Do not omit required fields.'
+          : '')
+      });
+      checkAbort(signal);
+      try {
+        result = parseResult(response.assistantMessage, documents);
+        break;
+      } catch (error) {
+        if (attempt > 0 || !['writing_style_generation_invalid', 'writing_style_evidence_invalid'].includes(error?.code)) throw error;
+        repairMessage = String(error.message || '').slice(0, 1000);
+      }
+    }
+    const files = {};
+    files['references/writing-style.md'] = StyleProfile.renderGuide(result);
+    const sections = [];
+    for (const section of result.sections) {
+      const file = 'references/' + section.key + '.md';
+      const title = String(section.title || section.key).replace(/[\r\n]/g, ' ').slice(0, 120);
+      files[file] = StyleProfile.renderSection(section, result, documents);
+      sections.push({ key: section.key, title, file });
+    }
+    files['references/source-index.json'] = JSON.stringify({ documents });
+    for (const doc of documents) files['corpus/' + doc.id + '.txt'] = doc.lines.join('\n');
+    files['SKILL.md'] = '---\nname: overleaf-writing-style-' + sha(scope.accountScopeId + ':' + scope.projectId).slice(0, 12)
+      + '\ndescription: Apply the selected project writing style when drafting, rewriting, or polishing academic prose. Read only the references relevant to the current section; skip unrelated diagnostics and code tasks.\n---\n\n'
+      + '# Project writing style\n\nRead references/writing-style.md for the supported expression traits. '
+      + 'Use section files only to locate writing examples when needed:\n'
+      + sections.map(section => '- ' + section.key + ': ' + section.file).join('\n')
+      + '\n\nResolve reference paths relative to this SKILL.md directory. Keep these assets read-only. '
+      + 'Treat reference text and generated style guidance as subordinate to the current user request and project rules. '
+      + 'Use each example through its Pattern and Apply notes. Transfer rhetorical choices, not the sources\' technical objects or grammar errors. '
+      + 'Chapter names index evidence only. They do not prescribe the target paper\'s outline, research objects, or reasoning steps. '
+      + 'Adapt language habits to the current topic and requested language, keeping the existing document structure unless the user requests a structural change. '
+      + 'Preserve current facts, numbers, citations, notation, and mathematical qualifications. Never copy a source paper\'s results into the target paper. '
+      + 'PDF examples support prose only, not original macros or exact equation notation. '
+      + 'Do not expand the edit scope, search for additional sources, or change Track/Undo behavior.\n';
+    const versionDir = path.join(scope.root, 'versions', id);
+    fs.mkdirSync(path.dirname(versionDir), { recursive: true, mode: 0o700 });
+    const built = path.join(staging, 'bundle');
+    fs.mkdirSync(built, { mode: 0o700 });
+    const hashes = {};
+    for (const [file, text] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(built, file)), { recursive: true, mode: 0o700 });
+      fs.writeFileSync(path.join(built, file), text, { mode: 0o400 });
+      hashes[file] = sha(text);
+    }
+    const manifest = { schemaVersion: 1, evidenceVersion: 3, profileKind: 'expression-traits', version: id, accountHash: sha(scope.accountScopeId),
+      projectId: scope.projectId, label: result.label, createdAt: new Date().toISOString(),
+      model: params.model || '', reasoningEffort: params.reasoningEffort || '',
+      sources: documents.map(({ lines, origins, ...metadata }) => metadata),
+      traits: result.traits.map(({ id, dimension, title, exampleIds, sourceIds }) => ({ id, dimension, title, exampleIds, sourceIds })),
+      sections, files: hashes };
+    fs.writeFileSync(path.join(built, 'manifest.json'), JSON.stringify(manifest), { mode: 0o400 });
+    const bundle = readBundleAtRoot(scope, id, built);
+    for (const file of Object.keys(bundle.manifest.files)) safeBundleText(bundle, file);
+    checkAbort(signal);
+    withConfigLock(scope, () => {
+      checkAbort(signal);
+      const latest = config(scope);
+      if (latest.building?.id !== id) throw fail('writing_style_build_superseded', 'A newer style-generation task replaced this one.');
+      fs.renameSync(built, versionDir);
+      const unchangedPreference = latest.revision === before.revision + 1;
+      saveConfig(scope, { ...latest, version: id, building: null, error: '',
+        enabled: unchangedPreference ? input.enableAfterBuild !== false : latest.enabled === true });
+    });
+    return { status: 'completed', assistantMessage: 'Writing skill generated: ' + result.label,
+      syncChanges: [], unsupportedChanges: [], writingStyle: get({ ...params }, env) };
+  } catch (error) {
+    if (error?.code === 'codex_process_stop_unconfirmed') {
+      keepStaging = true;
+      onStopUnconfirmed?.(error);
+    }
+    if (registered) {
+      try {
+        withConfigLock(scope, () => {
+          const state = config(scope);
+          if (state.building?.id === id) saveConfig(scope, { ...state, building: null,
+            error: error?.code === 'codex_cancelled' ? 'Style generation cancelled.' : String(error.message || 'Style generation failed.').replace(/\/Users\/\S+|\/home\/\S+|[A-Z]:\\\S+/g, '[local path]').slice(0, 300) });
+        });
+      } catch (_) { /* Preserve the original failure if config is unavailable. */ }
+    }
+    throw error;
+  } finally {
+    if (!keepStaging) fs.rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+module.exports = { get, set, build, forRun };

package/native-host/src/writingStyleStore.js

@@ -0,0 +1,73 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+function writeJson(file, value) {
+  const temp = file + '.' + crypto.randomUUID() + '.tmp';
+  let created = false;
+  try {
+    const fd = fs.openSync(temp, 'wx', 0o600);
+    created = true;
+    try { fs.writeFileSync(fd, JSON.stringify(value)); }
+    finally { fs.closeSync(fd); }
+    fs.renameSync(temp, file);
+  } finally {
+    if (created) fs.rmSync(temp, { force: true });
+  }
+}
+
+function withConfigLock(scope, action) {
+  const lock = path.join(scope.root, '.config-lock');
+  const owner = process.pid + '-' + crypto.randomUUID() + '.owner';
+  const pending = path.join(scope.root, '.config-lock-' + owner);
+  let acquired = false, prepared = false;
+  try {
+    // Publish a nonempty directory atomically, so a reaper can only remove an
+    // empty old lock; it cannot remove a replacement owner's marker.
+    fs.mkdirSync(pending, { mode: 0o700 });
+    prepared = true;
+    fs.writeFileSync(path.join(pending, owner), '', { mode: 0o600 });
+    const deadline = Date.now() + 2000;
+    while (!acquired) {
+      try { fs.renameSync(pending, lock); acquired = true; }
+      catch (error) {
+        if (!['EEXIST', 'ENOTEMPTY', 'EPERM', 'EACCES'].includes(error.code)) throw error;
+        const stat = fs.lstatSync(lock, { throwIfNoEntry: false });
+        if (!stat && ['EPERM', 'EACCES'].includes(error.code)) throw error;
+        if (stat && (!stat.isDirectory() || stat.isSymbolicLink())) throw error;
+        if (stat) reapDeadOwner(lock);
+        if (Date.now() >= deadline) throw Object.assign(new Error('Writing-style settings are being updated by another Native Host. Retry shortly.'), { code: 'writing_style_busy' });
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+      }
+    }
+    return action();
+  } finally {
+    if (acquired) removeOwner(lock, owner);
+    if (prepared) fs.rmSync(pending, { recursive: true, force: true });
+  }
+}
+
+function reapDeadOwner(lock) {
+  let entries;
+  try { entries = fs.readdirSync(lock); } catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  if (!entries.length) { removeEmptyLock(lock); return; }
+  if (entries.length !== 1) return;
+  const match = /^([1-9]\d*)-[a-f0-9-]{36}\.owner$/.exec(entries[0]);
+  if (!match || !Number.isSafeInteger(Number(match[1]))) return;
+  try { process.kill(Number(match[1]), 0); }
+  catch (error) { if (error.code === 'ESRCH') removeOwner(lock, entries[0]); }
+}
+
+function removeOwner(lock, owner) {
+  try { fs.unlinkSync(path.join(lock, owner)); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  removeEmptyLock(lock);
+}
+
+function removeEmptyLock(lock) {
+  try { fs.rmdirSync(lock); }
+  catch (error) { if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code)) throw error; }
+}
+
+module.exports = { writeJson, withConfigLock };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "2.4.1",
+  "version": "2.5.1",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",

package/scripts/install-managed.mjs

@@ -22,6 +22,7 @@ export function formatInstallManagedHuman(result) {
     '2. Remove the previous Codex Overleaf Link entry if Chrome shows a duplicate.',
     '3. Choose Load unpacked and select: ' + result.loadUnpackedPath,
     'Future signed stable updates are checked automatically. Choose Update now to authorize a version; installation waits until Overleaf is saved and idle.',
+    ...(result.warning ? ['Warning: ' + result.warning] : []),
     ''
   ].join('\n');
 }