@yugabytedb/meko-mcp 2.2.0 → 2.3.0

package/assets/hooks-handlers/lib/checkpoint-timer.js

@@ -31,11 +31,14 @@ const {
   timerPidPath,
   watermarkDir,
   scanStates,
+  scanCompleteForDropClamp,
   sortOldestFirst,
   computeAggregateHealth,
   writeHealthCache,
   importLegacyCaptureErrors,
   legacyErrorsSafeToRemove,
+  isResumableState,
+  readState,
 } = require("./capture-state");
 
 const INTERVAL_SECS = Math.max(1, checkpointInterval());
@@ -185,11 +188,27 @@ function runCaptureChild(mode, payload, timeoutMs) {
   });
 }
 
+// MEKO-635: settle OpenCode pending turns past the 30-minute default.
+function sweepOpenCodeSettles() {
+  try {
+    const opencode = require("./opencode-handler");
+    if (typeof opencode.sweepExpiredSettles === "function") {
+      opencode.sweepExpiredSettles();
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[meko-timer] OpenCode settle sweep failed: ${err.message}\n`,
+    );
+  }
+}
+
 function rebuildHealth() {
   try {
     const scan = scanStates({ includeBlocked: true });
     const health = computeAggregateHealth(scan);
-    writeHealthCache(health);
+    writeHealthCache(health, {
+      clampDropped: scanCompleteForDropClamp(scan),
+    });
   } catch (err) {
     process.stderr.write(
       `[meko-timer] Health rebuild failed: ${err.message}\n`,
@@ -250,6 +269,10 @@ async function runRecoveryCycle() {
   const forcePersistentRetry = startupRecoveryPending;
   let moreWork = false;
   try {
+    // Finalize any resumable session whose settling window has expired before
+    // the scan snapshots eligibility. Otherwise recovery keeps draining a
+    // pending user (queued_exchanges === 1) whose assistant will never arrive.
+    sweepOpenCodeSettles();
     const scan = scanStates({
       includeBlocked: true,
       forcePersistentRetry,
@@ -292,11 +315,12 @@ async function runRecoveryCycle() {
       }
 
       const state = entry.state || {};
+      const resumable = isResumableState(state);
       const payload = {
         session_id: entry.session_id,
         transcript_path: state.transcript_path || undefined,
-        lifecycle: state.lifecycle === "closing" ? "closing" : "closing",
-        confirmed_dead: true,
+        lifecycle: resumable ? "active" : "closing",
+        confirmed_dead: !resumable,
         recorded_owner_only: true,
         max_exchanges: Math.min(budget, maxCaptureBatchSize()),
         force_retry: Boolean(
@@ -321,7 +345,10 @@ async function runRecoveryCycle() {
       const captured = Number((result && result.captured) || 0);
       budget -= captured;
       const queued = Number((result && result.queued_remaining) || 0);
-      if (queued > 0 || (result && result.status === "retry_wait")) {
+      if (
+        (queued > 0 || (result && result.status === "retry_wait")) &&
+        !(resumable && captured === 0 && queued <= 1 && result.status !== "retry_wait")
+      ) {
         moreWork = true;
       }
       if (result && (result.status === "partial" || result.status === "retry_wait" || result.status === "blocked")) {
@@ -346,7 +373,10 @@ async function runRecoveryCycle() {
           e.eligibility &&
           e.session_id !== sessionId &&
           Number(e.eligibility.queued_exchanges || 0) > 0 &&
-          e.eligibility.retry_due === false,
+          e.eligibility.retry_due === false &&
+          !(isResumableState(e.state) &&
+            Number(e.eligibility.queued_exchanges || 0) <= 1 &&
+            e.state && e.state.delivery === "pending"),
       );
     }
 
@@ -361,6 +391,14 @@ async function runRecoveryCycle() {
   return moreWork;
 }
 
+// MEKO-635: for the daemon's own session, look up whether its captured intent
+// declared a resumable pending-turn policy. If so, timer-idle and
+// transcript-gone paths must drain without finalizing the session as dead.
+function selfIsResumable() {
+  const read = readState(sessionId);
+  return read.ok ? isResumableState(read.state) : false;
+}
+
 async function tick() {
   if (tickInFlight) return;
   tickInFlight = true;
@@ -382,14 +420,16 @@ async function tick() {
         await runRecoveryCycle();
         return;
       }
-      // Transcript gone after grace — run one closing recovery for self, then exit.
+      // Transcript gone after grace. For a resumable session drain without
+      // finalizing so a later snapshot can complete its pending turn.
+      const resumable = selfIsResumable();
       await runCaptureChild(
         "drain",
         {
           session_id: sessionId,
           transcript_path: transcriptPath,
-          lifecycle: "closing",
-          confirmed_dead: true,
+          lifecycle: resumable ? "active" : "closing",
+          confirmed_dead: !resumable,
           recorded_owner_only: true,
         },
         CAPTURE_TIMEOUT_MS,
@@ -403,13 +443,14 @@ async function tick() {
       process.stderr.write(
         `[meko-timer] Transcript idle > ${IDLE_EXIT_SECS}s; final drain then exit.\n`,
       );
+      const resumable = selfIsResumable();
       await runCaptureChild(
         "drain",
         {
           session_id: sessionId,
           transcript_path: transcriptPath,
-          lifecycle: "closing",
-          confirmed_dead: true,
+          lifecycle: resumable ? "active" : "closing",
+          confirmed_dead: !resumable,
           recorded_owner_only: true,
         },
         CAPTURE_TIMEOUT_MS,

package/assets/hooks-handlers/lib/journal-bridge.js

@@ -0,0 +1,218 @@
+/** Fsynced OpenCode journal primitives; Kiro keeps a separate implementation. */
+"use strict";
+const fs = require("fs");
+const LOCK_RETRIES = 100;
+const LOCK_RETRY_MS = 10;
+function sleepSync(ms) {
+  const cell = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(cell, 0, 0, ms);
+}
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureEventDir(eventDir) {
+  fs.mkdirSync(eventDir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(eventDir, 0o700); } catch { /* best effort */ }
+}
+function acquireEventLock(lockPath, eventDir) {
+  ensureEventDir(eventDir);
+  for (let attempt = 0; attempt < LOCK_RETRIES; attempt++) {
+    try {
+      const fd = fs.openSync(lockPath, "wx", 0o600);
+      try {
+        fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, created_at: Date.now() }));
+      } finally {
+        fs.closeSync(fd);
+      }
+      return true;
+    } catch (err) {
+      if (!err || err.code !== "EEXIST") throw err;
+      let existing = null;
+      try { existing = JSON.parse(fs.readFileSync(lockPath, "utf8")); } catch {
+        try {
+          const st = fs.statSync(lockPath);
+          if (Date.now() - st.mtimeMs < 2000) {
+            sleepSync(LOCK_RETRY_MS);
+            continue;
+          }
+        } catch { /* gone */ }
+      }
+      if (!existing || !pidAlive(Number(existing.pid))) {
+        try { fs.unlinkSync(lockPath); } catch { /* another process won */ }
+        continue;
+      }
+      sleepSync(LOCK_RETRY_MS);
+    }
+  }
+  throw new Error(`timed out acquiring event lock ${lockPath}`);
+}
+function releaseEventLock(lockPath) {
+  try {
+    const current = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    if (Number(current.pid) === process.pid) fs.unlinkSync(lockPath);
+  } catch { /* already gone */ }
+}
+function atomicWriteJson(filePath, value, eventDir) {
+  ensureEventDir(eventDir);
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  const fd = fs.openSync(tmp, "w", 0o600);
+  try {
+    fs.writeFileSync(fd, `${JSON.stringify(value)}\n`, "utf8");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, filePath);
+  try { fs.chmodSync(filePath, 0o600); } catch { /* best effort */ }
+}
+function appendJournal(journalPath, record, eventDir) {
+  ensureEventDir(eventDir);
+  let separator = "";
+  try {
+    const contents = fs.readFileSync(journalPath);
+    if (contents.length > 0 && contents[contents.length - 1] !== 0x0a) {
+      separator = "\n";
+    }
+  } catch (err) {
+    if (!err || err.code !== "ENOENT") throw err;
+  }
+  const data = Buffer.from(`${separator}${JSON.stringify(record)}\n`, "utf8");
+  const fd = fs.openSync(journalPath, "a", 0o600);
+  try {
+    let offset = 0;
+    while (offset < data.length) {
+      const written = fs.writeSync(fd, data, offset, data.length - offset, null);
+      if (!Number.isInteger(written) || written <= 0) {
+        throw new Error(`could not append complete journal record to ${journalPath}`);
+      }
+      offset += written;
+    }
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try { fs.chmodSync(journalPath, 0o600); } catch { /* best effort */ }
+}
+function journalEmpty(journalPath) {
+  try { return fs.statSync(journalPath).size === 0; } catch { return true; }
+}
+function emptyEventState(sessionId) {
+  return {
+    schema_version: 1,
+    session_id: sessionId,
+    turn_index: 0,
+    pending: null,
+    seen_source_ids: [],
+    updated_at: new Date().toISOString(),
+  };
+}
+function rebuildEventState(journalPath, sessionId) {
+  const rebuilt = emptyEventState(sessionId);
+  let contents;
+  try {
+    contents = fs.readFileSync(journalPath, "utf8");
+  } catch {
+    return rebuilt;
+  }
+  for (const line of contents.split("\n")) {
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!record || record.session_id !== sessionId) continue;
+    if (record.type === "user") {
+      const content = record.message && record.message.content;
+      const text = Array.isArray(content) && content[0] && typeof content[0].text === "string"
+        ? content[0].text
+        : "";
+      const uuid = String(record.uuid || "");
+      rebuilt.turn_index += 1;
+      const mekoObservedMs =
+        record.meko && Number.isFinite(record.meko.observed_at_ms)
+          ? record.meko.observed_at_ms
+          : null;
+      const firstObservedAtMs = mekoObservedMs;
+      rebuilt.pending = {
+        user_uuid: uuid,
+        source_message_id: record.source_message_id || null,
+        turn_index: rebuilt.turn_index,
+        prompt_preview: text.slice(0, 80),
+        first_observed_at_ms: firstObservedAtMs,
+      };
+      if (record.source_message_id) rebuilt.seen_source_ids.push(record.source_message_id);
+      // Alias `${userId}:interrupted` so a later original id is already seen.
+      const legacySuffix = ":interrupted";
+      if (uuid.endsWith(legacySuffix)) {
+        const base = uuid.slice(0, -legacySuffix.length);
+        if (base) rebuilt.seen_source_ids.push(base);
+      }
+    } else if (record.type === "assistant" && rebuilt.pending) {
+      if (record.source_message_id) rebuilt.seen_source_ids.push(record.source_message_id);
+      rebuilt.pending = null;
+    }
+  }
+  return rebuilt;
+}
+function readEventState(statePath, journalPath, sessionId, eventDir) {
+  let persisted = null;
+  try {
+    const value = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    if (value && value.schema_version === 1 && value.session_id === sessionId) {
+      persisted = value;
+    }
+  } catch { /* fresh or corrupt rebuildable sidecar */ }
+  const rebuilt = rebuildEventState(journalPath, sessionId);
+  // MEKO-635: prefer the persisted pending's first_observed_at_ms over the
+  // rebuild value from record.meko.observed_at_ms. Fall back to rebuild when
+  // the sidecar is missing or names a different pending user.
+  let pending = rebuilt.pending;
+  const persistedPending = persisted && persisted.pending;
+  if (
+    pending &&
+    persistedPending &&
+    persistedPending.user_uuid === pending.user_uuid
+  ) {
+    const persistedMs = persistedPending.first_observed_at_ms;
+    pending = {
+      ...pending,
+      first_observed_at_ms: Number.isFinite(persistedMs)
+        ? persistedMs
+        : pending.first_observed_at_ms,
+    };
+  }
+  return {
+    ...(persisted || emptyEventState(sessionId)),
+    turn_index: rebuilt.turn_index,
+    pending,
+    seen_source_ids: rebuilt.seen_source_ids,
+    tentative_observation:
+      pending &&
+      persisted &&
+      persisted.pending &&
+      persisted.pending.user_uuid === pending.user_uuid
+        ? persisted.tentative_observation || null
+        : null,
+  };
+}
+module.exports = {
+  LOCK_RETRIES,
+  LOCK_RETRY_MS,
+  ensureEventDir,
+  acquireEventLock,
+  releaseEventLock,
+  atomicWriteJson,
+  appendJournal,
+  journalEmpty,
+  emptyEventState,
+  rebuildEventState,
+  readEventState,
+};

package/assets/hooks-handlers/lib/kiro-handler.js

@@ -535,20 +535,42 @@ function journalEvent(event) {
 }
 
 function ensureCaptureIntent(event, journalPath) {
-  const agentId = deriveAgentId({
+  const envOverride = (process.env.MEKO_AGENT_ID || "").trim();
+  const derivedAgentId = deriveAgentId({
     client: "kiro",
     cwd: event.cwd,
-    envOverride: process.env.MEKO_AGENT_ID,
+    envOverride,
   });
+  const existing = captureState.readState(event.sessionId);
+  const existingAgentId = existing.ok && existing.state
+    ? String(existing.state.agent_id || "").trim()
+    : "";
+  const existingSource = existing.ok && existing.state
+    ? String(existing.state.agent_id_source || "").trim()
+    : "";
+
+  // Existing Kiro sessions keep their persisted owner. Changing it in place
+  // would orphan an already-created conversation and reset the capture intent.
+  // A live explicit override still wins, and stale pre-MEKO-385 client ids are
+  // allowed to upgrade to Kiro.
+  const preserveExisting = !envOverride && existingAgentId && (
+    existingSource === "explicit"
+    || existingAgentId === "kiro"
+    || existingAgentId.startsWith("kiro:")
+  );
+  const agentId = preserveExisting ? existingAgentId : derivedAgentId;
+  const agentIdSource = preserveExisting
+    ? (existingSource || "derived")
+    : (envOverride ? "explicit" : "derived");
   const intent = captureState.writeSessionIntent(event.sessionId, {
     client: "kiro",
     agent_id: agentId,
-    agent_id_source: (process.env.MEKO_AGENT_ID || "").trim() ? "explicit" : "derived",
+    agent_id_source: agentIdSource,
     transcript_path: journalPath,
     datapack_id: process.env.MEKO_DATAPACK_ID || null,
     datapack_name: process.env.MEKO_DATAPACK_NAME || null,
   });
-  return { ...intent, agentId };
+  return { ...intent, agentId, derivedAgentId };
 }
 
 function launchCapture(mode, payload) {