mixdog 1.4.2 → 1.4.3

package/src/runtime/office/authoring/xlsx-html-build.mjs

@@ -140,7 +140,7 @@ function resolveRange(text, cells, notes) {
 }
 
 /** The operations that write one measured workbook; formulas and charts come after every sheet's values. */
-export function xlsxOperationsFromSheets(sheets, { captures = new Map(), notes = [] } = {}) {
+function xlsxOperationsFromSheets(sheets, { captures = new Map(), notes = [] } = {}) {
   const first = [];
   const later = [];
   const chartData = [];

package/src/runtime/office/authoring/xlsx-html-runner.mjs

@@ -49,7 +49,7 @@ function fillRangeCharts() {
 }
 
 /** Artifacts kept beside the workbook: its HTML and the browser's picture of each sheet. */
-export function xlsxHtmlArtifacts(target) {
+function xlsxHtmlArtifacts(target) {
   return {
     source: `${target}.mixdog-source.html`,
     shot: (sheet) => `${target}.mixdog-html-sheet-${sheet}.png`,

package/src/runtime/office/capabilities.mjs

@@ -430,7 +430,7 @@ function docxStyleDefinitionFault(format, name, operation, index) {
 
 // A Word table has two alignments that read alike: `alignment` places the
 // table on the page and `columnAlignments` sets the text of each column.
-// A list written into the first used to be serialized verbatim into the
+// A list written into the first would be serialized verbatim into the
 // table's justification and refused by Word's schema at finalize.
 function docxTableAlignmentFaults(format, name, operation, index) {
   const properties = operation.properties;

package/src/runtime/office/core/office-core.mjs

@@ -118,7 +118,7 @@ export async function ensureOfficeSessionDesign(
   session.designRequest = mergeOfficeDesignRequest(session.designRequest, args.design);
   // A native document stays native: the `design` a later call carries is the
   // page review (reviewed, reviewToken, critique) or content, not a request
-  // for a preset. Resolving it as one used to hand a Word or Excel file the
+  // for a preset. Resolving it as one would hand a Word or Excel file the
   // default profile's palette and art direction it never asked for, and put
   // the preset review's gates in front of finalize.
   session.design =

package/src/runtime/office/design/content-model.mjs

@@ -108,9 +108,9 @@ export function normalizeOfficeContentModel(value) {
     const id = safeId(claim.id, 'claim id', `claim ${index + 1}${claim?.text ? `: ${claim.text}` : ''}`);
     if (claimIds.has(id)) throw new Error(`Office content model has duplicate claim id ${id}`);
     claimIds.add(id);
-    // The references are the point of a claim: naming them "facts" instead of
-    // factIds used to bind the claim to nothing at all, and the deck then
-    // reported the figure it carried as unsourced.
+    // The references are the point of a claim, so `facts` is accepted as an
+    // alias of `factIds`: a claim written with either name stays bound to its
+    // sources instead of reporting the figure it carried as unsourced.
     let references = [];
     if (Array.isArray(claim.factIds)) references = claim.factIds;
     else if (Array.isArray(claim.facts)) references = claim.facts;

package/src/runtime/office/design/docx/design-docx/section.mjs

@@ -39,10 +39,10 @@ function writeSectionHeading(w, section) {
 function writeSectionList(w, section, sectionKind, blockFollows = false) {
   const { append, colors, type, bodySize, spacing } = w;
   const sectionBullets = strings(section.bullets);
-  // A section that names steps draws them. They used to reach the page only
-  // when the section also declared kind:'roadmap', so a plan section landed as
-  // a heading with nothing under it - and the audit reported the orphan heading
-  // the composer had just written.
+  // A section that names steps draws them. Reaching the page only with
+  // kind:'roadmap' would land a plan section as a heading with nothing under
+  // it - and the audit would report the orphan heading the composer had just
+  // written.
   const sectionSteps = Array.isArray(section.steps) ? section.steps : [];
   const stepSource = sectionSteps.length ? sectionSteps : sectionBullets;
   const drewSteps =
@@ -76,8 +76,8 @@ function writeSectionList(w, section, sectionKind, blockFollows = false) {
   });
 }
 
-// What a section can carry. A field outside this list used to vanish: a plan written as `roadmap:[…]` reached the
-// page as a heading with nothing under it, and the composer reported success.
+// What a section can carry. A field outside this list would vanish: a plan written as `roadmap:[…]` would reach the
+// page as a heading with nothing under it, and the composer would report success.
 const SECTION_FIELDS = new Set([
   'heading',
   'title',

package/src/runtime/office/design/xlsx/design-xlsx-components.mjs

@@ -197,7 +197,7 @@ export function addXlsxDecisionPanel(
       cursor += 1;
     });
   }
-  // The actions follow the gates rather than stand in for them: given both, the actions used to be dropped.
+  // The actions follow the gates rather than stand in for them: given both, the actions would be dropped.
   if (gateRows.length && strings(actions).length) cursor += 1;
   for (const action of strings(actions).slice(0, 4)) {
     mergedBlock(output, {

package/src/runtime/office/design/xlsx/design-xlsx.mjs

@@ -417,7 +417,7 @@ function metricLabelStyle({ colors, type, dashboard }) {
 // metric is the one the strip paints as the headline, so the wider card reads
 // as emphasis rather than as a card that ran out of room.
 // More cards than columns wrap onto a second strip rather than pulling the
-// canvas past the table: a three-metric strip over a two-column table used to
+// canvas past the table: a three-metric strip over a two-column table would
 // make every band half again as wide as the table under it.
 // The text a card's value shows under its number format ("47.0%" for 0.47 under 0.0%, "12명" for 12 under 0"명").
 function metricDisplayText(metric) {

package/src/runtime/office/pdf/ocr-engine.mjs

@@ -9,7 +9,7 @@ import { workerExecArgv } from '../../shared/worker-exec-argv.mjs';
 const ENGINE_URL = new URL('./ocr-engine-worker.mjs', import.meta.url);
 
 /** The start includes the first-use download; without network it fails or hangs. */
-export const OCR_ENGINE_START_TIMEOUT_MS = 90_000;
+const OCR_ENGINE_START_TIMEOUT_MS = 90_000;
 
 const engines = new Map();
 

package/src/runtime/office/pdf/pdf-writer.mjs

@@ -13,10 +13,10 @@ const HEADING_SIZES = Object.freeze({ 1: 16, 2: 13, 3: 12 });
 
 const FLOW_FIELDS = ['before', 'after', 'x', 'width', 'color', 'align'];
 
-// What each block actually takes. A block the writer cannot read used to flow
-// as an empty paragraph: a table or a list written under the wrong key left no
-// mark on the page and no word in the result, so the report shipped without
-// the evidence it was asked for.
+// What each block actually takes. A block the writer cannot read would flow
+// as an empty paragraph: a table or a list written under the wrong key would
+// leave no mark on the page and no word in the result, so the report would ship
+// without the evidence it was asked for.
 const BLOCK_FIELDS = Object.freeze({
   paragraph: Object.freeze({ required: ['text'], optional: [...FLOW_FIELDS, 'size', 'lineHeight'] }),
   heading: Object.freeze({ required: ['text'], optional: [...FLOW_FIELDS, 'size', 'lineHeight', 'level'] }),

package/src/runtime/office/portable/portable-docx-operations.mjs

@@ -825,8 +825,8 @@ function styledDocxCell(cell, op) {
 }
 
 // A merged cell keeps what it carried (its shading, its borders, the bottom alignment a header row sits on, as Word
-// keeps them) and takes the spans; its width becomes the widths it joins. The whole tcPr used to be replaced, and a
-// two-level header's merged labels rose to the top of their cells on this backend only. Children stay in schema
+// keeps them) and takes the spans; its width becomes the widths it joins. Replacing the whole tcPr would make a
+// two-level header's merged labels rise to the top of their cells on this backend only. Children stay in schema
 // order: cnfStyle, tcW, gridSpan, vMerge, then the rest.
 function mergedCellXml(joined, spans) {
   const existing = /<w:tcPr(?:\s[^>]*)?>([\s\S]*?)<\/w:tcPr>/.exec(joined[0])?.[1] || '';

package/src/runtime/office/portable/portable-soffice.mjs

@@ -1,6 +1,7 @@
 import { basename, dirname, extname, join } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { execFile, spawn } from 'node:child_process';
+import { treeKillCommand } from '../../agent/orchestrator/mcp/child-tree.mjs';
 import { redactDirectories } from '../../shared/redact-directories.mjs';
 import { removeDirectoryWithRetry } from '../../shared/remove-directory.mjs';
 import { constants as fsConstants, rmSync } from 'node:fs';
@@ -53,11 +54,11 @@ const SOFFICE_KILL_GRACE_MS = 10_000;
 // launcher leaves running (and holding the files it was given); Windows needs
 // the whole tree stopped.
 // The tree is stopped asynchronously and the helper itself is bounded, so a
-// cancellation never blocks the event loop or waits on a stuck taskkill.
-const SOFFICE_TASKKILL_TIMEOUT_MS = 5_000;
+// cancellation never blocks the event loop or waits on a stuck tree kill.
+const SOFFICE_TREE_KILL_TIMEOUT_MS = 5_000;
 
-// The launcher is killed only once taskkill is done (or out of time): a launcher
-// that exits first leaves taskkill with no descendants to find.
+// The launcher is killed only once the tree kill is done (or out of time): a
+// launcher that exits first leaves the tree kill with no descendants to find.
 function killProcessTree(child) {
   if (process.platform !== 'win32' || !child.pid) {
     killQuietly(child);
@@ -71,7 +72,8 @@ function killProcessTree(child) {
   };
   let killer = null;
   try {
-    killer = spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+    const { command, args } = treeKillCommand([child.pid]);
+    killer = spawn(command, args, { windowsHide: true, stdio: 'ignore' });
   } catch {
     killLauncher();
     return;
@@ -79,7 +81,7 @@ function killProcessTree(child) {
   const bound = setTimeout(() => {
     killQuietly(killer);
     killLauncher();
-  }, SOFFICE_TASKKILL_TIMEOUT_MS);
+  }, SOFFICE_TREE_KILL_TIMEOUT_MS);
   bound.unref?.();
   const settle = () => {
     clearTimeout(bound);

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

@@ -290,7 +290,7 @@ const VALIDATION_CHOICE_RANGE = /^(?:'[^']+'!|[A-Za-z_][\w.]*!)?\$?[A-Z]{1,3}\$?
 
 // A dropdown names its choices — "서울,부산" — or points at the cells holding
 // them; anything that compares, calls, or tests is a rule the sheet evaluates.
-export function listValidationFormula(formula1) {
+function listValidationFormula(formula1) {
   const text = String(formula1 ?? '')
     .trim()
     .replace(/^=/, '');

package/src/runtime/shared/atomic-file.d.mts

@@ -34,6 +34,14 @@ export function writeJsonAtomicSync(
   options?: AtomicFileOptions & { compact?: boolean }
 ): boolean;
 
+/** Locked read-modify-write: `mutator` gets the current value (null when
+ *  missing) and returns the next one, or undefined to leave the file as is. */
+export function updateJsonAtomic<T = unknown>(
+  filePath: string,
+  mutator: (current: unknown) => T | undefined,
+  options?: AtomicFileOptions & { compact?: boolean }
+): Promise<T | unknown>;
+
 export interface JsonStateOptions<T> {
   /** Maps the parsed value; throwing marks the file damaged. */
   validate?: (value: unknown) => T;

package/src/runtime/shared/background-tasks.mjs

@@ -243,8 +243,13 @@ export function getBackgroundTask(taskId, options = {}) {
   return task;
 }
 
-function countsAsActive(task, wanted, awaitedOnly) {
-  return task.status === 'running' && !(awaitedOnly && task.detached === true) && (!wanted || task.surface === wanted);
+function countsAsActive(task, wanted, awaitedOnly, match = null) {
+  return (
+    task.status === 'running' &&
+    !(awaitedOnly && task.detached === true) &&
+    (!wanted || task.surface === wanted) &&
+    (!match || match(task) === true)
+  );
 }
 
 /** Lifetime signal: a session-owned background task remains live
@@ -256,9 +261,14 @@ function countsAsActive(task, wanted, awaitedOnly) {
 export function hasActiveBackgroundTasks(options = {}) {
   const wanted = clean(options.surface);
   const awaitedOnly = options.awaitedOnly === true;
+  // Optional caller predicate over the running task (background-wait.mjs).
+  const match = typeof options.match === 'function' ? options.match : null;
   const scope = normalizeTaskScope(options);
   for (const task of tasks.values()) {
-    if (countsAsActive(task, wanted, awaitedOnly) && taskMatchesScope(task, scope, { includeUnattributed: false })) {
+    if (
+      countsAsActive(task, wanted, awaitedOnly, match) &&
+      taskMatchesScope(task, scope, { includeUnattributed: false })
+    ) {
       return true;
     }
   }
@@ -565,10 +575,18 @@ export function reconcileBackgroundTask(
 
 export function renderBackgroundTaskNotification(task) {
   if (!task) return '';
-  const result =
+  const body =
     task.surface === 'agent' && typeof task.result?.content === 'string'
       ? task.result.content
       : resultTextForTask(task);
+  // An owner-supplied trailer (an agent's unfinished todo items).
+  let appendix = '';
+  try {
+    appendix = typeof task.reportAppendix === 'function' ? String(task.reportAppendix() || '') : '';
+  } catch {
+    appendix = '';
+  }
+  const result = appendix ? [body, appendix].filter(Boolean).join('\n\n') : body;
   if (task.surface === 'shell') {
     const parsed = parseTaskNotification(result);
     // The completion envelope already carries the result (exit code,

package/src/runtime/shared/background-wait.mjs

@@ -0,0 +1,66 @@
+// The one rule for "this session is waiting on work that will wake it": an
+// agent it started is still running, or a background shell job it started in
+// the CURRENT user cycle (since its last genuine user prompt) is still
+// running — started with `background: true` or moved to the background after
+// its hold alike; its completion arrives as a task notification. Running jobs
+// from earlier cycles (long-lived servers, watchers) and the processes a
+// finished command left behind (`detached`) never count. The cycle is stamped
+// on the job when it starts (stampShellJobCycle), never read from its command.
+// Shared by the end-of-turn todo completion check and Goal auto-continuation.
+import { clean } from './clean.mjs';
+import { hasActiveBackgroundTasks } from './background-tasks.mjs';
+
+// Session id -> its user cycle number. In memory like the shell jobs it
+// stamps: a restarted process has no running jobs from an earlier cycle.
+const userCycles = new Map();
+
+/** A genuine user prompt opened a new cycle for `sessionId`. */
+export function beginUserCycle(sessionId) {
+  const id = clean(sessionId);
+  if (id) userCycles.set(id, (userCycles.get(id) || 0) + 1);
+}
+
+const currentUserCycle = (sessionId) => userCycles.get(clean(sessionId)) || 0;
+
+/** Record on a starting background shell job the owner's current cycle. */
+export function stampShellJobCycle(task) {
+  if (task?.ownerSessionId) task.userCycle = currentUserCycle(task.ownerSessionId);
+  return task;
+}
+
+const ACTIVE_AGENT_STATUSES = new Set([
+  'connecting',
+  'requesting',
+  'streaming',
+  'tool_running',
+  'running',
+  'cancelling',
+]);
+
+/** A running agent among published status rows (`agentJobs` / `agentWorkers`). */
+function runningAgentWork(agentStatus) {
+  const jobs = Array.isArray(agentStatus?.agentJobs) ? agentStatus.agentJobs : [];
+  if (jobs.some((job) => clean(job?.status).toLowerCase() === 'running')) return true;
+  const workers = Array.isArray(agentStatus?.agentWorkers) ? agentStatus.agentWorkers : [];
+  return workers.some((worker) => {
+    const status = clean(worker?.status).toLowerCase();
+    const stage = clean(worker?.stage || worker?.worker_stage).toLowerCase();
+    return ACTIVE_AGENT_STATUSES.has(status) || ACTIVE_AGENT_STATUSES.has(stage);
+  });
+}
+
+/** Whether `sessionId` waits on an agent or an awaited background shell. */
+export function awaitingBackgroundWork({ sessionId = null, agentStatus = null } = {}) {
+  if (runningAgentWork(agentStatus)) return true;
+  const id = clean(sessionId);
+  if (!id) return false;
+  return (
+    hasActiveBackgroundTasks({ callerSessionId: id, surface: 'agent' }) ||
+    hasActiveBackgroundTasks({
+      callerSessionId: id,
+      surface: 'shell',
+      awaitedOnly: true,
+      match: (task) => task.userCycle === currentUserCycle(id),
+    })
+  );
+}

package/src/runtime/shared/child-guardian.mjs

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { TREE_KILL_DEADLINE_MS, treeKillCommand } from '../agent/orchestrator/mcp/child-tree.mjs';
 import { positiveInt } from './numbers.mjs';
 import { isPidAlive } from './pid-liveness.mjs';
 import { detachedSpawnOpts } from './spawn-flags.mjs';
@@ -46,15 +47,18 @@ function alive(pid) {
   try { process.kill(pid, 0); return true; }
   catch (error) { return error && error.code === 'EPERM'; }
 }
+// Windows: the owner's creation-checked tree kill (child-tree.mjs), built when
+// the child was registered. A signal there is a forced kill either way.
 function killTarget(target, force) {
   if (platform === 'win32') {
-    const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\\\Windows';
-    const taskkill = systemRoot + '\\\\System32\\\\taskkill.exe';
-    if (force) {
-      try { spawnSync(taskkill, ['/PID', String(target.childPid), '/T', '/F'], { stdio: 'ignore', windowsHide: true }); } catch {}
-    } else {
-      try { process.kill(target.childPid, 'SIGTERM'); } catch {}
-      try { spawnSync(taskkill, ['/PID', String(target.childPid), '/T'], { stdio: 'ignore', windowsHide: true }); } catch {}
+    if (target.killCommand) {
+      try {
+        spawnSync(target.killCommand.command, target.killCommand.args, {
+          stdio: 'ignore',
+          windowsHide: true,
+          timeout: target.killCommand.timeoutMs,
+        });
+      } catch {}
     }
     return;
   }
@@ -84,6 +88,8 @@ function accept(message) {
     orphanGraceMs: Math.max(100, Number(message.orphanGraceMs) || 3000),
     forceGraceMs: Math.max(100, Number(message.forceGraceMs) || 3000),
     receiptPath: typeof message.receiptPath === 'string' ? message.receiptPath : null,
+    killCommand: message.killCommand && typeof message.killCommand.command === 'string'
+      && Array.isArray(message.killCommand.args) && message.killCommand.timeoutMs > 0 ? message.killCommand : null,
     orphanedAt: 0,
     lastPolledAt: 0,
     killing: false,
@@ -255,6 +261,10 @@ export function startChildGuardian({
     orphanGraceMs: Math.max(100, Math.floor(Number(orphanGraceMs) || Number(graceMs) || 3000)),
     forceGraceMs: Math.max(100, Math.floor(Number(forceGraceMs) || Number(graceMs) || 3000)),
     receiptPath: typeof receiptPath === 'string' && receiptPath ? receiptPath : null,
+    // The child runs now, so its creation time bounds every later kill.
+    // Held to the shared deadline, so a hung pass never stalls the guardian.
+    killCommand:
+      process.platform === 'win32' ? { ...treeKillCommand([child]), timeoutMs: TREE_KILL_DEADLINE_MS } : null,
     onRemoved: () => {
       stopped = true;
     },