@geraldmaron/construct 1.0.5 → 1.0.7

package/lib/doctor/watchers/mcp-protocol.mjs

@@ -0,0 +1,232 @@
+/**
+ * lib/doctor/watchers/mcp-protocol.mjs — MCP handshake health probe.
+ *
+ * Sweeps every MCP server configured in the active editor configs (Claude
+ * Code, OpenCode) and performs a real MCP handshake against each: send
+ * `initialize`, parse the response, send `tools/list`, report tool count.
+ * cass-memory v0.2.x (the original cause of construct-1qt) rejects the
+ * handshake outright; this watcher flags servers that fail the handshake so
+ * the dashboard surfaces a protocol problem rather than a port-up false
+ * positive.
+ *
+ * Severity defaults to warning. Set `CONSTRUCT_MCP_PROTOCOL_BLOCKING=1` to
+ * escalate via `service.down` when a configured server fails the handshake.
+ *
+ * Tick: 10 min. Cheap — most checks are skipped when no editor configs exist.
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { record } from '../audit.mjs';
+import { escalate } from '../escalate.mjs';
+
+export const name = 'mcp-protocol';
+export const intervalMs = 10 * 60 * 1000;
+
+const PROBE_TIMEOUT_MS = 5000;
+const HANDSHAKE_REQUEST_ID = 1;
+
+function readJson(file) {
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+export function collectMcpServers({ home = homedir() } = {}) {
+  const servers = [];
+  const claudePath = join(home, '.claude', 'settings.json');
+  if (existsSync(claudePath)) {
+    const cfg = readJson(claudePath);
+    for (const [id, entry] of Object.entries(cfg?.mcpServers ?? {})) {
+      servers.push({ host: 'claude', id, entry });
+    }
+  }
+  const opencodePath = join(home, '.config', 'opencode', 'opencode.json');
+  if (existsSync(opencodePath)) {
+    const cfg = readJson(opencodePath);
+    for (const [id, entry] of Object.entries(cfg?.mcp ?? {})) {
+      servers.push({ host: 'opencode', id, entry });
+    }
+  }
+  return servers;
+}
+
+function classifyEntry(entry) {
+  if (!entry || typeof entry !== 'object') return { transport: 'unknown' };
+  if (entry.type === 'http' || entry.type === 'remote') {
+    return { transport: 'http', url: entry.url, headers: entry.headers ?? {} };
+  }
+  if (entry.type === 'local') {
+    const cmd = Array.isArray(entry.command) ? entry.command : [];
+    return { transport: 'stdio', command: cmd[0], args: cmd.slice(1), env: entry.environment ?? {} };
+  }
+  if (entry.command) {
+    return { transport: 'stdio', command: entry.command, args: entry.args ?? [], env: entry.env ?? {} };
+  }
+  return { transport: 'unknown' };
+}
+
+async function probeHttp({ url, headers }) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+  try {
+    const body = {
+      jsonrpc: '2.0',
+      id: HANDSHAKE_REQUEST_ID,
+      method: 'initialize',
+      params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'construct-doctor', version: '1' } },
+    };
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream', ...headers },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      return { ok: false, reason: `HTTP ${res.status} on initialize` };
+    }
+    const text = await res.text();
+    let parsed;
+    try { parsed = JSON.parse(text); } catch {
+      return { ok: false, reason: 'initialize response was not JSON' };
+    }
+    if (parsed?.error) {
+      return { ok: false, reason: `initialize returned error: ${parsed.error.message ?? parsed.error.code}` };
+    }
+    if (/Unsupported method/i.test(text)) {
+      return { ok: false, reason: 'backend rejects initialize (Unsupported method)' };
+    }
+    return { ok: true, protocolVersion: parsed?.result?.protocolVersion };
+  } catch (err) {
+    const reason = err?.name === 'AbortError' ? 'timeout' : (err?.message || String(err));
+    return { ok: false, reason };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function spawnStdioServer({ command, args, env }) {
+  const child = spawn(command, args ?? [], {
+    env: { ...process.env, ...(env ?? {}) },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  const frames = [];
+  let buffer = '';
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', (chunk) => {
+    buffer += chunk;
+    let idx;
+    while ((idx = buffer.indexOf('\n')) >= 0) {
+      const raw = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (!raw) continue;
+      try { frames.push(JSON.parse(raw)); } catch { /* skip junk */ }
+    }
+  });
+  child.stderr.on('data', () => { /* swallow */ });
+  return { child, frames };
+}
+
+async function waitFor(frames, predicate, deadline) {
+  while (Date.now() < deadline) {
+    const hit = frames.find(predicate);
+    if (hit) return hit;
+    await new Promise((r) => setTimeout(r, 25));
+  }
+  return null;
+}
+
+async function probeStdio(spec) {
+  if (!spec.command) return { ok: false, reason: 'stdio entry missing command' };
+  let session;
+  try {
+    session = spawnStdioServer(spec);
+  } catch (err) {
+    return { ok: false, reason: `spawn failed: ${err?.message || err}` };
+  }
+  const { child, frames } = session;
+  const deadline = Date.now() + PROBE_TIMEOUT_MS;
+
+  try {
+    child.stdin.write(JSON.stringify({
+      jsonrpc: '2.0',
+      id: HANDSHAKE_REQUEST_ID,
+      method: 'initialize',
+      params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'construct-doctor', version: '1' } },
+    }) + '\n');
+
+    const initFrame = await waitFor(frames, (f) => f.id === HANDSHAKE_REQUEST_ID, deadline);
+    if (!initFrame) return { ok: false, reason: 'no initialize response within timeout' };
+    if (initFrame.error) return { ok: false, reason: `initialize error: ${initFrame.error.message ?? initFrame.error.code}` };
+
+    child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+    child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} }) + '\n');
+
+    const toolsFrame = await waitFor(frames, (f) => f.id === 2, deadline);
+    if (!toolsFrame) return { ok: false, reason: 'no tools/list response within timeout' };
+    if (toolsFrame.error) return { ok: false, reason: `tools/list error: ${toolsFrame.error.message ?? toolsFrame.error.code}` };
+
+    const tools = toolsFrame.result?.tools ?? [];
+    return {
+      ok: true,
+      protocolVersion: initFrame.result?.protocolVersion,
+      toolCount: Array.isArray(tools) ? tools.length : 0,
+    };
+  } finally {
+    try { child.kill('SIGTERM'); } catch { /* already exited */ }
+  }
+}
+
+export async function probeServer({ host, id, entry }) {
+  const spec = classifyEntry(entry);
+  if (spec.transport === 'unknown') return { host, id, transport: 'unknown', ok: false, reason: 'unrecognized entry shape' };
+  const result = spec.transport === 'http' ? await probeHttp(spec) : await probeStdio(spec);
+  return { host, id, transport: spec.transport, ...result };
+}
+
+export async function tick() {
+  const actions = [];
+  const escalations = [];
+  const samples = [];
+
+  const servers = collectMcpServers();
+  for (const server of servers) {
+    const result = await probeServer(server);
+    samples.push(result);
+
+    if (result.ok) {
+      record({
+        kind: 'sample',
+        watcher: name,
+        target: `${result.host}/${result.id}`,
+        result: 'ok',
+        summary: `${result.host}/${result.id} MCP handshake ok (transport=${result.transport})`,
+        context: { protocolVersion: result.protocolVersion, toolCount: result.toolCount },
+      });
+      continue;
+    }
+
+    record({
+      kind: 'sample',
+      watcher: name,
+      target: `${result.host}/${result.id}`,
+      result: 'warn',
+      summary: `${result.host}/${result.id} MCP handshake failed: ${result.reason}`,
+      context: { transport: result.transport, reason: result.reason },
+    });
+    actions.push({ type: 'protocol-warning', target: `${result.host}/${result.id}`, reason: result.reason });
+
+    if (process.env.CONSTRUCT_MCP_PROTOCOL_BLOCKING === '1') {
+      const r = await escalate({
+        watcher: name,
+        eventType: 'service.down',
+        summary: `MCP handshake failed for ${result.host}/${result.id}: ${result.reason}`,
+        context: { host: result.host, id: result.id, transport: result.transport, reason: result.reason },
+      });
+      escalations.push({ eventType: 'service.down', target: `${result.host}/${result.id}`, result: r });
+    }
+  }
+
+  return { actions, escalations, notes: samples };
+}

