mixdog 0.9.174 → 1.0.0

package/src/runtime/office/portable/text-metrics.mjs

@@ -325,8 +325,9 @@ export function measureTextBlock(paragraphs = [], { width = 0, lineSpacing = 1,
       italic: paragraph.italic,
     };
     const size = Math.max(1, Number(paragraph.fontSize) || 18);
-    const multipleEarly =
+    const multiple =
       Number(paragraph.lineSpacing) > 0 ? Number(paragraph.lineSpacing) : Math.max(0.5, Number(lineSpacing) || 1);
+    const pitch = lineHeightRatio > 0 ? lineHeightRatio : LINE_HEIGHT_RATIO * multiple;
     // Runs of different sizes ("+4.3" at 47 pt, "%p" at 19 pt) are measured each at its own size: read at the first
     // run's size, a figure with its small unit was reported as breaking mid-word and overflowing its box. When the
     // whole paragraph fits one line that way, it is one line.
@@ -340,7 +341,7 @@ export function measureTextBlock(paragraphs = [], { width = 0, lineSpacing = 1,
         widest = Math.max(widest, total);
         longestRun = Math.max(longestRun, total);
         lines += 1;
-        height += size * (lineHeightRatio > 0 ? lineHeightRatio : LINE_HEIGHT_RATIO * multipleEarly);
+        height += size * pitch;
         height += Math.max(0, Number(paragraph.spaceBefore) || 0) + Math.max(0, Number(paragraph.spaceAfter) || 0);
         continue;
       }
@@ -351,9 +352,6 @@ export function measureTextBlock(paragraphs = [], { width = 0, lineSpacing = 1,
       if (part !== ' ') longestRun = Math.max(longestRun, measureTextWidth(part, font));
     }
     lines += wrapped.length;
-    const multiple =
-      Number(paragraph.lineSpacing) > 0 ? Number(paragraph.lineSpacing) : Math.max(0.5, Number(lineSpacing) || 1);
-    const pitch = lineHeightRatio > 0 ? lineHeightRatio : LINE_HEIGHT_RATIO * multiple;
     height += wrapped.length * size * pitch;
     height += Math.max(0, Number(paragraph.spaceBefore) || 0);
     height += Math.max(0, Number(paragraph.spaceAfter) || 0);
@@ -391,9 +389,10 @@ export function contrastRatio(foreground, background) {
 // between blocks of copy, not inside a labelled construct.
 const LABEL_MAX_CHARS = 16;
 
+const paragraphsOf = (box) => (Array.isArray(box?.paragraphs) ? box.paragraphs : []);
+
 function isLabelBox(box) {
-  const paragraphs = Array.isArray(box?.paragraphs) ? box.paragraphs : [];
-  const text = paragraphs
+  const text = paragraphsOf(box)
     .map((paragraph) => String(paragraph.text ?? '').trim())
     .filter(Boolean)
     .join('\n');
@@ -439,9 +438,8 @@ export function reviewTextContrast(boxes = []) {
   for (const box of boxes) {
     const background = box.background;
     if (!background) continue;
-    const paragraphs = Array.isArray(box.paragraphs) ? box.paragraphs : [];
     let worst = null;
-    for (const paragraph of paragraphs) {
+    for (const paragraph of paragraphsOf(box)) {
       if (!String(paragraph.text ?? '').trim()) continue;
       const ratio = contrastRatio(paragraph.color || '000000', background);
       if (ratio == null) continue;
@@ -473,9 +471,8 @@ const CJK_TRACKING_RATIO = 0.05;
 export function reviewCjkTracking(boxes = []) {
   const issues = [];
   for (const box of boxes) {
-    const paragraphs = Array.isArray(box.paragraphs) ? box.paragraphs : [];
     let worst = null;
-    for (const paragraph of paragraphs) {
+    for (const paragraph of paragraphsOf(box)) {
       const text = String(paragraph.text ?? '');
       if (!CJK_TEXT.test(text)) continue;
       const tracking = Number(paragraph.charSpacing) || 0;
@@ -570,7 +567,7 @@ function overflowIssue(measured, usableHeight, { tolerance, substituted, path })
 }
 
 function textBoxFitIssues(box, { slideWidth, slideHeight, tolerance, isFontAvailable }) {
-  const paragraphs = Array.isArray(box.paragraphs) ? box.paragraphs : [];
+  const paragraphs = paragraphsOf(box);
   const path = `/slide[${box.slide}]/shape[${box.shape}]`;
   const { usableWidth, usableHeight } = usableTextArea(box);
   const measured = measureTextBlock(paragraphs, { width: box.wrap === false ? 0 : usableWidth });
@@ -603,7 +600,7 @@ export function reviewTextBoxFit(
 ) {
   const issues = [];
   for (const box of boxes) {
-    const paragraphs = Array.isArray(box.paragraphs) ? box.paragraphs : [];
+    const paragraphs = paragraphsOf(box);
     if (!paragraphs.some((paragraph) => String(paragraph.text ?? '').trim())) continue;
     if (box.autofit === true) continue;
     issues.push(...textBoxFitIssues(box, { slideWidth, slideHeight, tolerance, isFontAvailable }));
@@ -617,7 +614,7 @@ export function reviewTextBoxFit(
 function statementSlides(boxes = []) {
   const perSlide = new Map();
   for (const box of boxes) {
-    const paragraphs = Array.isArray(box.paragraphs) ? box.paragraphs : [];
+    const paragraphs = paragraphsOf(box);
     const text = paragraphs
       .map((paragraph) => String(paragraph.text || ''))
       .join('')
@@ -686,7 +683,7 @@ function hollowBand(content = []) {
 // The author may mean it, so it is information, not a target.
 function titleLineHollow(slideBoxes, content, slideHeight) {
   const texts = slideBoxes
-    .map((box) => ({ box, size: largestFontSize(Array.isArray(box.paragraphs) ? box.paragraphs : []) }))
+    .map((box) => ({ box, size: largestFontSize(paragraphsOf(box)) }))
     .filter(({ box }) => (box.paragraphs || []).some((paragraph) => String(paragraph.text || '').trim()));
   if (texts.length < 2) return null;
   const title = texts.reduce((largest, entry) => (entry.size > largest.size ? entry : largest));
@@ -766,7 +763,7 @@ export function reviewStatLabelProximity(boxes = [], { maximumGap = 36 } = {}) {
     issues.push(...reviewDeclaredRelations(shapes, maximumGap));
     for (const box of shapes) {
       if (box.relation?.role === 'value') continue;
-      const paragraphs = Array.isArray(box.paragraphs) ? box.paragraphs : [];
+      const paragraphs = paragraphsOf(box);
       const text = paragraphs
         .map((paragraph) => String(paragraph.text ?? ''))
         .join(' ')
@@ -777,7 +774,7 @@ export function reviewStatLabelProximity(boxes = [], { maximumGap = 36 } = {}) {
       if (letters > text.replace(/\s/g, '').length * 0.5) continue;
       const nearest = shapes
         .filter((candidate) => candidate !== box)
-        .filter((candidate) => largestFontSize(Array.isArray(candidate.paragraphs) ? candidate.paragraphs : []) <= 20)
+        .filter((candidate) => largestFontSize(paragraphsOf(candidate)) <= 20)
         .filter((candidate) => candidate.paragraphs?.some((paragraph) => String(paragraph.text || '').trim()))
         .sort((first, second) => rectangleGap(box, first) - rectangleGap(box, second))[0];
       if (!nearest) continue;

package/src/runtime/office/portable/xlsx-contract.mjs

@@ -246,6 +246,42 @@ export function listValidationChoices(formula1) {
   return `"${text}"`;
 }
 
+export const XLSX_VALIDATION_TYPES = Object.freeze(['list', 'whole', 'decimal', 'date', 'time', 'textLength', 'custom']);
+export const XLSX_VALIDATION_OPERATORS = Object.freeze([
+  'between',
+  'notBetween',
+  'equal',
+  'notEqual',
+  'greaterThan',
+  'lessThan',
+  'greaterThanOrEqual',
+  'lessThanOrEqual',
+]);
+
+// Resolve and validate once, before either Excel COM or the portable writer
+// can interpret an unknown name as a different rule.
+export function normalizeXlsxValidation(operation) {
+  if (!String(operation.formula1 ?? '').trim()) throw new Error('add_validation requires non-empty formula1');
+  const requestedType = String(operation.type ?? '').trim() || (listValidationFormula(operation.formula1) ? 'list' : 'custom');
+  const type = XLSX_VALIDATION_TYPES.find((value) => value.toLowerCase() === requestedType.toLowerCase());
+  if (!type) throw new Error(`add_validation type must be one of ${XLSX_VALIDATION_TYPES.join(', ')}`);
+  const requestedOperator = String(operation.operator ?? '').trim();
+  const bounded = !['list', 'custom'].includes(type);
+  const operator = requestedOperator
+    ? XLSX_VALIDATION_OPERATORS.find((value) => value.toLowerCase() === requestedOperator.toLowerCase())
+    : bounded ? 'between' : '';
+  if (requestedOperator && !operator) {
+    throw new Error(`add_validation operator must be one of ${XLSX_VALIDATION_OPERATORS.join(', ')}`);
+  }
+  if (!bounded && requestedOperator) {
+    throw new Error(`add_validation operator is unsupported for type "${type}"; omit operator`);
+  }
+  if (['between', 'notBetween'].includes(operator) && !String(operation.formula2 ?? '').trim()) {
+    throw new Error(`add_validation operator "${operator}" requires formula2; for one bound use a comparison operator`);
+  }
+  return { type, ...(operator ? { operator } : {}) };
+}
+
 // Three ways a sheet marks its numbers: a rule that paints the cells it picks,
 // a scale that colors every cell by where its value sits, and a bar drawn in
 // the cell. The first needs a formula and a format; the other two carry their
@@ -394,9 +430,7 @@ function validateXlsxOperation(operation) {
   // Both backends write the kind named here, so the default is settled once:
   // a formula that names choices is a dropdown, a formula that states a test
   // is a custom rule. Writing B2>0 as a list would offer it as one entry.
-  if (op === 'add_validation' && !String(operation.type ?? '').trim()) {
-    operation.type = listValidationFormula(operation.formula1) ? 'list' : 'custom';
-  }
+  if (op === 'add_validation') Object.assign(operation, normalizeXlsxValidation(operation));
   if (op === 'set_style' && operation.cell) parseXlsxCell(operation.cell);
   if (operation.range && RANGE_OPERATIONS.includes(op)) validateRangeOperation(operation, op);
   else if (op === 'set_range') throw new Error('XLSX set_range requires range');

package/src/runtime/office/portable/xlsx-formula-engine.mjs

@@ -53,7 +53,13 @@ const SCANNERS = [
   ['string', /"(?:[^"]|"")*"/y],
   // Excel writes a reference whose cells were deleted as #REF!, after the sheet name when it named another sheet
   // (Data!#REF!), and one whose sheet was deleted as #REF! before the cells it named (#REF!B2:B4).
-  ['error', new RegExp(String.raw`(?:${SHEET_PREFIX})?#(?:REF!(?:${REFERENCE_BODY})?|DIV\/0!|VALUE!|NAME\?|N\/A|NUM!|NULL!)`, 'yu')],
+  [
+    'error',
+    new RegExp(
+      String.raw`(?:${SHEET_PREFIX})?#(?:REF!(?:${REFERENCE_BODY})?|DIV\/0!|VALUE!|NAME\?|N\/A|NUM!|NULL!)`,
+      'yu'
+    ),
+  ],
   // A name followed by "(" is a call, which keeps LOG10( from reading as a cell.
   ['call', /[A-Za-z_][A-Za-z0-9_.]*(?=\s*\()/y],
   ['reference', new RegExp(`(?:${SHEET_PREFIX})?(?:${REFERENCE_BODY})`, 'yu')],

package/src/runtime/office/quality/assurance-checklist.mjs

@@ -1,5 +1,5 @@
 import { plainObject } from '../shared/values.mjs';
-import { issue } from './assurance-structure.mjs';
+import { issue } from './assurance-issue.mjs';
 
 const CHECKLIST_RULES = Object.freeze({
   docx: [

package/src/runtime/office/quality/assurance-rendered.mjs

@@ -1,6 +1,6 @@
 import { createCanvas, loadImage } from '@napi-rs/canvas';
 import { reviewRenderedOfficeAesthetics } from './design-aesthetics.mjs';
-import { issue } from './assurance-structure.mjs';
+import { issue } from './assurance-issue.mjs';
 
 function imagePages(image) {
   return Array.isArray(image?.pages) && image.pages.length ? image.pages.map(Number) : [Number(image?.page) || 0];

package/src/runtime/office/quality/assurance-structure-pptx.mjs

@@ -134,9 +134,6 @@ function isPptxChromeText(shape) {
   return fontSize > 0 && fontSize <= PPTX_BODY_MIN_PT && text.length <= PPTX_CHROME_MAX_CHARS && !/[\r\n]/.test(text);
 }
 
-// A numeral or short lead directly above its own description is one unit
-// (a hero number and its label, a step number and its detail); the tight gap
-// is the design, not a spacing defect.
 // Near-miss alignment: an element a few points off an axis the slide already
 // shares reads as a mistake, not as a decision — the eye registers the step
 // without being able to name it. The reference axis must already be held by two
@@ -164,13 +161,15 @@ const PPTX_AXIS_KINDS = Object.freeze(['left edge', 'centre', 'right edge', 'top
 // position. Registering that single position as three different kinds would let
 // any box's edge drift against a rule it has nothing to do with, so the collapsed
 // dimension reports its centre only; the drawn dimension keeps both ends.
+const PPTX_VERTICAL_AXES = new Set(['top edge', 'bottom edge', 'middle']);
+const PPTX_HORIZONTAL_AXES = new Set(['left edge', 'right edge', 'centre']);
+
 function pptxShapeAxes(shape) {
   const flat = { x: shape.width === 0, y: shape.height === 0 };
   const span = shape.pageSpan || {};
-  const VERTICAL = new Set(['top edge', 'bottom edge', 'middle']);
-  const HORIZONTAL = new Set(['left edge', 'right edge', 'centre']);
   return pptxPlacedAxes(shape, flat).filter(
-    ([kind]) => !(span.spansHeight && VERTICAL.has(kind)) && !(span.spansWidth && HORIZONTAL.has(kind))
+    ([kind]) =>
+      !(span.spansHeight && PPTX_VERTICAL_AXES.has(kind)) && !(span.spansWidth && PPTX_HORIZONTAL_AXES.has(kind))
   );
 }
 
@@ -705,14 +704,24 @@ const FRAME_EDGED_GEOMETRY = new Set(['rect', 'roundRect']);
 function reviewPptxTextEdgeCrossing(slide, textShapes, issues) {
   for (const textShape of textShapes) {
     if (isPptxChromeText(textShape)) continue;
-    const t = { l: Number(textShape.left), t: Number(textShape.top), w: Number(textShape.width), h: Number(textShape.height) };
+    const t = {
+      l: Number(textShape.left),
+      t: Number(textShape.top),
+      w: Number(textShape.width),
+      h: Number(textShape.height),
+    };
     if (!(t.w > 0 && t.h > 0)) continue;
     for (const surface of slide.shapes || []) {
       if (surface === textShape || isMotifShape(surface) || String(surface.text || '').trim()) continue;
       if (!isPptxPicture(surface) && !solidShapeFill(surface)) continue;
       if (surface.geometry && !FRAME_EDGED_GEOMETRY.has(surface.geometry)) continue;
       if (!hasFrame(surface)) continue;
-      const s = { l: Number(surface.left), t: Number(surface.top), w: Number(surface.width), h: Number(surface.height) };
+      const s = {
+        l: Number(surface.left),
+        t: Number(surface.top),
+        w: Number(surface.width),
+        h: Number(surface.height),
+      };
       const across = Math.min(t.l + t.w, s.l + s.w) - Math.max(t.l, s.l);
       const down = Math.min(t.t + t.h, s.t + s.h) - Math.max(t.t, s.t);
       if (across <= 0 || down <= 0) continue;

package/src/runtime/office/quality/assurance-structure.mjs

@@ -2,8 +2,6 @@ import { reviewDocxStructure } from './assurance-structure-docx.mjs';
 import { reviewPptxStructure } from './assurance-structure-pptx.mjs';
 import { reviewXlsxStructure } from './assurance-structure-xlsx.mjs';
 
-export { issue } from './assurance-issue.mjs';
-
 export function reviewOfficeStructure({ format, document, auditProfile = '' } = {}) {
   const normalized = String(format || document?.format || '').toLowerCase();
   if (normalized === 'docx') return reviewDocxStructure(document);

package/src/runtime/office/quality/design-aesthetics.mjs

@@ -2,6 +2,7 @@
 // the issues the render can raise (contrast, density, rhythm, repetition) and
 // the v2 score. Sampling lives in design-aesthetics-metrics.mjs.
 import { clamp } from '../shared/values.mjs';
+import { issue } from './assurance-issue.mjs';
 import {
   deviation,
   mean,
@@ -96,15 +97,7 @@ function roleAwareComposition(metric, role) {
   };
 }
 
-function aestheticIssue(code, path, message) {
-  return {
-    severity: 'warning',
-    code,
-    path,
-    message,
-    source: 'aesthetic-review',
-  };
-}
+const aestheticIssue = (code, path, message) => issue(code, path, message, 'aesthetic-review');
 
 function contentPages(pages) {
   return pages.length >= 3 ? pages.slice(1, -1) : pages.slice(1);

package/src/runtime/office/quality/design-deck-diversity.mjs

@@ -1,15 +1,8 @@
 import { slideReceipt } from '../authoring/pptx-receipt.mjs';
 import { isPictureShape, signedVisualType } from '../design/design-discipline.mjs';
+import { issue as sharedIssue } from './assurance-issue.mjs';
 
-function issue(code, message) {
-  return {
-    severity: 'warning',
-    code,
-    path: '/',
-    message,
-    source: 'design-review',
-  };
-}
+const issue = (code, message) => sharedIssue(code, '/', message, 'design-review');
 
 // The deck's shape, read from the page grammar the receipt assigns (beat | evidence | text). Thirteen reference
 // decks (400 pages) run beats — dark or field pages — on 0-21% of their pages (median 13%) and never three in a

package/src/runtime/office/quality/design-review.mjs

@@ -14,6 +14,7 @@ import {
 import { authoredBackgroundLadder, isCardGridSlide, isOrnamentalStripe, slideSize } from './design-review-authored.mjs';
 import { reviewBriefPromises, reviewFactCoverage, reviewSourceGrounding } from '../authoring/pptx-brief.mjs';
 import { isAdvisoryOfficeIssue } from './quality-pipeline.mjs';
+import { issue } from './assurance-issue.mjs';
 import { isPptxSpecimenSlide, isPptxStatementSlide } from './pptx-slide-roles.mjs';
 import { usesNativeOfficeDesign } from '../design/native-design.mjs';
 import { reviewNativeDocumentDesign } from './document-design-review.mjs';
@@ -27,9 +28,8 @@ export {
   isPptxStatementSlide,
 } from './pptx-slide-roles.mjs';
 
-function designIssue(code, path, message, severity = 'warning') {
-  return { severity, code, path, message, source: 'design-review' };
-}
+const designIssue = (code, path, message, severity = 'warning') =>
+  issue(code, path, message, 'design-review', severity);
 
 function pptxSlideBackgroundColor(slide) {
   return hex(slide?.background?.color, '');

package/src/runtime/office/quality/pptx-slide-roles.mjs

@@ -42,7 +42,7 @@ function isRegisteredText(shape, anchors) {
 
 // A diagram shape is a connector, a preset geometry that is not a plain text
 // rectangle, or a rectangle with a surface fill (a field, a plane, a lane).
-export function isPptxDiagramShape(shape) {
+function isPptxDiagramShape(shape) {
   if (!shape || shape.placeholder || isMotifShape(shape)) return false;
   if (shape.type === 'p:cxnSp') return true;
   if (shape.type !== 'p:sp' || !shape.geometry) return false;
@@ -53,7 +53,7 @@ export function isPptxDiagramShape(shape) {
 // count: the drawn shapes; fieldShare: the union box of those shapes and the
 // text registered to them (the slide's title — its largest type — excluded),
 // as a share of the canvas.
-export function pptxDiagramCoverage(slide, size = DEFAULT_SLIDE) {
+function pptxDiagramCoverage(slide, size = DEFAULT_SLIDE) {
   const all = (Array.isArray(slide?.shapes) ? slide.shapes : []).filter(
     (shape) => hasBox(shape) && !shape.placeholder && !isMotifShape(shape)
   );
@@ -80,7 +80,7 @@ export function pptxDiagramCoverage(slide, size = DEFAULT_SLIDE) {
 const PICTURE_MIN_SHARE = 0.25;
 
 // The share of the canvas under pictures (each frame's own area; overlaps count twice, which only helps a stack).
-export function pptxPictureShare(slide, size = DEFAULT_SLIDE) {
+function pptxPictureShare(slide, size = DEFAULT_SLIDE) {
   const canvas = canvasArea(size);
   const area = (Array.isArray(slide?.shapes) ? slide.shapes : [])
     .filter((shape) => shape?.type === 'p:pic' && Number(shape.width) > 0 && Number(shape.height) > 0)

package/src/runtime/office/shared/line-breaks.mjs

@@ -4,7 +4,9 @@
 // "14시 30분"), a sum written in two groups ("12만 6천 원", "1억 3,500만 원"), and a sum with its unit ("24억 원").
 // Broken between them, a decision read "…을 10월 / 14일 투자심의에서" and a saving "12만 / 6천 원".
 function bound(left, right) {
-  return (/\d(?:분의|월|시|조|억|만)$/.test(left) && /^\d/.test(right)) || (/\d[억만천조]?$/.test(left) && /^원/.test(right));
+  return (
+    (/\d(?:분의|월|시|조|억|만)$/.test(left) && /^\d/.test(right)) || (/\d[억만천조]?$/.test(left) && /^원/.test(right))
+  );
 }
 
 // A line's words with each pair that reads as one joined by its space: the units a line is broken between.

package/src/runtime/office/tool-defs.mjs

@@ -26,7 +26,7 @@ export const TOOL_DEFS = [
           type: 'string',
           enum: OFFICE_ACTIONS,
           description:
-            'detect/describe discover; author: PPTX from HTML or pptxgenjs; transactions/recover, begin/diff/commit/rollback checkpoint; create/attach/open start; snapshot/get/query inspect; batch edits; issues/qa/render/validate review; save/finalize/close finish; secure encrypts/decrypts PDF.',
+            'detect/describe discover; author: HTML/pptxgenjs PPTX; transactions/recover/begin/diff/commit/rollback checkpoints; create/attach/open; snapshot/get/query; batch edits; issues/qa/validate review; render exports PDF and page images; save/finalize/close; secure: PDF passwords.',
         },
         path: { type: 'string', description: 'Document path; relative paths resolve from the caller project.' },
         script: { type: 'string', description: 'author: HTML slides or a pptxgenjs script (pptx skill).' },
@@ -75,7 +75,7 @@ export const TOOL_DEFS = [
           description:
             'auto defaults to background with Office, otherwise portable. Only explicit attach (alias live) co-edits an open file; visible opens a window; background edits a copy.',
         },
-        output: { type: 'string', description: 'Output copy or render destination; defaults beside source.' },
+        output: { type: 'string', description: 'Output copy; render: exported PDF path. Defaults beside source.' },
         target: { type: 'string', description: 'Stable path from snapshot/query, e.g. /body/p[2].' },
         query: { type: 'string', description: 'Case-insensitive value search; with pdf-layout, where the text sits.' },
         queryKind: {

package/src/runtime/shared/async-log-appender.mjs

@@ -0,0 +1,83 @@
+// Non-blocking, size-bounded line appender for diagnostic logs.
+//
+// Callers on hot paths (notification delivery, every session close) used to
+// appendFileSync per line and, for one of them, stat + rewrite the file too.
+// Here `append` only queues the line; one drain per file writes the batch
+// asynchronously, and once the file would pass `maxBytes` it is cut down to
+// its last `keepBytes` (whole lines) before the next batch lands. Best effort:
+// a failed write drops its batch and never throws into the caller.
+import { appendFile, readFile, stat, writeFile } from 'node:fs/promises';
+
+// A wedged disk must not turn the queue into a memory leak.
+const MAX_QUEUED_LINES = 4096;
+// Other processes append to the same file; re-measure now and then.
+const RESTAT_EVERY_DRAINS = 256;
+
+export function createAsyncLogAppender({ maxBytes, keepBytes }) {
+  /** path -> { lines, bytes (last known size or null), drains, running } */
+  const lanes = new Map();
+
+  async function measure(path) {
+    try {
+      return (await stat(path)).size;
+    } catch {
+      return 0;
+    }
+  }
+
+  async function rotate(path) {
+    const buffer = await readFile(path);
+    if (buffer.length <= maxBytes) return buffer.length;
+    let tail = buffer.subarray(buffer.length - keepBytes);
+    // Start on a line boundary so no half line survives rotation.
+    const newline = tail.indexOf(0x0a);
+    if (newline >= 0 && newline + 1 < tail.length) tail = tail.subarray(newline + 1);
+    await writeFile(path, tail);
+    return tail.length;
+  }
+
+  async function drain(path, lane) {
+    try {
+      if (lane.bytes === null || ++lane.drains % RESTAT_EVERY_DRAINS === 0) lane.bytes = await measure(path);
+      while (lane.lines.length > 0) {
+        const chunk = lane.lines.join('');
+        lane.lines = [];
+        const size = Buffer.byteLength(chunk);
+        if (lane.bytes + size > maxBytes) {
+          lane.bytes = await measure(path);
+          if (lane.bytes + size > maxBytes) lane.bytes = await rotate(path);
+        }
+        await appendFile(path, chunk);
+        lane.bytes += size;
+      }
+    } catch {
+      lane.bytes = null;
+      lane.lines = [];
+    } finally {
+      lane.running = null;
+      if (lane.lines.length > 0) lane.running = drain(path, lane);
+    }
+  }
+
+  return {
+    /** Queue one already-terminated line for `path`. */
+    append(path, line) {
+      let lane = lanes.get(path);
+      if (!lane) {
+        lane = { lines: [], bytes: null, drains: 0, running: null };
+        lanes.set(path, lane);
+      }
+      lane.lines.push(line);
+      if (lane.lines.length > MAX_QUEUED_LINES) lane.lines.shift();
+      if (!lane.running) lane.running = drain(path, lane);
+    },
+    /** Resolves once everything queued so far has been written (or dropped). */
+    async flush() {
+      for (;;) {
+        const running = [...lanes.values()].map((lane) => lane.running).filter(Boolean);
+        if (running.length === 0) return;
+        await Promise.all(running);
+      }
+    },
+  };
+}

package/src/runtime/shared/automation-presence.mjs

@@ -0,0 +1,9 @@
+// Automation presence: any enabled schedule that has not finished, or any
+// enabled webhook endpoint. The channel worker boots only while one exists,
+// so this is also what tells a stopped worker apart from an idle one.
+export function hasEnabledAutomation({ schedules = [], webhooks = [] } = {}) {
+  return (
+    schedules.some((entry) => entry?.enabled !== false && entry?.status !== 'done') ||
+    webhooks.some((entry) => entry?.enabled !== false)
+  );
+}

package/src/runtime/shared/buffered-appender.mjs

@@ -137,6 +137,8 @@ function _flush(path, q) {
         q.chunks.unshift(data);
         q.bytes += Buffer.byteLength(data, 'utf8');
         trimBufferedQueue(q);
+      } else {
+        recordDroppedBytes(q, Buffer.byteLength(data, 'utf8'));
       }
     })
     .finally(() => {
@@ -189,24 +191,25 @@ export function getBufferedAppenderStats(path) {
  */
 function drainAllSync() {
   for (const path of queues.keys()) {
-    drainPathSync(path);
+    drainPathSync(path, { exiting: true });
   }
 }
 
 /**
- * Synchronously drain the queue for a single path. Writes any in-flight
- * (already-dequeued but not yet persisted) payload FIRST, then any
- * still-queued chunks, so nothing buffered is lost. Best-effort, never
- * throws.
+ * Synchronously drain the queue for a single path. At process exit the
+ * in-flight (already-dequeued but not yet persisted) payload is written
+ * FIRST, since its async append can no longer land; otherwise the live
+ * async append still owns it and rewriting it would duplicate the bytes.
+ * Then any still-queued chunks are written. Best-effort, never throws.
  */
-export function drainPathSync(path) {
+export function drainPathSync(path, { exiting = false } = {}) {
   const q = queues.get(path);
   if (!q) return;
   if (q.timer) {
     clearTimeout(q.timer);
     q.timer = null;
   }
-  if (q.inFlight) {
+  if (exiting && q.inFlight) {
     try {
       appendFileSync(path, q.inFlight, 'utf8');
     } catch {

package/src/runtime/shared/child-spawn-gate.mjs

@@ -1,7 +1,6 @@
 import { availableParallelism } from 'node:os';
 import { createOwnerFairGate } from './owner-fair-gate.mjs';
 import { currentToolExecutionOwner } from './tool-execution-owner.mjs';
-import { acquireRemoteSpawnLease, remoteSpawnLeasesEnabled } from './child-spawn-remote.mjs';
 import { positiveInt } from './numbers.mjs';
 
 // ── Module-global child-spawn semaphore ──────────────────────────────────
@@ -128,21 +127,6 @@ const SLOW_WAIT_MS = Math.max(1000, Number(process.env.MIXDOG_CHILD_SPAWN_SLOW_M
 const SLOW_WARN_THROTTLE_MS = 30000;
 
 let _lastSlowWarnAt = 0;
-let _lastFallbackWarnAt = 0;
-
-function _warnLeaseFallback(error, laneName) {
-  const now = Date.now();
-  if (now - _lastFallbackWarnAt < SLOW_WARN_THROTTLE_MS) return;
-  _lastFallbackWarnAt = now;
-  try {
-    process.stderr.write(
-      `[child-spawn-gate] lane=${laneName} machine spawn budget unavailable` +
-        ` (${error?.message || error}); using this process's bounded local lane\n`
-    );
-  } catch {
-    /* ignore */
-  }
-}
 
 function _maybeWarnSlow(waitedMs, laneName, limit, queued) {
   if (waitedMs < SLOW_WAIT_MS) return;
@@ -180,25 +164,6 @@ export function acquire(signal = null, laneName = 'search', options = {}) {
   const lane = _lane(normalizedLaneName);
   const ownerKey = options?.ownerKey || currentToolExecutionOwner();
   const waitTimeoutMs = options?.waitTimeoutMs ?? lane.waitTimeoutMs;
-  // Session shards defer to the machine-wide budget owned by the daemon-side
-  // pool; the local lane remains the bounded fallback when the pool channel
-  // cannot answer. Real admission rejections (wait timeout, queue full)
-  // surface unchanged.
-  if (remoteSpawnLeasesEnabled()) {
-    return acquireRemoteSpawnLease({
-      lane: normalizedLaneName,
-      ownerKey,
-      signal,
-      waitTimeoutMs,
-    }).catch((error) => {
-      if (error?.code !== 'ELEASEFALLBACK') throw error;
-      // Only a genuinely dead pool channel reaches here (the client re-arms
-      // while the link is alive). Say so loudly: from this point the cap is
-      // per-process, so N shards can hold N× the machine-wide budget.
-      _warnLeaseFallback(error, normalizedLaneName);
-      return _acquireLocal(signal, normalizedLaneName, lane, ownerKey, waitTimeoutMs);
-    });
-  }
   return _acquireLocal(signal, normalizedLaneName, lane, ownerKey, waitTimeoutMs);
 }
 
@@ -240,7 +205,7 @@ function _abortError() {
  * Best-effort capacity probe for NON-COMPETING prewarm/warmup work. Returns
  * true only when a slot could be taken right now without queuing — i.e. below
  * the cap AND with no waiter already queued. Speculative warmers
- * code_graph / find prewarm) consult this to skip/defer when the daemon is
+ * (code_graph / find prewarm) consult this to skip/defer when the daemon is
  * busy, so a fire-and-forget warm never pushes a real tool query into the
  * queue (the "non-competing under fanout" guarantee). This is a probe, NOT a
  * reservation: the answer can go stale under a race, which is acceptable for
@@ -254,7 +219,7 @@ export function hasSpareCapacity(laneName = 'search') {
 
 export function snapshot() {
   return {
-    mode: remoteSpawnLeasesEnabled() ? 'remote-lease' : 'local',
+    mode: 'local',
     maxInflight: Number.isFinite(DEFAULT_MAX_INFLIGHT) ? DEFAULT_MAX_INFLIGHT : null,
     lanes: [..._lanes.entries()].map(([name, lane]) => {
       const state = lane.gate.snapshot();