@dmsdc-ai/aigentry-telepty 0.1.50 → 0.1.52

package/BUS_EVENT_SCHEMA.md

@@ -0,0 +1,171 @@
+# Telepty Bus Event Schema Standard
+
+Version: 1.0 (2026-03-15)
+Agreed by: telepty, deliberation, devkit, brain, orchestrator
+
+## Transport
+
+- **HTTP**: `POST /api/bus/publish` with JSON body
+- **WebSocket**: `ws://HOST:3848/api/bus` send JSON message
+- Both paths trigger bus auto-router for routable events
+
+## Envelope Structure (All Events)
+
+```json
+{
+  "message_id": "string (UUID or prefixed ID)",
+  "kind": "string (event type)",
+  "source": "string (sender identifier)",
+  "target": "string | null (target session ID, optional @host suffix)",
+  "ts": "ISO 8601 timestamp"
+}
+```
+
+### Canonical Field Names
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `kind` | string | Event type (NOT `type` — `kind` is canonical) |
+| `target` | string | Target telepty session ID. May include `@host` suffix for remote |
+| `source` | string | Sender identifier (format: `project:session_id`) |
+| `message_id` | string | Unique message identifier |
+| `ts` | string | ISO 8601 timestamp |
+
+## Routable Events (Auto-Router)
+
+### `turn_request`
+
+Published by deliberation to request a turn from a session. Telepty daemon auto-routes to target session PTY.
+
+```json
+{
+  "message_id": "turn_request-<uuid>",
+  "session_id": "<deliberation_session_id>",
+  "project": "<project_name>",
+  "kind": "turn_request",
+  "source": "deliberation:<deliberation_session_id>",
+  "target": "<telepty_session_id>[@<host>]",
+  "reply_to": "<deliberation_session_id>",
+  "trace": ["project:<name>", "speaker:<id>", "turn:<turn_id>"],
+  "payload": {
+    "turn_id": "string",
+    "round": "number",
+    "max_rounds": "number",
+    "speaker": "string (target telepty session ID)",
+    "role": "string | null",
+    "prompt": "string (full prompt text — inject as-is to PTY)",
+    "prompt_sha1": "string (40-char SHA1)",
+    "history_entries": "number",
+    "transport_timeout_ms": "number",
+    "semantic_timeout_ms": "number"
+  },
+  "ts": "ISO 8601"
+}
+```
+
+**Important Notes:**
+- `session_id` is the DELIBERATION session ID, NOT the target telepty session
+- `target` is the telepty session ID to inject into
+- `payload.prompt` is the full text to write to PTY (no further processing needed)
+- `@host` suffix on target: strip before resolving, use for remote routing
+
+**Auto-Router Behavior:**
+1. Daemon receives turn_request via HTTP POST or WS
+2. Extracts `target` field, strips `@host` suffix
+3. Resolves session via `resolveSessionAlias()`
+4. Delivers `payload.prompt` to session PTY (kitty primary, WS fallback)
+5. Emits `inject_written` ack on bus
+
+### `inject_written` (ACK)
+
+Emitted by telepty after successful auto-route delivery.
+
+```json
+{
+  "type": "inject_written",
+  "inject_id": "UUID",
+  "sender": "daemon",
+  "target_agent": "<session_id>",
+  "source_type": "bus_auto_route",
+  "delivered": true,
+  "timestamp": "ISO 8601"
+}
+```
+
+## Session Lifecycle Events
+
+### `session_register`
+```json
+{ "type": "session_register", "sender": "daemon", "session_id": "string", "command": "string", "cwd": "string", "timestamp": "ISO 8601" }
+```
+
+### `session.replaced`
+```json
+{ "type": "session.replaced", "sender": "daemon", "old_id": "string", "new_id": "string", "alias": "string", "timestamp": "ISO 8601" }
+```
+
+### `session.idle`
+```json
+{ "type": "session.idle", "session_id": "string", "idleSeconds": "number", "lastActivityAt": "ISO 8601", "timestamp": "ISO 8601" }
+```
+
+### `session_health` (periodic, every 10s)
+```json
+{ "type": "session_health", "session_id": "string", "payload": { "alive": true, "pid": "number|null", "type": "string", "clients": "number", "idleSeconds": "number|null" }, "timestamp": "ISO 8601" }
+```
+
+## Inject Events
+
+### `inject_written`
+```json
+{ "type": "inject_written", "inject_id": "UUID", "sender": "daemon", "target_agent": "string", "content": "string", "from": "string|null", "reply_to": "string|null", "thread_id": "string|null", "reply_expected": "boolean", "timestamp": "ISO 8601" }
+```
+
+### `message_routed`
+```json
+{ "type": "message_routed", "message_id": "UUID", "from": "string", "to": "string", "reply_to": "string", "inject_id": "UUID", "deliberation_session_id": "string|null", "thread_id": "string|null", "timestamp": "ISO 8601" }
+```
+
+## Handoff Events
+
+### `handoff.created` / `handoff.claimed` / `handoff.executing` / `handoff.completed`
+```json
+{ "type": "handoff.<status>", "handoff_id": "UUID", "source_session_id": "string|null", "deliberation_id": "string|null", "auto_execute": "boolean", "task_count": "number", "timestamp": "ISO 8601" }
+```
+
+## Thread Events
+
+### `thread.opened`
+```json
+{ "type": "thread.opened", "thread_id": "UUID", "topic": "string", "orchestrator_session_id": "string|null", "participant_session_ids": ["string"], "timestamp": "ISO 8601" }
+```
+
+### `thread.closed`
+```json
+{ "type": "thread.closed", "thread_id": "UUID", "topic": "string", "message_count": "number", "timestamp": "ISO 8601" }
+```
+
+## Termination Signal Detection
+
+Messages containing these strings suppress auto-reply guide footer:
+- `no further reply needed`
+- `thread closed` / `closed on X side`
+- `ack received` / `ack-only`
+- `회신 불필요` / `스레드 종료`
+
+## Inject API Reference
+
+### `POST /api/sessions/:id/inject`
+
+```json
+{
+  "prompt": "string (REQUIRED — canonical body field)",
+  "from": "string (sender session ID)",
+  "reply_to": "string (defaults to from if omitted)",
+  "thread_id": "string (optional)",
+  "reply_expected": "boolean (optional)",
+  "no_enter": "boolean (skip Enter after inject)"
+}
+```
+
+**Note:** The canonical body field is `prompt`, NOT `text`, `content`, or `message`.

