@dmsdc-ai/aigentry-deliberation 0.0.40 → 0.0.42

package/index.js

@@ -154,6 +154,8 @@ import {
 } from "./lib/speaker-discovery.js";
 import {
   initSessionDeps,
+  DEFAULT_SESSION_TTL_MS,
+  isSessionExpired,
   generateSessionId,
   generateTurnId,
   detectContextDirs,
@@ -354,6 +356,34 @@ function getSessionFile(sessionRef, projectSlug) {
   return path.join(getSessionsDir(getSessionProject(sessionRef, projectSlug)), `${sessionId}.json`);
 }
 
+function getExecutionStatusFile(sessionId, projectSlug) {
+  return path.join(getProjectStateDir(projectSlug || getProjectSlug()), `exec-status-${sessionId}.json`);
+}
+
+function loadExecutionStatus(sessionId, projectSlug) {
+  // Search across all projects if projectSlug not given
+  const projects = projectSlug
+    ? [normalizeProjectSlug(projectSlug)]
+    : [getProjectSlug(), ...listStateProjects()];
+  for (const p of [...new Set(projects)]) {
+    const file = getExecutionStatusFile(sessionId, p);
+    try {
+      const data = JSON.parse(fs.readFileSync(file, "utf-8"));
+      if (data && data.session_id === sessionId) return data;
+    } catch { /* not found */ }
+  }
+  return null;
+}
+
+function saveExecutionStatus(sessionId, projectSlug, patch) {
+  const file = getExecutionStatusFile(sessionId, normalizeProjectSlug(projectSlug || getProjectSlug()));
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const existing = (() => { try { return JSON.parse(fs.readFileSync(file, "utf-8")); } catch { return {}; } })();
+  const updated = { ...existing, ...patch, session_id: sessionId, updated_at: new Date().toISOString() };
+  fs.writeFileSync(file, JSON.stringify(updated, null, 2));
+  return updated;
+}
+
 function listStateProjects() {
   if (!fs.existsSync(GLOBAL_STATE_DIR)) return [];
   try {
@@ -690,11 +720,17 @@ server.tool(
       (v) => (typeof v === "string" ? v === "true" : v),
       z.boolean().optional()
     ).describe("If true, automatically create a handoff task in the inbox when synthesis completes. Enables the Autonomous Deliberation Handoff pattern."),
+    auto_synthesize: z.preprocess(
+      (v) => (typeof v === "string" ? v === "true" : v),
+      z.boolean().optional()
+    ).describe("If true, automatically generate synthesis when all rounds complete. Lighter than auto_execute (no handoff)."),
     mode: z.enum(["standard", "lite"]).default("standard").describe("Deliberation mode. 'lite' caps speakers to 3 and rounds to 2 for quick decisions."),
+    session_ttl_ms: z.number().int().min(60000).max(86400000).optional()
+      .describe("Session TTL in milliseconds. Sessions expire after this duration. Default: 7200000 (2 hours). Max: 86400000 (24 hours)."),
     orchestrator_session_id: z.string().trim().min(1).max(128).optional()
       .describe("Optional telepty session ID to notify on turn completion. Defaults to TELEPTY_SESSION_ID when available."),
   },
-  safeToolHandler("deliberation_start", async ({ topic, session_id, rounds, first_speaker, selection_token, speakers, speaker_instructions, require_manual_speakers, auto_discover_speakers, include_browser_speakers, participant_types, ordering_strategy, speaker_roles, role_preset, auto_execute, mode, orchestrator_session_id }) => {
+  safeToolHandler("deliberation_start", async ({ topic, session_id, rounds, first_speaker, selection_token, speakers, speaker_instructions, require_manual_speakers, auto_discover_speakers, include_browser_speakers, participant_types, ordering_strategy, speaker_roles, role_preset, auto_execute, auto_synthesize, mode, session_ttl_ms, orchestrator_session_id }) => {
     // ── First-time onboarding guard ──
     const config = loadDeliberationConfig();
     if (!config.setup_complete) {
@@ -884,7 +920,9 @@ server.tool(
       speaker_roles: speaker_roles || (role_preset ? applyRolePreset(role_preset, speakerOrder) : {}),
       degradation: degradationLevels,
       auto_execute: auto_execute || false,
+      auto_synthesize: auto_synthesize || auto_execute || false,
       mode: mode || "standard",
+      session_ttl_ms: session_ttl_ms || DEFAULT_SESSION_TTL_MS,
       orchestrator_session_id: orchestrator_session_id || getDefaultOrchestratorSessionId() || null,
       created: new Date().toISOString(),
       updated: new Date().toISOString(),
@@ -955,7 +993,9 @@ server.tool(
     appendRuntimeLog("INFO", `SESSION_CREATED: ${sessionId} | topic: ${topic.slice(0, 60)} | speakers: ${speakerOrder.join(",")} | rounds: ${rounds}`);
 
     // Auto-handoff: kick off background orchestration
-    if (auto_execute) {
+    // auto_execute = full handoff (turns + synthesis + bus notification)
+    // auto_synthesize = lighter (turns + synthesis only, no bus notification)
+    if (auto_execute || auto_synthesize) {
       // Fire-and-forget — runs in background
       runAutoHandoff(sessionId).catch(err => {
         appendRuntimeLog("ERROR", `AUTO_HANDOFF_SPAWN_ERROR: ${sessionId} | ${err.message}`);
@@ -1074,10 +1114,27 @@ server.tool(
       return { content: [{ type: "text", text: t(`Session "${resolved}" not found.`, `세션 "${resolved}"을 찾을 수 없습니다.`, "en") }] };
     }
 
+    if (isSessionExpired(state)) {
+      state.status = "expired";
+      state.current_speaker = "none";
+      state.expired_reason = "ttl_exceeded";
+      saveSession(state);
+      return {
+        content: [{
+          type: "text",
+          text: `⏰ Session "${resolved}" has expired (TTL exceeded).\nTopic: ${state.topic}\nCreated: ${state.created}\n\nUse \`deliberation_reset(session_id: "${resolved}")\` to clean up, or start a new deliberation.`,
+        }],
+      };
+    }
+
+    const execStatus = loadExecutionStatus(state.id, state.project);
+    const execLine = execStatus
+      ? `\n**Execution status:** ${execStatus.execution_status}${execStatus.tasks_total > 0 ? ` (${execStatus.tasks_done}/${execStatus.tasks_total} tasks)` : ""}${execStatus.note ? ` — ${execStatus.note}` : ""}`
+      : "";
     return {
       content: [{
         type: "text",
-        text: `📋 **Forum Status** — ${state.id}\n\n**Project:** ${state.project}\n**Topic:** ${state.topic}\n**Status:** ${state.status === "active" ? "active" : state.status === "awaiting_synthesis" ? "awaiting synthesis" : state.status === "completed" ? "completed" : state.status} (Round ${state.current_round}/${state.max_rounds})\n**Participants:** ${state.speakers.join(", ")}\n**Current turn:** ${state.current_speaker}\n**Accumulated responses:** ${state.log.length}${state.degradation ? `\n\n**Environment status:**\n${formatDegradationReport(state.degradation)}` : ""}`,
+        text: `📋 **Forum Status** — ${state.id}\n\n**Project:** ${state.project}\n**Topic:** ${state.topic}\n**Status:** ${state.status === "active" ? "active" : state.status === "awaiting_synthesis" ? "awaiting synthesis" : state.status === "completed" ? "completed" : state.status} (Round ${state.current_round}/${state.max_rounds})${execLine}\n**Participants:** ${state.speakers.join(", ")}\n**Current turn:** ${state.current_speaker}\n**Accumulated responses:** ${state.log.length}${state.degradation ? `\n\n**Environment status:**\n${formatDegradationReport(state.degradation)}` : ""}`,
       }],
     };
   }
@@ -2040,6 +2097,14 @@ server.tool(
       saveSession(loaded);
       archivePath = archiveState(loaded);
       cleanupSyncMarkdown(loaded);
+      // Write execution_status sidecar (persists after session file is deleted)
+      saveExecutionStatus(loaded.id, loaded.project, {
+        execution_status: loaded.auto_execute ? "executing" : "pending",
+        tasks_total: loaded.execution_contract?.tasks?.length ?? 0,
+        tasks_done: 0,
+        project: loaded.project,
+        topic: loaded.topic,
+      });
 
       // Clean up the active session JSON file upon completion
       const sessionFile = getSessionFile(loaded);
@@ -2094,6 +2159,51 @@ server.tool(
   })
 );
 
+server.tool(
+  "deliberation_set_execution_status",
+  "Update the execution status of a completed deliberation's handoff. Used by executor agents to report implementation progress.",
+  {
+    session_id: z.string().min(1).describe("Session ID of the completed deliberation"),
+    status: z.enum(["pending", "executing", "implemented", "failed"]).describe("New execution status"),
+    tasks_done: z.number().int().min(0).optional().describe("Number of tasks completed so far"),
+    tasks_total: z.number().int().min(0).optional().describe("Total number of tasks (if known)"),
+    note: z.string().max(200).optional().describe("Short progress note (max 200 chars)"),
+    project: z.string().optional().describe("Project slug (auto-detected if omitted)"),
+  },
+  safeToolHandler("deliberation_set_execution_status", async ({ session_id, status, tasks_done, tasks_total, note, project }) => {
+    const patch = { execution_status: status };
+    if (tasks_done !== undefined) patch.tasks_done = tasks_done;
+    if (tasks_total !== undefined) patch.tasks_total = tasks_total;
+    if (note !== undefined) patch.note = note;
+
+    const saved = saveExecutionStatus(session_id, project, patch);
+
+    // Notify telepty bus so other MCP processes can react
+    const statusEvent = {
+      kind: "execution_status_update",
+      session_id,
+      project: project || getProjectSlug(),
+      execution_status: status,
+      tasks_done: saved.tasks_done ?? 0,
+      tasks_total: saved.tasks_total ?? 0,
+      note: note || null,
+      timestamp: new Date().toISOString(),
+    };
+    notifyTeleptyBus(statusEvent).catch(() => {});
+    appendRuntimeLog("INFO", `EXECUTION_STATUS: ${session_id} | status: ${status} | tasks: ${saved.tasks_done ?? 0}/${saved.tasks_total ?? 0}`);
+
+    const taskLine = (saved.tasks_total ?? 0) > 0
+      ? ` (${saved.tasks_done ?? 0}/${saved.tasks_total} tasks)`
+      : "";
+    return {
+      content: [{
+        type: "text",
+        text: `✅ Execution status updated\n\n**Session:** ${session_id}\n**Status:** ${status}${taskLine}${note ? `\n**Note:** ${note}` : ""}`,
+      }],
+    };
+  })
+);
+
 server.tool(
   "deliberation_list",
   "Return the list of past deliberation archives.",

package/lib/session.js

@@ -16,6 +16,7 @@ import {
   notifyTeleptyBus,
   notifyTeleptySessionInject,
   buildTeleptyTurnCompletedEnvelope,
+  buildTeleptyTurnRespondedEnvelope,
   getDefaultOrchestratorSessionId,
   buildTurnCompletionNotificationText,
 } from "./telepty.js";
@@ -56,6 +57,19 @@ export function initSessionDeps(deps) {
   Object.assign(_deps, deps);
 }
 
+// ── Session TTL ──────────────────────────────────────────────
+
+export const DEFAULT_SESSION_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
+
+export function isSessionExpired(state) {
+  if (!state || !state.created) return false;
+  // Only expire sessions that explicitly opted in to TTL
+  if (!state.session_ttl_ms) return false;
+  const createdAt = new Date(state.created).getTime();
+  if (isNaN(createdAt)) return false;
+  return Date.now() - createdAt > state.session_ttl_ms;
+}
+
 // ── Session ID generation ─────────────────────────────────────
 
 export function generateSessionId(topic) {
@@ -157,6 +171,9 @@ export function findSessionRecord(sessionRef, { preferProject, activeOnly = fals
     if (activeOnly && normalized.status !== "active" && normalized.status !== "awaiting_synthesis") {
       return null;
     }
+    if (activeOnly && isSessionExpired(normalized)) {
+      return null;
+    }
     return { file, project, state: normalized };
   }
 
@@ -171,6 +188,9 @@ export function findSessionRecord(sessionRef, { preferProject, activeOnly = fals
     if (activeOnly && normalized.status !== "active" && normalized.status !== "awaiting_synthesis") {
       continue;
     }
+    if (activeOnly && isSessionExpired(normalized)) {
+      continue;
+    }
     return { file, project: normalized.project || project, state: normalized };
   }
   return null;
@@ -216,15 +236,16 @@ export function listActiveSessions(projectSlug) {
           return null;
         }
       })
-      .filter(s => s && (s.status === "active" || s.status === "awaiting_synthesis"));
+      .filter(s => s && (s.status === "active" || s.status === "awaiting_synthesis") && !isSessionExpired(s));
   });
 }
 
 export function resolveSessionId(sessionId) {
-  // Use session_id directly if provided
+  // Use session_id directly if provided — do not load or expire here;
+  // individual tool handlers check expiry when needed.
   if (sessionId) return sessionId;
 
-  // Auto-select when only one active session
+  // Auto-select when only one active session (listActiveSessions now checks TTL)
   const active = listActiveSessions();
   if (active.length === 0) return null;
   if (active.length === 1) return active[0].id;
@@ -556,6 +577,13 @@ export function submitDeliberationTurn({ session_id, speaker, content, turn_id,
       speaker: normalizedSpeaker,
       turnId: state.pending_turn_id || turn_id || null,
     });
+    // Cross-process semantic completion: notify other MCP processes via bus
+    const turnRespondedEnvelope = buildTeleptyTurnRespondedEnvelope({
+      state,
+      speaker: normalizedSpeaker,
+      turnId: state.pending_turn_id || turn_id || null,
+    });
+    notifyTeleptyBus(turnRespondedEnvelope).catch(() => {});
     _deps.appendRuntimeLog("INFO", `TURN: ${state.id} | R${state.current_round} | speaker: ${normalizedSpeaker} | votes: ${votes.length > 0 ? votes.map(v => v.vote).join(",") : "none"} | channel: ${channel_used || "respond"} | attachments: ${attachments ? attachments.length : 0}${source_metadata?.source_machine_id ? ` | source_machine: ${source_metadata.source_machine_id}` : ""}`);
 
     state.current_speaker = selectNextSpeaker(state);

package/lib/telepty.js

@@ -126,6 +126,14 @@ export const TeleptyTurnCompletedPayloadSchema = z.object({
   orchestrator_session_id: z.string().nullable().optional(),
 });
 
+export const TeleptyTurnRespondedPayloadSchema = z.object({
+  session_id: z.string().min(1),
+  speaker: z.string().min(1),
+  turn_id: z.string().nullable().optional(),
+  round: z.number().int().positive(),
+  timestamp: z.string().min(1),
+});
+
 export const TeleptyDeliberationCompletedPayloadSchema = z.object({
   topic: z.string(),
   synthesis: z.string(),
@@ -136,6 +144,7 @@ export const TeleptyDeliberationCompletedPayloadSchema = z.object({
 export const TELEPTY_ENVELOPE_PAYLOAD_SCHEMAS = {
   turn_request: TeleptyTurnRequestPayloadSchema,
   turn_completed: TeleptyTurnCompletedPayloadSchema,
+  turn_responded: TeleptyTurnRespondedPayloadSchema,
   deliberation_completed: TeleptyDeliberationCompletedPayloadSchema,
 };
 
@@ -310,6 +319,29 @@ export function buildTeleptyTurnCompletedEnvelope({ state, entry }) {
   });
 }
 
+export function buildTeleptyTurnRespondedEnvelope({ state, speaker, turnId }) {
+  return buildTeleptyEnvelope({
+    session_id: state.id,
+    project: state.project || _deps.getProjectSlug(),
+    kind: "turn_responded",
+    source: `deliberation:${state.id}`,
+    target: "telepty-bus",
+    reply_to: state.id,
+    trace: [
+      `project:${state.project || _deps.getProjectSlug()}`,
+      `speaker:${speaker}`,
+      `turn:${turnId || "none"}`,
+    ],
+    payload: {
+      session_id: state.id,
+      speaker,
+      turn_id: turnId || null,
+      round: state.current_round,
+      timestamp: new Date().toISOString(),
+    },
+  });
+}
+
 export function buildTeleptySynthesisEnvelope({ state, synthesis, structured, executionContract }) {
   const derivedExecutionContract =
     executionContract !== undefined
@@ -478,6 +510,14 @@ export function handleTeleptyBusMessage(raw) {
   if (parsed.type === "session_health") {
     return updateTeleptySessionHealth(parsed);
   }
+  if (parsed.kind === "turn_responded" && parsed.payload) {
+    completePendingTeleptySemantic({
+      sessionId: parsed.payload.session_id,
+      speaker: parsed.payload.speaker,
+      turnId: parsed.payload.turn_id || null,
+    });
+    return parsed;
+  }
   return parsed;
 }
 
@@ -643,7 +683,7 @@ export function buildTurnCompletionNotificationText(state, entry) {
   ].join("\n");
 }
 
-export async function notifyTeleptySessionInject({ targetSessionId, prompt, fromSessionId, replyToSessionId = null, host = TELEPTY_DEFAULT_HOST }) {
+export async function notifyTeleptySessionInject({ targetSessionId, prompt, fromSessionId, replyToSessionId = null, deliberationSessionId = null, turnId = null, host = TELEPTY_DEFAULT_HOST }) {
   if (!targetSessionId || !prompt) return { ok: false, error: "missing target or prompt" };
   const token = loadTeleptyAuthToken();
   if (!token) return { ok: false, error: "telepty auth token unavailable" };
@@ -659,7 +699,8 @@ export async function notifyTeleptySessionInject({ targetSessionId, prompt, from
         prompt,
         from: fromSessionId || null,
         reply_to: replyToSessionId || null,
-        deliberation_session_id: null,
+        deliberation_session_id: deliberationSessionId || null,
+        turn_id: turnId || null,
         thread_id: null,
       }),
     });
@@ -698,6 +739,8 @@ export async function dispatchTeleptyTurnRequest({ state, speaker, prompt = null
     prompt: turnPrompt,
     fromSessionId: `deliberation:${state.id}`,
     replyToSessionId: state.id,
+    deliberationSessionId: state.id,
+    turnId,
     host: targetHost,
   });
 

package/lib/transport.js

@@ -17,6 +17,7 @@ import {
   dispatchTeleptyTurnRequest,
   buildTeleptySynthesisEnvelope,
   notifyTeleptyBus,
+  notifyTeleptySessionInject,
   callBrainIngest,
   buildExecutionContract,
   ensureTeleptyBusSubscriber,
@@ -932,6 +933,13 @@ export async function runUntilBlockedCore(sessionId, {
     const { transport } = resolveTransportForSpeaker(state, speaker);
     const callerSpeaker = detectCallerSpeaker();
     if (transport === "cli_respond" && callerSpeaker && normalizeSpeaker(callerSpeaker) === normalizeSpeaker(speaker)) {
+      // Count how many remaining speakers can be auto-dispatched after the orchestrator responds
+      const remainingAutoSpeakers = (state.speakers || []).filter(s => {
+        if (normalizeSpeaker(s) === normalizeSpeaker(callerSpeaker)) return false;
+        const { transport: t } = resolveTransportForSpeaker(state, s);
+        return t === "cli_respond" || t === "browser_auto" || t === "telepty_bus";
+      }).length;
+
       return {
         ok: true,
         status: "blocked",
@@ -939,6 +947,10 @@ export async function runUntilBlockedCore(sessionId, {
         speaker,
         transport,
         turn_prompt: buildClipboardTurnPrompt(state, speaker, null, includeHistoryEntries),
+        remaining_auto_speakers: remainingAutoSpeakers,
+        hint: remainingAutoSpeakers > 0
+          ? "Respond with deliberation_respond, then call run_until_blocked again to auto-progress remaining speakers."
+          : undefined,
         steps,
       };
     }
@@ -1108,11 +1120,13 @@ Respond with EXACTLY this JSON structure:
 
 /**
  * Orchestrate full auto-handoff: run all turns -> synthesize -> inbox -> telepty.
- * Called as fire-and-forget from deliberation_start when auto_execute is true.
+ * Called as fire-and-forget from deliberation_start when auto_execute or auto_synthesize is true.
  */
 export async function runAutoHandoff(sessionId) {
   _deps.appendRuntimeLog("INFO", `AUTO_HANDOFF_START: ${sessionId}`);
 
+  const retryConfig = { maxRetries: 2, retryDelayMs: 10000 };
+
   try {
     // Phase 1: Run all deliberation turns
     let maxIterations = 100; // safety limit
@@ -1132,14 +1146,41 @@ export async function runAutoHandoff(sessionId) {
 
       _deps.appendRuntimeLog("INFO", `AUTO_HANDOFF_TURN: ${sessionId} | speaker: ${speaker} | round: ${state.current_round}/${state.max_rounds}`);
 
-      const runResult = await runUntilBlockedCore(sessionId, { maxTurns: 1, includeHistoryEntries: 3 });
-      const step = runResult.steps.at(-1) || null;
-      if (!runResult.ok || runResult.status === "blocked") {
-        _deps.appendRuntimeLog("WARN", `AUTO_HANDOFF_TURN_BLOCKED: ${sessionId} | speaker: ${speaker} | ${runResult.block_reason || runResult.error || "unknown"}`);
-        break;
+      let turnSucceeded = false;
+      for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+        const runResult = await runUntilBlockedCore(sessionId, { maxTurns: 1, includeHistoryEntries: 3 });
+        const step = runResult.steps.at(-1) || null;
+
+        if (runResult.ok && runResult.status !== "blocked") {
+          _deps.appendRuntimeLog("INFO", `AUTO_HANDOFF_TURN_OK: ${sessionId} | speaker: ${speaker} | ${step?.elapsedMs || 0}ms`);
+          turnSucceeded = true;
+          break;
+        }
+
+        // self_turn blocks should break immediately — the orchestrator itself is the speaker
+        if (runResult.block_reason === "self_turn") {
+          _deps.appendRuntimeLog("WARN", `AUTO_HANDOFF_SELF_TURN: ${sessionId} | speaker: ${speaker} | breaking`);
+          turnSucceeded = false;
+          break;
+        }
+
+        if (attempt < retryConfig.maxRetries) {
+          _deps.appendRuntimeLog("WARN", `AUTO_HANDOFF_RETRY: ${sessionId} | speaker: ${speaker} | attempt ${attempt + 1}/${retryConfig.maxRetries} | reason: ${runResult.block_reason || runResult.error || "unknown"} | retrying in ${retryConfig.retryDelayMs}ms`);
+          await new Promise(r => setTimeout(r, retryConfig.retryDelayMs));
+        } else {
+          _deps.appendRuntimeLog("WARN", `AUTO_HANDOFF_SKIP: ${sessionId} | speaker: ${speaker} | exhausted ${retryConfig.maxRetries} retries | submitting placeholder`);
+          // Submit a placeholder turn so the session can advance to the next speaker
+          submitDeliberationTurn({
+            session_id: sessionId,
+            speaker,
+            content: `[AUTO_SKIP] Speaker ${speaker} did not respond after ${retryConfig.maxRetries} retries.`,
+            channel_used: "auto_skip",
+          });
+          turnSucceeded = true; // placeholder submitted, continue with next speaker
+        }
       }
 
-      _deps.appendRuntimeLog("INFO", `AUTO_HANDOFF_TURN_OK: ${sessionId} | speaker: ${speaker} | ${step?.elapsedMs || 0}ms`);
+      if (!turnSucceeded) break;
     }
 
     // Phase 2: Generate structured synthesis
@@ -1206,6 +1247,20 @@ export async function runAutoHandoff(sessionId) {
       _deps.appendRuntimeLog("INFO", `AUTO_HANDOFF_NOTIFIED: ${sessionId} | telepty event sent`);
     }
 
+    // Phase 5: Report final results to orchestrator
+    const orchestratorSessionId = state.orchestrator_session_id;
+    if (orchestratorSessionId) {
+      const taskCount = structured.actionable_tasks?.length || 0;
+      const decisionCount = structured.decisions?.length || 0;
+      const reportText = `[deliberation_auto_complete] session: ${sessionId} | topic: ${state.topic} | decisions: ${decisionCount} | tasks: ${taskCount} | status: completed`;
+      notifyTeleptySessionInject({
+        targetSessionId: orchestratorSessionId,
+        prompt: reportText,
+        fromSessionId: `deliberation:${sessionId}`,
+      }).catch(() => {});
+      _deps.appendRuntimeLog("INFO", `AUTO_HANDOFF_REPORTED: ${sessionId} | orchestrator: ${orchestratorSessionId}`);
+    }
+
     _deps.appendRuntimeLog("INFO", `AUTO_HANDOFF_COMPLETE: ${sessionId}`);
   } catch (err) {
     _deps.appendRuntimeLog("ERROR", `AUTO_HANDOFF_ERROR: ${sessionId} | ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-deliberation",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "MCP server for structured multi-AI discussions — deliberate across Claude, GPT, Gemini and more before committing to decisions",
   "type": "module",
   "license": "MIT",