@dmsdc-ai/aigentry-telepty 0.3.3 → 0.4.0

package/daemon.js

@@ -15,6 +15,7 @@ const { UnixSocketNotifier } = require('./src/mailbox/notifier');
 const { SessionStateManager, STATE_DISPLAY, stripAnsi: stripAnsiState } = require('./session-state');
 const { classifyReportPrompt, buildAutoSummary } = require('./src/report-enforcement');
 const submitGate = require('./src/submit-gate');
+const readyRegistry = require('./src/prompt-symbol-registry');
 
 const config = getConfig();
 const EXPECTED_TOKEN = config.authToken;
@@ -26,6 +27,8 @@ const SESSION_STALE_SECONDS = Math.max(1, Number(process.env.TELEPTY_SESSION_STA
 const SESSION_CLEANUP_SECONDS = Math.max(SESSION_STALE_SECONDS, Number(process.env.TELEPTY_SESSION_CLEANUP_SECONDS || 300));
 const DELIVERY_TIMEOUT_MS = Math.max(100, Number(process.env.TELEPTY_DELIVERY_TIMEOUT_MS || 5000));
 const HEALTH_POLL_MS = Math.max(100, Number(process.env.TELEPTY_HEALTH_POLL_MS || 10000));
+const BOOTSTRAP_READY_TIMEOUT_MS = Math.max(500, Number(process.env.TELEPTY_BOOTSTRAP_READY_TIMEOUT_MS || 30000));
+const WRAPPED_SUBMIT_DELAY_MS = 500;
 
 // Session state machine manager — auto-detects session state from PTY output
 const sessionStateManager = new SessionStateManager({
@@ -354,6 +357,292 @@ function getSessionHealthReason(session, healthStatus) {
   return session.ptyProcess && !session.ptyProcess.killed ? 'PTY_RUNNING' : 'PTY_EXITED';
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isBootstrapGatedSession(session) {
+  return !!(session && session.type === 'wrapped' && readyRegistry.isKnownAiCli(session.command));
+}
+
+function initializeBootstrapState(session) {
+  if (!session) return session;
+  if (!Array.isArray(session.bootstrapQueue)) {
+    session.bootstrapQueue = [];
+  }
+  session.bootstrapDraining = session.bootstrapDraining === true;
+  session.bootstrapDrainPromise = session.bootstrapDrainPromise || null;
+  session.bootstrapPromptPoll = session.bootstrapPromptPoll || null;
+
+  if (isBootstrapGatedSession(session)) {
+    session.bootstrapReady = session.bootstrapReady === true;
+    session.bootstrapReadyAt = session.bootstrapReadyAt || null;
+    session.bootstrapReadyReason = session.bootstrapReadyReason || null;
+    session.ready = session.bootstrapReady === true;
+  } else {
+    session.bootstrapReady = true;
+    session.bootstrapReadyAt = session.bootstrapReadyAt || new Date().toISOString();
+    session.bootstrapReadyReason = session.bootstrapReadyReason || 'generic_command_compat';
+    session.ready = true;
+  }
+  return session;
+}
+
+function isBootstrapReady(session) {
+  return !isBootstrapGatedSession(session) || session.bootstrapReady === true;
+}
+
+function buildBootstrapBlock(session) {
+  return {
+    gated: isBootstrapGatedSession(session),
+    ready: isBootstrapReady(session),
+    ready_at: session.bootstrapReadyAt || null,
+    reason: session.bootstrapReadyReason || null,
+    queued: Array.isArray(session.bootstrapQueue) ? session.bootstrapQueue.length : 0,
+    draining: session.bootstrapDraining === true
+  };
+}
+
+function shouldQueueBootstrapOperation(session) {
+  return isBootstrapGatedSession(session) && !isBootstrapReady(session);
+}
+
+function hasBootstrapBacklog(session) {
+  return !!(session && Array.isArray(session.bootstrapQueue) && session.bootstrapQueue.length > 0);
+}
+
+function emitBootstrapEvent(eventType, sessionId, session, extra = {}) {
+  broadcastSessionEvent(eventType, sessionId, session, {
+    extra: {
+      bootstrap: buildBootstrapBlock(session),
+      ...extra
+    }
+  });
+}
+
+function enqueueBootstrapOperation(sessionId, session, operation) {
+  initializeBootstrapState(session);
+  const op = {
+    op_id: crypto.randomUUID(),
+    queued_at: new Date().toISOString(),
+    ...operation
+  };
+
+  if (op.type === 'submit') {
+    op.promise = new Promise((resolve) => {
+      op.resolve = resolve;
+    });
+  }
+
+  session.bootstrapQueue.push(op);
+  emitBootstrapEvent('bootstrap_queue_queued', sessionId, session, {
+    op_id: op.op_id,
+    operation: op.type,
+    depth: session.bootstrapQueue.length
+  });
+  scheduleBootstrapPromptPoll(sessionId, session);
+  return op;
+}
+
+function resolveBootstrapSubmit(op, result) {
+  if (op && typeof op.resolve === 'function') {
+    op.resolve(result);
+    op.resolve = null;
+  }
+}
+
+function bootstrapQueuedResponse(op, extra = {}) {
+  return {
+    success: true,
+    strategy: 'bootstrap_queue',
+    queued: true,
+    bootstrap_queued: true,
+    bootstrap_op_id: op.op_id,
+    ...extra
+  };
+}
+
+async function executeBootstrapInject(sessionId, session, op) {
+  const prompt = typeof op.prompt === 'string' ? op.prompt : '';
+  const textResult = await writeDataToSession(sessionId, session, prompt);
+  if (!textResult.success) return textResult;
+
+  if (!op.noEnter) {
+    await sleep(WRAPPED_SUBMIT_DELAY_MS);
+    const submitResult = await writeDataToSession(sessionId, session, '\r');
+    if (!submitResult.success) return submitResult;
+  }
+
+  session.lastActivityAt = new Date().toISOString();
+  return {
+    success: true,
+    strategy: 'bootstrap_direct',
+    submit: op.noEnter ? 'skipped' : 'sent'
+  };
+}
+
+async function executeBootstrapSubmit(sessionId, session, op) {
+  const strategy = terminalLevelSubmit(sessionId, session);
+  if (!strategy) {
+    return {
+      status: 503,
+      body: {
+        error: 'Submit failed via all strategies (kitty/cmux/pty)',
+        strategy: 'none',
+        attempts: 0,
+        gated: false,
+        bootstrap_queued: true
+      }
+    };
+  }
+  return {
+    status: 200,
+    body: {
+      success: true,
+      strategy,
+      attempts: 1,
+      gated: false,
+      verify: null,
+      bootstrap_queued: true
+    }
+  };
+}
+
+async function drainBootstrapQueue(sessionId, session) {
+  if (!session || session.bootstrapDraining) {
+    return session ? session.bootstrapDrainPromise : null;
+  }
+  if (!isBootstrapReady(session)) {
+    return null;
+  }
+
+  session.bootstrapDraining = true;
+  session.bootstrapDrainPromise = (async () => {
+    while (hasBootstrapBacklog(session)) {
+      const op = session.bootstrapQueue.shift();
+      try {
+        if (op.cancelled) {
+          continue;
+        }
+        if (op.type === 'inject') {
+          const result = await executeBootstrapInject(sessionId, session, op);
+          if (!result.success) {
+            emitBootstrapEvent('bootstrap_queue_failed', sessionId, session, {
+              op_id: op.op_id,
+              operation: op.type,
+              code: result.code || 'DELIVERY_FAILED',
+              error: result.error || 'bootstrap delivery failed'
+            });
+          }
+        } else if (op.type === 'submit') {
+          const result = await executeBootstrapSubmit(sessionId, session, op);
+          resolveBootstrapSubmit(op, result);
+          if (result.status >= 400) {
+            emitBootstrapEvent('bootstrap_queue_failed', sessionId, session, {
+              op_id: op.op_id,
+              operation: op.type,
+              code: result.body.code || 'SUBMIT_FAILED',
+              error: result.body.error || 'bootstrap submit failed'
+            });
+          }
+        }
+      } catch (error) {
+        if (op.type === 'submit') {
+          resolveBootstrapSubmit(op, {
+            status: 500,
+            body: {
+              error: error.message || 'bootstrap submit failed',
+              strategy: 'none',
+              attempts: 0,
+              gated: false,
+              bootstrap_queued: true
+            }
+          });
+        }
+        emitBootstrapEvent('bootstrap_queue_failed', sessionId, session, {
+          op_id: op.op_id,
+          operation: op.type,
+          code: 'BOOTSTRAP_DRAIN_FAILED',
+          error: error.message || 'bootstrap drain failed'
+        });
+      }
+    }
+
+    emitBootstrapEvent('bootstrap_queue_drained', sessionId, session);
+  })().finally(() => {
+    session.bootstrapDraining = false;
+    session.bootstrapDrainPromise = null;
+  });
+
+  return session.bootstrapDrainPromise;
+}
+
+function markBootstrapReady(sessionId, session, reason) {
+  if (!session) return false;
+  initializeBootstrapState(session);
+  if (!isBootstrapGatedSession(session)) {
+    return false;
+  }
+  if (session.bootstrapReady === true) {
+    return false;
+  }
+
+  session.bootstrapReady = true;
+  session.bootstrapReadyAt = new Date().toISOString();
+  session.bootstrapReadyReason = reason || 'ready';
+  session.ready = true;
+  emitBootstrapEvent('bootstrap_ready', sessionId, session, { reason: session.bootstrapReadyReason });
+  drainBootstrapQueue(sessionId, session);
+  return true;
+}
+
+function scheduleBootstrapPromptPoll(sessionId, session) {
+  if (!session || !isBootstrapGatedSession(session) || isBootstrapReady(session)) return;
+  if (session.bootstrapPromptPoll || session.backend !== 'cmux' || !session.cmuxWorkspaceId) return;
+  if (!isOpenWebSocket(session.ownerWs)) return;
+
+  session.bootstrapPromptPoll = submitGate.awaitPromptSymbol(session, {
+    timeoutMs: BOOTSTRAP_READY_TIMEOUT_MS
+  }).then((result) => {
+    session.bootstrapPromptPoll = null;
+    if (result && result.ready && isOpenWebSocket(session.ownerWs)) {
+      markBootstrapReady(sessionId, session, 'cmux_prompt_symbol');
+    } else if (result && result.reason) {
+      emitBootstrapEvent('bootstrap_ready_timeout', sessionId, session, {
+        reason: result.reason,
+        waited_ms: result.waited_ms || 0
+      });
+    }
+  }).catch((error) => {
+    session.bootstrapPromptPoll = null;
+    emitBootstrapEvent('bootstrap_ready_timeout', sessionId, session, {
+      reason: 'prompt_symbol_error',
+      error: error.message || String(error)
+    });
+  });
+}
+
+async function waitForBootstrapSubmit(op, session, timeoutMs) {
+  const timeout = sleep(timeoutMs).then(() => {
+    op.cancelled = true;
+    return {
+      status: 504,
+      body: {
+        error: 'Submit bootstrap-timeout — target CLI did not become ready',
+        reason: 'bootstrap_not_ready',
+        last_state: sessionStateManager.getState(session.id)?.state || null,
+        strategy: 'none',
+        attempts: 0,
+        gated: true,
+        bootstrap_queued: true,
+        bootstrap_op_id: op.op_id,
+        bootstrap: buildBootstrapBlock(session)
+      }
+    };
+  });
+  return Promise.race([op.promise, timeout]);
+}
+
 function buildSessionTransportBlock(session, options = {}) {
   if (!session) {
     return null;
@@ -380,7 +669,8 @@ function buildSessionTransportBlock(session, options = {}) {
     last_disconnected_at: session.lastDisconnectedAt || null,
     last_inject_from: session.lastInjectFrom || null,
     last_reply_to: session.lastInjectReplyTo || null,
-    last_thread_id: session.lastThreadId || null
+    last_thread_id: session.lastThreadId || null,
+    bootstrap: buildBootstrapBlock(session)
   };
 }
 
@@ -645,6 +935,28 @@ function terminalLevelSubmit(id, session) {
 
 async function deliverInjectionToSession(id, session, prompt, options = {}) {
   const now = Date.now();
+  if (!options.bypassBootstrapQueue && shouldQueueBootstrapOperation(session)) {
+    const healthStatus = getSessionHealthStatus(session, { nowMs: now });
+    if (healthStatus === 'STALE') {
+      return { success: false, httpStatus: 410, code: 'STALE', error: 'Session is stale and awaiting cleanup.' };
+    }
+    const op = enqueueBootstrapOperation(id, session, {
+      type: 'inject',
+      prompt,
+      noEnter: !!options.noEnter,
+      options: {
+        source: options.source || 'inject',
+        from: options.from || 'daemon'
+      }
+    });
+    session.lastActivityAt = new Date(now).toISOString();
+    return bootstrapQueuedResponse(op, {
+      msg_id: op.op_id,
+      pending: session.bootstrapQueue.length,
+      submit: options.noEnter ? 'skipped' : 'queued'
+    });
+  }
+
   const injectFailure = getInjectFailure(session, { nowMs: now });
   if (injectFailure) {
     return { success: false, ...injectFailure };
@@ -834,6 +1146,7 @@ for (const [id, meta] of Object.entries(_persisted)) {
       lastStateReportAt: meta.lastStateReportAt || null,
       stateReport: meta.stateReport || null,
       clients: new Set(), isClosing: false, outputRing: [], ready: true,     };
+    initializeBootstrapState(sessions[id]);
     console.log(`[PERSIST] Restored session ${id} (awaiting reconnect)`);
   }
 }
@@ -1020,6 +1333,7 @@ app.post('/api/sessions/register', (req, res) => {
       existing.ready = true;
       markSessionConnected(existing);
     }
+    initializeBootstrapState(existing);
     console.log(`[REGISTER] Re-registered session ${session_id} (type: ${existing.type}, updated metadata)`);
     return res.status(200).json({ session_id, type: existing.type, command: existing.command, cwd: existing.cwd, reregistered: true });
   }
@@ -1049,8 +1363,9 @@ app.post('/api/sessions/register', (req, res) => {
     clients: new Set(),
     isClosing: false,
     outputRing: [],
-    ready: true,  // all sessions are injectable once registered (#150)
-      };
+    ready: true,  // unknown commands remain injectable once registered (#150)
+  };
+  initializeBootstrapState(sessionRecord);
   // Check for existing session with same base alias and emit replaced event
   const baseAlias = session_id.replace(/-\d+$/, '');
   const replaced = Object.keys(sessions).find(id => {
@@ -1521,6 +1836,18 @@ app.post('/api/sessions/:id/submit', async (req, res) => {
 
   console.log(`[SUBMIT] Session ${id} (${session.command})${retries > 0 ? `, retries: ${retries}, pre_delay: ${preDelayMs}ms` : ''}${gateOff ? ' [gate=off]' : ''}`);
 
+  if (isBootstrapGatedSession(session) && (!isBootstrapReady(session) || hasBootstrapBacklog(session) || session.bootstrapDraining)) {
+    const op = enqueueBootstrapOperation(id, session, {
+      type: 'submit',
+      body: { ...(req.body || {}) }
+    });
+    if (isBootstrapReady(session)) {
+      drainBootstrapQueue(id, session);
+    }
+    const queuedSubmit = await waitForBootstrapSubmit(op, session, gateTimeoutMs);
+    return res.status(queuedSubmit.status).json(queuedSubmit.body);
+  }
+
   function emitSubmitBus(payload) {
     const busMsg = JSON.stringify({
       type: 'submit',
@@ -1805,6 +2132,12 @@ app.post('/api/sessions/:id/inject', async (req, res) => {
             delete pendingReports[senderAlias];
             const elapsedSecs = Number(((Date.now() - new Date(senderPending.injectedAt).getTime()) / 1000).toFixed(1));
             const senderSession = sessions[senderAlias];
+            sessionStateManager.markIdle(senderAlias, 1.0, {
+              trigger: 'report_inject',
+              report_inject_id: inject_id,
+              report_status: classification,
+              source: senderPending.source
+            });
             const eventType =
               classification === 'report_blocked' ? 'TASK_BLOCKED_WITH_REASON' :
               classification === 'report_dismissed' ? 'TASK_DISMISSED' :
@@ -1881,7 +2214,17 @@ app.post('/api/sessions/:id/inject', async (req, res) => {
       });
     }
 
-    res.json({ success: true, inject_id, strategy: delivery.strategy, submit: delivery.submit });
+    res.json({
+      success: true,
+      inject_id,
+      strategy: delivery.strategy,
+      submit: delivery.submit,
+      ...(delivery.bootstrap_queued ? {
+        bootstrap_queued: true,
+        bootstrap_op_id: delivery.bootstrap_op_id || delivery.msg_id,
+        pending: delivery.pending
+      } : {})
+    });
   } catch (err) {
     emitInjectFailureEvent(id, 'DELIVERY_FAILED', err.message, { inject_id }, session);
     res.status(500).json(buildErrorBody('DELIVERY_FAILED', err.message));
@@ -2607,6 +2950,7 @@ wss.on('connection', (ws, req) => {
       outputRing: [],
       ready: true,
           };
+    initializeBootstrapState(autoSession);
     sessions[sessionId] = autoSession;
     console.log(`[WS] Auto-registered wrapped session ${sessionId} on reconnect`);
     // Set tab title via kitty (no \x0c redraw — it causes flickering on multi-session reconnect)
@@ -2639,7 +2983,9 @@ wss.on('connection', (ws, req) => {
     }
     activeSession.ownerWs = ws;
     markSessionConnected(activeSession);
+    initializeBootstrapState(activeSession);
     console.log(`[WS] Wrap owner ${isOwnerConnect && activeSession.clients.size > 1 ? 're-' : ''}connected for session ${sessionId} (Total: ${activeSession.clients.size})`);
+    scheduleBootstrapPromptPoll(sessionId, activeSession);
     if (hadDisconnectedOwner) {
       emitSessionLifecycleEvent('session_reconnect', sessionId, activeSession);
     }
@@ -2665,7 +3011,11 @@ wss.on('connection', (ws, req) => {
               }
             });
           } else if (type === 'ready') {
-            activeSession.ready = true;
+            if (isBootstrapGatedSession(activeSession)) {
+              markBootstrapReady(sessionId, activeSession, 'bridge_ready');
+            } else {
+              activeSession.ready = true;
+            }
             activeSession.lastActivityAt = new Date().toISOString();
             console.log(`[READY] Session ${sessionId} CLI is ready for inject`);
             // Broadcast readiness to bus (cmux/kitty paths now enabled for this session)

package/host-spec.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const DEFAULT_PORT = 3848;
+
+function parseHostSpec(value, defaultPort = DEFAULT_PORT) {
+  if (value === undefined || value === null || value === '') {
+    return { host: '127.0.0.1', port: defaultPort };
+  }
+
+  let raw = String(value).trim();
+  if (!raw) {
+    return { host: '127.0.0.1', port: defaultPort };
+  }
+
+  raw = raw.replace(/^https?:\/\//i, '');
+  raw = raw.replace(/\/.*$/, '');
+
+  const ipv6Bracketed = raw.match(/^\[([^\]]+)\](?::(\d+))?$/);
+  if (ipv6Bracketed) {
+    const port = ipv6Bracketed[2] ? Number(ipv6Bracketed[2]) : defaultPort;
+    return { host: ipv6Bracketed[1], port };
+  }
+
+  const colonCount = (raw.match(/:/g) || []).length;
+  if (colonCount > 1) {
+    return { host: raw, port: defaultPort };
+  }
+
+  const hostPort = raw.match(/^(.+):(\d+)$/);
+  if (hostPort) {
+    return { host: hostPort[1], port: Number(hostPort[2]) };
+  }
+
+  return { host: raw, port: defaultPort };
+}
+
+function formatHostForUrl(host) {
+  if (host && host.includes(':') && !host.startsWith('[')) {
+    return `[${host}]`;
+  }
+  return host;
+}
+
+function buildDaemonUrl(value, defaultPort = DEFAULT_PORT) {
+  const { host, port } = parseHostSpec(value, defaultPort);
+  return `http://${formatHostForUrl(host)}:${port}`;
+}
+
+function buildDaemonWsUrl(value, defaultPort = DEFAULT_PORT) {
+  const { host, port } = parseHostSpec(value, defaultPort);
+  return `ws://${formatHostForUrl(host)}:${port}`;
+}
+
+module.exports = {
+  DEFAULT_PORT,
+  parseHostSpec,
+  formatHostForUrl,
+  buildDaemonUrl,
+  buildDaemonWsUrl
+};

package/mcp-server/index.mjs

@@ -34,9 +34,30 @@ function getAuthToken() {
 }
 
 function getDaemonUrl() {
-  const port = process.env.TELEPTY_PORT || "3848";
-  const host = process.env.TELEPTY_HOST || "127.0.0.1";
-  return `http://${host}:${port}`;
+  // TELEPTY_HOST accepts: `host`, `host:port`, or `http://host:port`. Embedded
+  // port from TELEPTY_HOST is used unless TELEPTY_PORT is set explicitly.
+  const explicitPort = process.env.TELEPTY_PORT ? Number(process.env.TELEPTY_PORT) : null;
+  const raw = process.env.TELEPTY_HOST || "127.0.0.1";
+  let stripped = String(raw).trim().replace(/^https?:\/\//i, "").replace(/\/.*$/, "");
+  let host = stripped;
+  let embeddedPort = null;
+  const ipv6Bracketed = stripped.match(/^\[([^\]]+)\](?::(\d+))?$/);
+  if (ipv6Bracketed) {
+    host = ipv6Bracketed[1];
+    if (ipv6Bracketed[2]) embeddedPort = Number(ipv6Bracketed[2]);
+  } else {
+    const colonCount = (stripped.match(/:/g) || []).length;
+    if (colonCount === 1) {
+      const m = stripped.match(/^(.+):(\d+)$/);
+      if (m) {
+        host = m[1];
+        embeddedPort = Number(m[2]);
+      }
+    }
+  }
+  const port = explicitPort != null ? explicitPort : (embeddedPort != null ? embeddedPort : 3848);
+  const hostForUrl = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `http://${hostForUrl}:${port}`;
 }
 
 async function daemonFetch(endpoint, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "main": "daemon.js",
   "bin": {
     "aigentry-telepty": "install.js",
@@ -8,10 +8,35 @@
     "telepty-install": "install.js",
     "telepty-mcp": "mcp-server/index.mjs"
   },
+  "files": [
+    "cli.js",
+    "daemon.js",
+    "install.js",
+    "auth.js",
+    "cross-machine.js",
+    "daemon-control.js",
+    "entitlement.js",
+    "host-spec.js",
+    "interactive-terminal.js",
+    "runtime-info.js",
+    "session-routing.js",
+    "session-state.js",
+    "shared-context.js",
+    "skill-installer.js",
+    "terminal-backend.js",
+    "tui.js",
+    "install.sh",
+    "install.ps1",
+    "mcp-server/",
+    "src/",
+    "skills/",
+    "CHANGELOG.md"
+  ],
   "scripts": {
-    "test": "node --test test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js test/report-enforcement.test.js test/enforce-report.test.js test/submit-gate.test.js test/prompt-symbol-registry.test.js test/inject-submit-flags.test.js",
-    "test:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js test/report-enforcement.test.js test/enforce-report.test.js test/submit-gate.test.js test/prompt-symbol-registry.test.js test/inject-submit-flags.test.js",
-    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js test/report-enforcement.test.js test/enforce-report.test.js test/submit-gate.test.js test/prompt-symbol-registry.test.js test/inject-submit-flags.test.js"
+    "test": "node --test test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js test/report-enforcement.test.js test/enforce-report.test.js test/submit-gate.test.js test/prompt-symbol-registry.test.js test/inject-submit-flags.test.js test/host-spec.test.js test/cross-host-inject.test.js test/init.test.js && git diff --exit-code tests/snippet-protocol/v1/",
+    "test:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js test/report-enforcement.test.js test/enforce-report.test.js test/submit-gate.test.js test/prompt-symbol-registry.test.js test/inject-submit-flags.test.js test/host-spec.test.js test/cross-host-inject.test.js test/init.test.js",
+    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js test/report-enforcement.test.js test/enforce-report.test.js test/submit-gate.test.js test/prompt-symbol-registry.test.js test/inject-submit-flags.test.js test/host-spec.test.js test/cross-host-inject.test.js test/init.test.js && git diff --exit-code tests/snippet-protocol/v1/",
+    "regen-fixtures": "node scripts/regen-snippet-fixtures.js"
   },
   "keywords": [
     "pty",
@@ -48,7 +73,7 @@
     "node-pty": "^1.2.0-beta.11",
     "prompts": "^2.4.2",
     "update-notifier": "^5.1.0",
-    "uuid": "^13.0.0",
+    "uuid": "^9.0.0",
     "ws": "^8.19.0",
     "zod": "^3.24.0"
   }

package/session-state.js

@@ -203,6 +203,9 @@ class SessionStateMachine {
 
     // Strip ANSI and split into lines for pattern analysis
     const cleaned = stripAnsi(data);
+    if (cleaned.trim().length === 0) {
+      return;
+    }
     const lines = cleaned.split(/\r?\n/).filter(l => l.trim().length > 0);
 
     for (const line of lines) {
@@ -269,6 +272,16 @@ class SessionStateMachine {
     this._transition(STATES.RESTARTING, 1.0, { trigger: 'lifecycle' });
   }
 
+  markIdle(confidence = 1.0, detail = {}) {
+    if (this._state === STATES.DEAD || this._state === STATES.RESTARTING) {
+      return;
+    }
+    this._transition(STATES.IDLE, confidence, {
+      trigger: 'manual_idle',
+      ...detail,
+    });
+  }
+
   // --- Internal ---
 
   _transition(newState, confidence, detail) {
@@ -538,6 +551,16 @@ class SessionStateManager {
     if (sm) sm.markRestarting();
   }
 
+  /**
+   * Mark a session as idle from a semantic daemon event.
+   */
+  markIdle(sessionId, confidence = 1.0, detail = {}) {
+    const sm = this._machines.get(sessionId);
+    if (!sm) return false;
+    sm.markIdle(confidence, detail);
+    return true;
+  }
+
   /**
    * Unregister and cleanup a session's state machine.
    */