package/daemon.js

@@ -10,6 +10,26 @@ const { claimDaemonState, clearDaemonState } = require('./daemon-control');
 
 const config = getConfig();
 const EXPECTED_TOKEN = config.authToken;
+const fs = require('fs');
+const SESSION_PERSIST_PATH = require('path').join(os.homedir(), '.config', 'aigentry-telepty', 'sessions.json');
+
+function persistSessions() {
+  try {
+    const data = {};
+    for (const [id, s] of Object.entries(sessions)) {
+      data[id] = { id, type: s.type, command: s.command, cwd: s.cwd, createdAt: s.createdAt, lastActivityAt: s.lastActivityAt || null };
+    }
+    fs.mkdirSync(require('path').dirname(SESSION_PERSIST_PATH), { recursive: true });
+    fs.writeFileSync(SESSION_PERSIST_PATH, JSON.stringify(data, null, 2));
+  } catch {}
+}
+
+function loadPersistedSessions() {
+  try {
+    if (!fs.existsSync(SESSION_PERSIST_PATH)) return {};
+    return JSON.parse(fs.readFileSync(SESSION_PERSIST_PATH, 'utf8'));
+  } catch { return {}; }
+}
 
 const app = express();
 app.use(cors());
@@ -48,6 +68,21 @@ if (!daemonClaim.claimed) {
 const sessions = {};
 const handoffs = {};
 const threads = {};
+
+// Restore persisted session metadata (wrapped sessions await reconnect)
+const _persisted = loadPersistedSessions();
+for (const [id, meta] of Object.entries(_persisted)) {
+  if (meta.type === 'wrapped') {
+    sessions[id] = {
+      id, type: 'wrapped', ptyProcess: null, ownerWs: null,
+      command: meta.command || 'wrapped', cwd: meta.cwd || process.cwd(),
+      createdAt: meta.createdAt || new Date().toISOString(),
+      lastActivityAt: meta.lastActivityAt || new Date().toISOString(),
+      clients: new Set(), isClosing: false
+    };
+    console.log(`[PERSIST] Restored session ${id} (awaiting reconnect)`);
+  }
+}
 const STRIPPED_SESSION_ENV_KEYS = [
   'CLAUDECODE',
   'CODEX_CI',
@@ -185,6 +220,7 @@ app.post('/api/sessions/spawn', (req, res) => {
     });
 
     console.log(`[SPAWN] Created session ${session_id} (${command})`);
+    persistSessions();
     res.status(201).json({ session_id, command, cwd });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -250,6 +286,7 @@ app.post('/api/sessions/register', (req, res) => {
   });
 
   console.log(`[REGISTER] Registered wrapped session ${session_id}`);
+  persistSessions();
   res.status(201).json({ session_id, type: 'wrapped', command: sessionRecord.command, cwd });
 });
 