package/lib/document-extract.mjs

@@ -10,6 +10,11 @@ import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, extname, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
 
+// 50 MB hard cap mirrors lib/embed/inbox.mjs and lib/observation-store.mjs.
+// Anything larger is intentionally not extracted to keep the daemon path
+// bounded; callers receive an empty text plus a `skipped` marker.
+const MAX_EML_BYTES = 50 * 1024 * 1024;
+
 export const UTF8_TEXT_EXTS = new Set([
   '.md', '.txt', '.rst', '.adoc', '.json', '.yaml', '.yml', '.toml',
   '.js', '.mjs', '.ts', '.tsx', '.jsx', '.py', '.go', '.rs', '.sh', '.bash',
@@ -21,11 +26,13 @@ export const UTF8_TEXT_EXTS = new Set([
 export const ZIP_DOCUMENT_EXTS = new Set(['.docx', '.xlsx', '.pptx', '.odt', '.ods']);
 export const RICH_TEXT_EXTS = new Set(['.doc', '.rtf']);
 export const MDLS_DOCUMENT_EXTS = new Set(['.xls', '.ppt', '.pages', '.numbers', '.key']);
+export const EMAIL_DOCUMENT_EXTS = new Set(['.eml']);
 export const EXTRACTABLE_DOCUMENT_EXTS = new Set([
   ...UTF8_TEXT_EXTS,
   ...ZIP_DOCUMENT_EXTS,
   ...RICH_TEXT_EXTS,
   ...MDLS_DOCUMENT_EXTS,
+  ...EMAIL_DOCUMENT_EXTS,
   '.pdf',
 ]);
 
@@ -176,6 +183,203 @@ export function isExtractableDocumentPath(filePath) {
   return EXTRACTABLE_DOCUMENT_EXTS.has(extname(filePath).toLowerCase());
 }
 
+// Minimal RFC 5322 header decoder. Unfolds continuation lines (a line that
+// begins with whitespace continues the previous header) and splits each
+// header into (name, value). Stops at the first blank line, which RFC 5322
+// defines as the header/body separator.
+function parseRfc5322Headers(headerBlock) {
+  const lines = headerBlock.split('\n');
+  const unfolded = [];
+  for (const line of lines) {
+    if (/^[ \t]/.test(line) && unfolded.length > 0) {
+      unfolded[unfolded.length - 1] += ' ' + line.trim();
+    } else {
+      unfolded.push(line);
+    }
+  }
+  const headers = {};
+  for (const line of unfolded) {
+    const idx = line.indexOf(':');
+    if (idx === -1) continue;
+    const name = line.slice(0, idx).trim().toLowerCase();
+    const value = line.slice(idx + 1).trim();
+    if (!name) continue;
+    // Multiple Received headers are common; keep the first occurrence of
+    // any header so From/Subject/Date pick the outermost value.
+    if (!(name in headers)) headers[name] = value;
+  }
+  return headers;
+}
+
+// Split a Content-Type header value into the bare type and a parameter map.
+// Returns { type, params } where type is lowercased and stripped, params is
+// keyed by lowercased name with values stripped of surrounding quotes.
+function parseContentType(value) {
+  if (!value) return { type: '', params: {} };
+  const parts = value.split(';').map((s) => s.trim()).filter(Boolean);
+  const type = (parts.shift() || '').toLowerCase();
+  const params = {};
+  for (const part of parts) {
+    const idx = part.indexOf('=');
+    if (idx === -1) continue;
+    const k = part.slice(0, idx).trim().toLowerCase();
+    let v = part.slice(idx + 1).trim();
+    if (v.startsWith('"') && v.endsWith('"')) v = v.slice(1, -1);
+    params[k] = v;
+  }
+  return { type, params };
+}
+
+// Split a multipart body on the boundary marker. Each returned segment is
+// itself a mini MIME entity (its own header block, blank line, body). The
+// closing `--boundary--` terminator is honored by stripping anything past
+// it. Boundaries that do not appear in the body produce a single segment.
+function splitMultipart(body, boundary) {
+  if (!boundary) return [body];
+  const marker = '--' + boundary;
+  const closer = marker + '--';
+  const closeIdx = body.indexOf(closer);
+  const scoped = closeIdx === -1 ? body : body.slice(0, closeIdx);
+  const segments = scoped.split(marker);
+  // The piece before the first boundary is the preamble; discard it.
+  return segments.slice(1).map((seg) => seg.replace(/^\r?\n/, '').replace(/\r?\n$/, ''));
+}
+
+// Decode a quoted-printable body. Tolerant: malformed `=XX` sequences are
+// passed through verbatim rather than throwing, which matches real-world
+// mailers more closely than a strict decoder.
+function decodeQuotedPrintable(text) {
+  return text
+    .replace(/=\r?\n/g, '')
+    .replace(/=([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+
+function decodeTransferEncoded(text, encoding) {
+  const enc = String(encoding || '').toLowerCase();
+  if (enc === 'quoted-printable') return decodeQuotedPrintable(text);
+  if (enc === 'base64') {
+    try { return Buffer.from(text.replace(/\s+/g, ''), 'base64').toString('utf8'); } catch { return text; }
+  }
+  return text;
+}
+
+// Walk a parsed MIME entity, returning the first text/plain body it finds
+// and a flat list of attachment filenames encountered along the way. The
+// walker stops at depth 8 so a hand-crafted pathological message cannot
+// exhaust the stack.
+function walkMimeForPlainText(rawEntity, depth = 0) {
+  if (depth > 8) return { text: '', attachments: [] };
+  const sepIdx = rawEntity.indexOf('\n\n') !== -1
+    ? rawEntity.indexOf('\n\n')
+    : rawEntity.indexOf('\r\n\r\n');
+  if (sepIdx === -1) return { text: '', attachments: [] };
+  const headerBlock = rawEntity.slice(0, sepIdx);
+  const body = rawEntity.slice(sepIdx).replace(/^\r?\n\r?\n/, '');
+  const headers = parseRfc5322Headers(headerBlock);
+  const { type, params } = parseContentType(headers['content-type'] || 'text/plain');
+  const disposition = parseContentType(headers['content-disposition'] || '');
+  const filename = disposition.params.filename || params.name || null;
+
+  if (type.startsWith('multipart/')) {
+    const attachments = [];
+    let firstPlain = '';
+    for (const seg of splitMultipart(body, params.boundary)) {
+      const child = walkMimeForPlainText(seg, depth + 1);
+      attachments.push(...child.attachments);
+      if (!firstPlain && child.text) firstPlain = child.text;
+    }
+    return { text: firstPlain, attachments };
+  }
+
+  if (disposition.type === 'attachment' && filename) {
+    return { text: '', attachments: [filename] };
+  }
+
+  if (type === '' || type === 'text/plain') {
+    return {
+      text: decodeTransferEncoded(body, headers['content-transfer-encoding']),
+      attachments: [],
+    };
+  }
+
+  // Non-plain leaves with an explicit filename are treated as attachments.
+  if (filename) return { text: '', attachments: [filename] };
+  return { text: '', attachments: [] };
+}
+
+/**
+ * Extract a normalized representation of an .eml message.
+ *
+ * Returns { text, headers, attachments, skipped } where:
+ *   text         concatenates Subject, From, Date and the first text/plain
+ *                body, suitable for direct hand-off to the classifier.
+ *   headers      decoded From, Subject, Date, To (raw strings).
+ *   attachments  filenames of every non-plain part with a Content-Disposition
+ *                of `attachment` or a filename parameter. Bodies are skipped.
+ *   skipped      set to `'too large'` if the message exceeded MAX_EML_BYTES;
+ *                in that case text is empty and no parsing was attempted.
+ *
+ * The parser is intentionally minimal: it understands header folding, the
+ * `--boundary` framing of multipart messages, and quoted-printable / base64
+ * transfer encodings. It does not decode RFC 2047 encoded-word headers, does
+ * not chase nested message/rfc822 envelopes, and does not validate signatures.
+ */
+export function extractEmlMessage(filePath) {
+  const stat = statSync(filePath);
+  if (stat.size > MAX_EML_BYTES) {
+    return { text: '', headers: {}, attachments: [], skipped: 'too large' };
+  }
+  const raw = readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  const sepIdx = raw.indexOf('\n\n');
+  if (sepIdx === -1) {
+    // No header/body separator. Treat the whole file as the body.
+    return {
+      text: normalizeText(raw),
+      headers: {},
+      attachments: [],
+    };
+  }
+  const headerBlock = raw.slice(0, sepIdx);
+  const body = raw.slice(sepIdx + 2);
+  const headers = parseRfc5322Headers(headerBlock);
+  const { type, params } = parseContentType(headers['content-type'] || 'text/plain');
+
+  let bodyText = '';
+  const attachments = [];
+  if (type.startsWith('multipart/')) {
+    for (const seg of splitMultipart(body, params.boundary)) {
+      const child = walkMimeForPlainText(seg);
+      attachments.push(...child.attachments);
+      if (!bodyText && child.text) bodyText = child.text;
+    }
+  } else {
+    bodyText = decodeTransferEncoded(body, headers['content-transfer-encoding']);
+  }
+
+  const subject = headers.subject || '';
+  const from = headers.from || '';
+  const date = headers.date || '';
+  const to = headers.to || '';
+  const text = normalizeText(
+    `Subject: ${subject}\nFrom: ${from}\nDate: ${date}\n\n${bodyText}`,
+  );
+  return {
+    text,
+    headers: { subject, from, date, to },
+    attachments,
+  };
+}
+
+function extractEml(filePath) {
+  const message = extractEmlMessage(filePath);
+  return {
+    text: message.text,
+    method: message.skipped ? 'eml-skipped' : 'eml',
+    skipped: message.skipped || null,
+    attachments: message.attachments,
+  };
+}
+
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
 const URL_RE = /https?:\/\/[^\s)>\]"'`]+/g;
 const DATE_KEYS = ['date', 'created', 'created_at', 'updated', 'updated_at', 'published', 'last_modified'];
@@ -268,6 +472,7 @@ export function extractDocumentText(filePath, { maxChars = null } = {}) {
   else if (ZIP_DOCUMENT_EXTS.has(extension)) extracted = extractZipDocument(resolvedPath, extension);
   else if (RICH_TEXT_EXTS.has(extension)) extracted = extractRichText(resolvedPath);
   else if (MDLS_DOCUMENT_EXTS.has(extension) && process.platform === 'darwin' && commandExists('mdls')) extracted = { text: extractWithMdls(resolvedPath), method: 'mdls' };
+  else if (EMAIL_DOCUMENT_EXTS.has(extension)) extracted = extractEml(resolvedPath);
   else if (extension === '.pdf') extracted = extractPdf(resolvedPath);
   else throw new Error(`Unsupported document type: ${extension || 'unknown'}`);
 
@@ -277,7 +482,7 @@ export function extractDocumentText(filePath, { maxChars = null } = {}) {
     : null;
   const truncated = limit !== null && text.length > limit;
 
-  return {
+  const result = {
     filePath: resolvedPath,
     extension,
     extractionMethod: extracted.method,
@@ -285,4 +490,9 @@ export function extractDocumentText(filePath, { maxChars = null } = {}) {
     truncated,
     characters: text.length,
   };
+  // Surface eml-specific metadata so callers (intake, ingest) can route
+  // attachment filenames and oversize-skip markers without re-parsing.
+  if (extracted.attachments) result.attachments = extracted.attachments;
+  if (extracted.skipped) result.skipped = extracted.skipped;
+  return result;
 }

package/lib/embed/cli.mjs

@@ -41,6 +41,83 @@ function logPath(homeDir = os.homedir()) {
   return path.join(runtimeDir(homeDir), LOG_FILE);
 }
 
+// ---------------------------------------------------------------------------
+// Log rotation
+//
+// The embed daemon writes its stdout/stderr to a single appended file. The
+// file descriptor is opened by the parent process at spawn time; the daemon
+// has no opportunity to reopen mid-flight. Rotation therefore happens at
+// each daemon spawn: if the existing log exceeds the size cap we shift
+// segments (.log → .log.1 → .log.2 → …) and drop the oldest, then the
+// spawn opens a fresh empty file.
+//
+// CONSTRUCT_EMBED_LOG_MAX_MB sets the rotation threshold (default 50 MB).
+// CONSTRUCT_EMBED_LOG_KEEP    sets retained segment count (default 3).
+// Worst-case disk footprint is (MAX_MB * (KEEP + 1)).
+// ---------------------------------------------------------------------------
+
+const DEFAULT_MAX_MB = 50;
+const DEFAULT_KEEP = 3;
+const HARD_CAP_MAX_MB = 500;     // refuse absurd configured values
+const HARD_CAP_KEEP = 20;
+
+function rotationConfig(env = process.env) {
+  const maxMbRaw = Number.parseInt(env.CONSTRUCT_EMBED_LOG_MAX_MB ?? '', 10);
+  const keepRaw = Number.parseInt(env.CONSTRUCT_EMBED_LOG_KEEP ?? '', 10);
+  const maxMb = Number.isFinite(maxMbRaw) && maxMbRaw > 0 ? Math.min(maxMbRaw, HARD_CAP_MAX_MB) : DEFAULT_MAX_MB;
+  const keep = Number.isFinite(keepRaw) && keepRaw >= 0 ? Math.min(keepRaw, HARD_CAP_KEEP) : DEFAULT_KEEP;
+  return { maxBytes: maxMb * 1024 * 1024, keep };
+}
+
+/**
+ * Rotate the embed daemon log if it exceeds the size cap. Exported for tests.
+ *
+ * @param {string} log        - Absolute path to the live log file
+ * @param {object} [env]      - Env object (default: process.env)
+ * @returns {{ rotated: boolean, sizeBytes: number, droppedSegment?: string }}
+ */
+export function rotateEmbedLogIfNeeded(log, env = process.env) {
+  let sizeBytes = 0;
+  try {
+    sizeBytes = fs.statSync(log).size;
+  } catch (err) {
+    if (err.code === 'ENOENT') return { rotated: false, sizeBytes: 0 };
+    process.stderr.write(`[cli.mjs] rotateEmbedLog stat: ${err.message}\n`);
+    return { rotated: false, sizeBytes: 0 };
+  }
+
+  const { maxBytes, keep } = rotationConfig(env);
+  if (sizeBytes <= maxBytes) return { rotated: false, sizeBytes };
+
+  // Shift segments oldest-first: .{keep} gets dropped, .{n} → .{n+1}, .log → .log.1
+  let droppedSegment;
+  try {
+    const oldest = `${log}.${keep}`;
+    if (keep === 0) {
+      // Retention of 0 means rotate-and-discard: the existing log is removed,
+      // no segment is kept.
+      fs.rmSync(log, { force: true });
+      droppedSegment = log;
+      return { rotated: true, sizeBytes, droppedSegment };
+    }
+    if (fs.existsSync(oldest)) {
+      fs.rmSync(oldest, { force: true });
+      droppedSegment = oldest;
+    }
+    for (let n = keep - 1; n >= 1; n--) {
+      const from = `${log}.${n}`;
+      const to = `${log}.${n + 1}`;
+      if (fs.existsSync(from)) fs.renameSync(from, to);
+    }
+    fs.renameSync(log, `${log}.1`);
+  } catch (err) {
+    process.stderr.write(`[cli.mjs] rotateEmbedLog: ${err.message}\n`);
+    return { rotated: false, sizeBytes };
+  }
+
+  return { rotated: true, sizeBytes, droppedSegment };
+}
+
 // ---------------------------------------------------------------------------
 // State helpers
 // ---------------------------------------------------------------------------
@@ -140,6 +217,7 @@ export async function autoStartEmbedIfNeeded(env = process.env, rootDir, homeDir
     const workerPath = path.join(resolvedRoot, 'lib', 'embed', 'worker.mjs');
     const log = logPath(homeDir);
     fs.mkdirSync(path.dirname(log), { recursive: true });
+    rotateEmbedLogIfNeeded(log, env);
     const fd = fs.openSync(log, 'a');
 
     const child = spawn(process.execPath, [workerPath], {
@@ -149,7 +227,18 @@ export async function autoStartEmbedIfNeeded(env = process.env, rootDir, homeDir
     });
     child.unref();
 
-    writeState({ pid: child.pid, configPath: 'auto', startedAt: new Date().toISOString() }, homeDir);
+    let resolvedRootDir = homeDir;
+    try {
+      const { resolveRootDir } = await import('./daemon.mjs');
+      resolvedRootDir = resolveRootDir(env, process.cwd());
+    } catch { /* fall back to homeDir */ }
+
+    writeState({
+      pid: child.pid,
+      configPath: 'auto',
+      startedAt: new Date().toISOString(),
+      rootDir: resolvedRootDir,
+    }, homeDir);
     return { started: true, pid: child.pid };
   } catch (err) {
     return { started: false, reason: `spawn_failed: ${err.message}` };
@@ -196,6 +285,7 @@ async function cmdEmbedStart(args, { homeDir = os.homedir(), rootDir, _workerPat
   const workerArgs = configPath ? [workerPath, '--config', configPath] : [workerPath];
   const log = logPath(homeDir);
   fs.mkdirSync(path.dirname(log), { recursive: true });
+  rotateEmbedLogIfNeeded(log, process.env);
   const fd = fs.openSync(log, 'a');
 
   const child = spawn(process.execPath, workerArgs, {
@@ -206,7 +296,21 @@ async function cmdEmbedStart(args, { homeDir = os.homedir(), rootDir, _workerPat
   fs.closeSync(fd);
   child.unref();
 
-  writeState({ pid: child.pid, configPath: configPath ?? 'auto', startedAt: new Date().toISOString() }, homeDir);
+  // Resolve rootDir using the same precedence the spawned worker will so the
+  // operator can see which inbox is being watched via `construct embed status`.
+
+  let resolvedRootDir = homeDir;
+  try {
+    const { resolveRootDir } = await import('./daemon.mjs');
+    resolvedRootDir = resolveRootDir(process.env, process.cwd());
+  } catch { /* fall back to homeDir */ }
+
+  writeState({
+    pid: child.pid,
+    configPath: configPath ?? 'auto',
+    startedAt: new Date().toISOString(),
+    rootDir: resolvedRootDir,
+  }, homeDir);
 
   // Brief liveness check — detects immediate crashes (e.g. missing module, bad config path)
   await new Promise(r => setTimeout(r, _livenessCheckMs));
@@ -245,15 +349,32 @@ function cmdEmbedStop(_args, { homeDir = os.homedir() } = {}) {
 // Subcommand: status
 // ---------------------------------------------------------------------------
 
-function cmdEmbedStatus(_args, { homeDir = os.homedir() } = {}) {
+async function cmdEmbedStatus(_args, { homeDir = os.homedir() } = {}) {
   const state = readRunningState(homeDir);
   if (!state) {
     process.stdout.write('embed daemon: stopped\n');
     return;
   }
+
+  // Re-resolve rootDir using the same precedence the daemon would so the
+  // operator sees which inbox is actually being watched (CX_DATA_DIR override,
+  // walked-up project root, or homedir fallback).
+
+  let rootDir = state.rootDir;
+  if (!rootDir) {
+    try {
+      const { resolveRootDir } = await import('./daemon.mjs');
+      rootDir = resolveRootDir(process.env, process.cwd());
+    } catch {
+      rootDir = homeDir;
+    }
+  }
+
   process.stdout.write(`embed daemon: running\n`);
   process.stdout.write(`  pid:        ${state.pid}\n`);
   process.stdout.write(`  config:     ${state.configPath}\n`);
+  process.stdout.write(`  rootDir:    ${rootDir}\n`);
+  process.stdout.write(`  inbox:      ${path.join(rootDir, '.cx', 'inbox')}\n`);
   process.stdout.write(`  started at: ${state.startedAt}\n`);
   process.stdout.write(`  log:        ${logPath(homeDir)}\n`);
 }