@@ -814,9 +851,11 @@ app.delete('/api/sessions/:id', (req, res) => {
       session.clients.forEach(ws => ws.close(1000, 'Session destroyed'));
       delete sessions[id];
       console.log(`[KILL] Wrapped session ${id} removed`);
+      persistSessions();
     } else {
       session.ptyProcess.kill();
       console.log(`[KILL] Session ${id} forcefully closed`);
+      persistSessions();
     }
     res.json({ success: true, status: 'closing' });
   } catch (err) {
@@ -824,15 +863,88 @@ app.delete('/api/sessions/:id', (req, res) => {
   }
 });
 
+// Shared auto-router: handles turn_request events from any source (WS or HTTP)
+function busAutoRoute(msg) {
+  const eventType = msg.type || msg.kind;
+  const isRoutable = (eventType === 'turn_request' || eventType === 'deliberation_route_turn') && (msg.target || msg.target_session_id);
+  if (!isRoutable) return;
+
+  const rawTarget = (msg.target || msg.target_session_id).split('@')[0];
+  console.log(`[BUS-ROUTE] Received ${eventType}: target=${rawTarget}`);
+  const targetId = resolveSessionAlias(rawTarget);
+  const targetSession = targetId ? sessions[targetId] : null;
+  if (!targetSession) {
+    console.log(`[BUS-ROUTE] Target ${rawTarget} not found`);
+    return;
+  }
+
+  const prompt = (msg.payload && msg.payload.prompt) || msg.content || msg.prompt || JSON.stringify(msg);
+  const inject_id = crypto.randomUUID();
+
+  // Write to session (kitty primary, WS fallback)
+  const sock = findKittySocket();
+  if (!targetSession.kittyWindowId && sock) targetSession.kittyWindowId = findKittyWindowId(sock, targetId);
+  const wid = targetSession.kittyWindowId;
+  let delivered = false;
+
+  if (wid && sock && targetSession.type === 'wrapped') {
+    try {
+      const escaped = prompt.replace(/\\/g, '\\\\').replace(/'/g, "'\\''");
+      require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} '${escaped}'`, {
+        timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
+      });
+      setTimeout(() => {
+        try {
+          require('child_process').execSync(`kitty @ --to unix:${sock} send-key --match id:${wid} Return`, {
+            timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+          });
+        } catch {}
+      }, 500);
+      delivered = true;
+    } catch {}
+  }
+  if (!delivered) {
+    if (targetSession.type === 'wrapped' && targetSession.ownerWs && targetSession.ownerWs.readyState === 1) {
+      targetSession.ownerWs.send(JSON.stringify({ type: 'inject', data: prompt }));
+      setTimeout(() => {
+        if (targetSession.ownerWs && targetSession.ownerWs.readyState === 1) {
+          targetSession.ownerWs.send(JSON.stringify({ type: 'inject', data: '\r' }));
+        }
+      }, 300);
+      delivered = true;
+    } else if (targetSession.ptyProcess) {
+      targetSession.ptyProcess.write(prompt);
+      setTimeout(() => targetSession.ptyProcess.write('\r'), 300);
+      delivered = true;
+    }
+  }
+
+  // Emit inject_written ack
+  const ackMsg = JSON.stringify({
+    type: 'inject_written',
+    inject_id,
+    sender: 'daemon',
+    target_agent: targetId,
+    source_type: 'bus_auto_route',
+    delivered,
+    timestamp: new Date().toISOString()
+  });
+  busClients.forEach(client => {
+    if (client.readyState === 1) client.send(ackMsg);
+  });
+  targetSession.lastActivityAt = new Date().toISOString();
+  console.log(`[BUS-ROUTE] ${eventType} → ${targetId}: ${delivered ? 'delivered' : 'failed'}`);
+}
+
 app.post('/api/bus/publish', (req, res) => {
   const payload = req.body;
-  
+
   if (!payload || typeof payload !== 'object') {
     return res.status(400).json({ error: 'Payload must be a JSON object' });
   }
 
   let deliveredCount = 0;
-  
+
   busClients.forEach(client => {
     if (client.readyState === 1) { // WebSocket.OPEN
       client.send(JSON.stringify(payload));
@@ -840,6 +952,9 @@ app.post('/api/bus/publish', (req, res) => {
     }
   });
 
+  // Auto-route if this is a turn_request
+  busAutoRoute(payload);
+
   res.json({ success: true, delivered: deliveredCount });
 });
 
@@ -1247,76 +1362,8 @@ busWss.on('connection', (ws, req) => {
         }
       });
 
-      // Auto-router: turn_request → inject to target session PTY
-      // Matches both msg.type and msg.kind (deliberation uses 'kind')
-      const eventType = msg.type || msg.kind;
-      const isRoutable = (eventType === 'turn_request' || eventType === 'deliberation_route_turn') && (msg.target || msg.target_session_id);
-      if (isRoutable) {
-        // Parse target: may include @host suffix (e.g. "session-001@100.x.y.z")
-        const rawTarget = (msg.target || msg.target_session_id).split('@')[0];
-        console.log(`[BUS-ROUTE] Received ${eventType}: target=${rawTarget}`);
-        const targetId = resolveSessionAlias(rawTarget);
-        const targetSession = targetId ? sessions[targetId] : null;
-        if (targetSession) {
-          // Extract prompt from payload.prompt (deliberation schema) or fallbacks
-          const prompt = (msg.payload && msg.payload.prompt) || msg.content || msg.prompt || JSON.stringify(msg);
-          const inject_id = crypto.randomUUID();
-
-          // Write to session (kitty primary, WS fallback)
-          const sock = findKittySocket();
-          if (!targetSession.kittyWindowId && sock) targetSession.kittyWindowId = findKittyWindowId(sock, targetId);
-          const wid = targetSession.kittyWindowId;
-          let delivered = false;
-
-          if (wid && sock && targetSession.type === 'wrapped') {
-            try {
-              const escaped = prompt.replace(/\\/g, '\\\\').replace(/'/g, "'\\''");
-              require('child_process').execSync(`kitty @ --to unix:${sock} send-text --match id:${wid} '${escaped}'`, {
-                timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
-              });
-              setTimeout(() => {
-                try {
-                  require('child_process').execSync(`kitty @ --to unix:${sock} send-key --match id:${wid} Return`, {
-                    timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
-                  });
-                } catch {}
-              }, 500);
-              delivered = true;
-            } catch {}
-          }
-          if (!delivered) {
-            // WS fallback
-            if (targetSession.type === 'wrapped' && targetSession.ownerWs && targetSession.ownerWs.readyState === 1) {
-              targetSession.ownerWs.send(JSON.stringify({ type: 'inject', data: prompt }));
-              setTimeout(() => {
-                if (targetSession.ownerWs && targetSession.ownerWs.readyState === 1) {
-                  targetSession.ownerWs.send(JSON.stringify({ type: 'inject', data: '\r' }));
-                }
-              }, 300);
-              delivered = true;
-            } else if (targetSession.ptyProcess) {
-              targetSession.ptyProcess.write(prompt);
-              setTimeout(() => targetSession.ptyProcess.write('\r'), 300);
-              delivered = true;
-            }
-          }
-
-          // Emit inject_written ack
-          const ackMsg = JSON.stringify({
-            type: 'inject_written',
-            inject_id,
-            sender: 'daemon',
-            target_agent: targetId,
-            source_type: 'bus_auto_route',
-            delivered,
-            timestamp: new Date().toISOString()
-          });
-          busClients.forEach(client => {
-            if (client.readyState === 1) client.send(ackMsg);
-          });
-          console.log(`[BUS-ROUTE] turn_request → ${targetId}: ${delivered ? 'delivered' : 'failed'}`);
-        }
-      }
+      // Auto-route turn_request events (shared logic with HTTP publish)
+      busAutoRoute(msg);
     } catch (e) {
       console.error('[BUS] Invalid message format', e);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "main": "daemon.js",
   "bin": {
     "aigentry-telepty": "install.js",