@openrig/cli 0.6.5 → 0.6.7

package/daemon/dist/domain/session-transport.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { inspectStartupStagedText, startupSubmissionEvidence } from "./startup-submission-evidence.js";
 export { inspectStartupStagedText } from "./startup-submission-evidence.js";
 import { OutboxHandler } from "./outbox-handler.js";
+import { latestHookWaitsOnPerson } from "./agent-activity-store.js";
 import { wrapPaneEnvelope, appendDeliveredSegment } from "../lib/pane-envelope.js";
 import { SeatIdentityStore } from "./seat-identity-store.js";
 import { isShellForeground } from "./shell-classifier.js";
@@ -46,9 +47,8 @@ const IDLE_PROMPT_PATTERNS = [
 const PROMPT_DRAFT_PATTERNS = [
     /^[❯›]\s+\S/,
 ];
-// Status-bar patterns that ONLY appear when the harness is at its idle
-// prompt. These are more reliable than the prompt char alone because they
-// are never rendered during active tool execution.
+// Footer hints, not proof of inactivity: Claude also renders its mode bar
+// during a turn. Current live-status evidence must take precedence below.
 const IDLE_STATUS_BAR_PATTERNS = [
     /gpt-\d[\d.]* .+ · Context \[/, // Codex model/context footer
     /⏵⏵ accept edits/, // Claude Code edit-accept bar
@@ -76,6 +76,7 @@ const PERMISSION_PROMPT_PATTERNS = [
 // after hitting this. Erring toward "prompt detected" is the SAFE direction for this guard: a false
 // refusal is overridable; a false-idle lets a message land on a prompt. (EXA: ntm e28763e; AgentDeck.)
 const PROMPT_SCAN_LINES = 12;
+const CLAUDE_QUESTION_FOOTER = "Enter to select · ↑/↓ to navigate · Esc to cancel";
 function trimPaneLines(paneContent) {
     return paneContent
         .split("\n")
@@ -94,6 +95,88 @@ function findPatternEvidence(lines, patterns) {
     }
     return null;
 }
+function findCurrentClaudeQuestion(paneContent) {
+    // Claude 2.1.289 can wrap a current choice beyond the general prompt window.
+    // Anchor at its terminal footer, then follow only the adjoining choice block.
+    // Preserve columns so indented draft/quoted text does not gain new authority.
+    const lines = paneContent.split("\n").map(line => line.trimEnd()).filter(line => line.length > 0);
+    if (lines.at(-1) !== CLAUDE_QUESTION_FOOTER)
+        return null;
+    for (let i = lines.length - 2; i >= 0; i--) {
+        const line = lines[i];
+        if (/^❯ \d+\.\s+\S/.test(line))
+            return truncateEvidence(line);
+        if (!/^(?: {2}\d+\.\s+\S| {5}\S|─{3,}$)/.test(line))
+            break;
+    }
+    return null;
+}
+// Claude can leave these noninteractive warnings BELOW the input box and mode bar.
+// Recognize the complete input block, never a warning or historical prompt alone.
+const CLAUDE_STATUS_WARNINGS = [
+    /^✘ Auto-update failed: no write permission to npm prefix · Run claude doctor$/,
+    /^tmux focus-events off · add 'set -g focus-events on' to ~\/\.tmux\.conf and re…$/,
+    /^You've used (?:\d|[1-9]\d)% of your weekly limit · resets \d{1,2}(?::\d{2})?(?:am|pm) \(UTC\)$/,
+];
+// Claude's permission-mode footers: default, accept edits, bypass, auto and plan, optionally after a
+// vim-mode marker such as "-- INSERT --" (#808). A suffix such as "· 1 shell" can follow the mode.
+const CLAUDE_MODE_FOOTER = /^(?:-- [A-Z]+ -- )?(?:⏵⏵ (?:accept edits|bypass permissions|auto mode) on\b|⏸ plan mode on\b|\? for shortcuts\b)/;
+// Current Claude status rows need not end in "thinking)" or show "esc to interrupt".
+// Completed summaries such as "✻ Crunched for 2s" lack the live ellipsis/timer shape.
+// While a hook runs, the timer follows its label: "(running PostToolUse hook · 3m 12s · …)".
+const CLAUDE_LIVE_STATUS_PATTERN = /^[✶✢✳✻✽·*]\s+\S[^(]*(?:…|\.{3})\s+\((?:running [^()·]+ hook · )?(?:\d+h\s+)?(?:\d+m\s+)?\d+s\b/;
+function findClaudeComposer(paneContent) {
+    // Preserve columns: a multiline draft may contain indented border/prompt text.
+    // This classifier scans at most 20 physical lines; captures can be taller.
+    // Exhausting the scan without reaching the status head is unknown, not idle.
+    const lines = paneContent.split("\n").slice(-20)
+        .map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
+    let bar = lines.length - 1;
+    while (bar >= 0 && CLAUDE_STATUS_WARNINGS.some((pattern) => pattern.test(lines[bar].trim())))
+        bar--;
+    const supportedWarningFooter = lines[bar]?.trim() === "⏵⏵ accept edits on (shift+tab to cycle) · ← for agents";
+    const modeFooter = CLAUDE_MODE_FOOTER.test(lines[bar]?.trim() ?? "");
+    let indent = /^([ \t]*)─{3,}$/.exec(lines[bar - 1] ?? "")?.[1];
+    const framed = indent !== undefined;
+    let prompt = lines[bar - 2] ?? "";
+    let statusStart = bar - 4;
+    if (indent === undefined) {
+        // The unframed Claude prompt has the same current status/task block.
+        // Keep Codex footers and a bare prompt with no visible block on their old path.
+        if (bar < 2 || !/^(?:⏵⏵ (?:accept edits|bypass permissions) on\b|⏸ plan mode on\b|\? for shortcuts$)/.test(lines[bar].trim()))
+            return null;
+        prompt = lines[bar - 1] ?? "";
+        indent = /^([ \t]*)❯\s*$/.exec(prompt)?.[1];
+        if (indent === undefined)
+            return null;
+        statusStart = bar - 2;
+    }
+    else {
+        const upper = lines[bar - 3] ?? "";
+        if (!upper.startsWith(indent) || !/^─{3,}(?: .+ ─+)?$/.test(upper.slice(indent.length)) ||
+            !prompt.startsWith(`${indent}❯`) || !/^❯(?:\s|$)/.test(prompt.slice(indent.length)))
+            return null;
+    }
+    let liveStatus = null;
+    let headSeen = false;
+    for (let i = statusStart; i >= 0; i--) {
+        if (!lines[i].startsWith(indent))
+            break;
+        const line = lines[i].slice(indent.length);
+        if ([CLAUDE_LIVE_STATUS_PATTERN, ...MID_WORK_PATTERNS].some((pattern) => pattern.test(line))) {
+            liveStatus = truncateEvidence(line);
+            headSeen = true;
+            break;
+        }
+        // Indented task rows can follow the live status. A newer unindented output
+        // or completed status ends this block; do not revive an older work row.
+        if (!/^\s/.test(line)) {
+            headSeen = true;
+            break;
+        }
+    }
+    return { text: prompt.slice(indent.length), bar: lines[bar].trim(), framed, hasWarnings: bar < lines.length - 1, supportedWarningFooter, modeFooter, headSeen, liveStatus };
+}
 function findPromptDraftBeforeFooter(paneContent) {
     const rawLines = paneContent.split("\n").map((line) => line.trimEnd());
     let lastLineIndex = rawLines.length - 1;
@@ -122,7 +205,6 @@ export function classifyPaneActivity(paneContent) {
         return { state: "unknown", reason: "empty_capture", evidence: null };
     }
     const recentLines = lastNonBlank.slice(-8);
-    const recentWindow = recentLines.join("\n");
     // Wider window for prompt SIGNATURES so a tall footer can't push a real prompt out of view (see
     // PROMPT_SCAN_LINES). The generic activity checks below keep the tighter 8-line window.
     const promptScanLines = lastNonBlank.slice(-PROMPT_SCAN_LINES);
@@ -132,7 +214,17 @@ export function classifyPaneActivity(paneContent) {
     const idleStatusBarLine = IDLE_STATUS_BAR_PATTERNS.some((pattern) => pattern.test(lastLine))
         ? lastLine
         : null;
-    const selectionPromptEvidence = findPatternEvidence(promptScanLines, [/^[❯›]\s*\d+\.\s/m]);
+    const claudeComposer = findClaudeComposer(paneContent);
+    const oldQuestionEnd = promptScanLines.lastIndexOf(CLAUDE_QUESTION_FOOTER);
+    // A complete later empty composer with a recognized Claude bar makes the preceding question history.
+    // Keep draft handling and selectors without this dialog boundary unchanged.
+    const selectionLines = claudeComposer?.framed &&
+        /^(?:⏵⏵ (?:accept edits|bypass permissions|auto mode) on\b|⏸ plan mode on\b|\? for shortcuts$)/.test(claudeComposer.bar) &&
+        IDLE_PROMPT_PATTERNS.some(pattern => pattern.test(claudeComposer.text)) &&
+        oldQuestionEnd >= 0 && oldQuestionEnd < promptScanLines.length - 1
+        ? promptScanLines.slice(oldQuestionEnd + 1) : promptScanLines;
+    const selectionPromptEvidence = findCurrentClaudeQuestion(paneContent) ??
+        findPatternEvidence(selectionLines, [/^[❯›]\s*\d+\.\s/m]);
     if (selectionPromptEvidence) {
         return {
             state: "attention",
@@ -151,6 +243,23 @@ export function classifyPaneActivity(paneContent) {
             evidence: permissionPromptEvidence,
         };
     }
+    if (claudeComposer?.hasWarnings && claudeComposer.supportedWarningFooter && PROMPT_DRAFT_PATTERNS.some((pattern) => pattern.test(claudeComposer.text))) {
+        return { state: "attention", reason: "prompt_draft", evidence: truncateEvidence(claudeComposer.text) };
+    }
+    if (claudeComposer?.liveStatus) {
+        return { state: "agent_active", reason: "mid_work_pattern", evidence: claudeComposer.liveStatus };
+    }
+    // Unframed status evidence can veto idle, but warnings require a complete input frame to prove it.
+    if (claudeComposer && (!claudeComposer.headSeen || (claudeComposer.hasWarnings && !claudeComposer.framed))) {
+        return { state: "unknown", reason: "no_activity_signal", evidence: truncateEvidence(lastLine) };
+    }
+    // Below warning rows, any Claude mode footer completes the frame for an EMPTY composer (#808).
+    // Drafts keep the narrower check above: attention is needs_input, a send refusal for other modes.
+    if (claudeComposer && (!claudeComposer.hasWarnings || claudeComposer.modeFooter) &&
+        IDLE_PROMPT_PATTERNS.some((pattern) => pattern.test(claudeComposer.text))) {
+        return { state: "agent_idle", reason: idleStatusBarLine ? "idle_status_bar" : "idle_prompt",
+            evidence: truncateEvidence(idleStatusBarLine ?? claudeComposer.text) };
+    }
     const promptDraftEvidence = findPromptDraftBeforeFooter(paneContent);
     if (promptDraftEvidence) {
         return {
@@ -159,7 +268,8 @@ export function classifyPaneActivity(paneContent) {
             evidence: promptDraftEvidence,
         };
     }
-    if (idleStatusBarLine) {
+    const midWorkEvidence = findPatternEvidence(recentLines, [...MID_WORK_PATTERNS, CLAUDE_LIVE_STATUS_PATTERN]);
+    if (idleStatusBarLine && (!idleStatusBarLine.includes("⏵⏵ accept edits") || !midWorkEvidence)) {
         return {
             state: "agent_idle",
             reason: "idle_status_bar",
@@ -181,14 +291,13 @@ export function classifyPaneActivity(paneContent) {
             evidence: placeholderMidWork,
         };
     }
-    if (idlePromptLine && !MID_WORK_PATTERNS.some((pattern) => pattern.test(recentWindow))) {
+    if (idlePromptLine && !midWorkEvidence) {
         return {
             state: "agent_idle",
             reason: "idle_prompt",
             evidence: truncateEvidence(idlePromptLine),
         };
     }
-    const midWorkEvidence = findPatternEvidence(recentLines, MID_WORK_PATTERNS);
     if (midWorkEvidence) {
         return {
             state: "agent_active",
@@ -501,6 +610,27 @@ export function hasExpectedStagedText(pane, expected) {
     }
     return stagedEvidence;
 }
+/** An interaction may consume its answer immediately. Only add Enter when the
+ * complete answer is still visible in a bounded current text input, never a
+ * numbered choice or a partial prefix. Unknown rendering is not consumption. */
+function promptAnswerStaged(pane, answer, runtime) {
+    if (!pane || !answer.trim() || /[\r\n\x1b]/.test(answer))
+        return false;
+    const lines = pane.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const input = lines[i].trimStart();
+        if (!/^[❯›]/.test(input))
+            continue;
+        if (/^[❯›]\s*\d+[.)]/.test(input))
+            return false;
+        if (runtime === "codex" ? !input.startsWith("›") : runtime !== "claude-code" || !input.startsWith("❯"))
+            return false;
+        const end = lines.findIndex((line, index) => index > i && (runtime === "codex"
+            ? line.trim() === "" : /^[─═-]{10,}$/.test(line.trim())));
+        return end > i && lines.slice(i, end).join("\n").trimStart().slice(1).trim() === answer.trim();
+    }
+    return false;
+}
 export class SessionTransport {
     db;
     rigRepo;
@@ -532,48 +662,37 @@ export class SessionTransport {
         this.captureObserver = deps.captureObserver;
         this.listProcesses = deps.listProcesses;
     }
-    /**
-     * Slice-05 D5/D6 — when a live transport op (send/capture) observes that the
-     * seat's tmux session is genuinely gone (a `probeSession` result of `absent`
-     * — POSITIVE tmux evidence, never a transport failure; OPR.0.5.4.2 mini-req
-     * 5), durably record the SAME `session_missing` identity verdict the
-     * reconciler would write, so `rig ps` stops reporting the dead seat as
-     * running WITHOUT waiting for the next reconciler poll. This is the
-     * transport-side writer of the shared verdict bridge; the reconciler is the
-     * poll-side writer. Transport-absence must never reach this method: a blip
-     * against a live seat would otherwise fabricate a durable absence verdict.
-     *
-     * Only writes an APPLICABLE verdict: the join is narrowed to the node whose
-     * LATEST running session_name equals the probed session (so
-     * `verdict.sessionName === latest session_name`, the node-inventory
-     * applicability gate), and it only writes when a binding pane is registered
-     * (a null pane is the reconciler's `tmux_unavailable` case, which is
-     * non-down-ranking — never fabricate `session_missing` without a pane).
-     * Never mutates `sessions.status`.
-     */
-    recordSessionMissingVerdict(sessionName) {
-        const seat = this.db
+    /** Freeze the registration and binding before asking tmux about this name. */
+    absenceProbeTarget(sessionName) {
+        return this.db
             .prepare(`
-        SELECT n.id AS node_id, s.session_name AS session_name, b.tmux_pane AS tmux_pane
+        SELECT s.id AS session_id, n.id AS node_id, s.session_name AS session_name, b.tmux_pane AS tmux_pane
         FROM nodes n
         JOIN sessions s ON s.node_id = n.id
           AND s.id = (SELECT s2.id FROM sessions s2 WHERE s2.node_id = n.id ORDER BY s2.id DESC LIMIT 1)
-        LEFT JOIN bindings b ON b.node_id = n.id
+        JOIN bindings b ON b.node_id = n.id AND b.tmux_session = s.session_name
         WHERE s.status = 'running'
           AND s.session_name = ?
         LIMIT 1
       `)
             .get(sessionName);
-        if (!seat || seat.tmux_pane === null)
+    }
+    /** Positive tmux absence only; a delayed reply cannot describe a replacement. */
+    recordSessionMissingVerdict(target, observedAt) {
+        if (!target || target.tmux_pane === null)
+            return;
+        const current = this.absenceProbeTarget(target.session_name);
+        if (!current || current.session_id !== target.session_id || current.node_id !== target.node_id
+            || current.tmux_pane !== target.tmux_pane)
             return;
         new SeatIdentityStore(this.db).upsert({
-            nodeId: seat.node_id,
+            nodeId: target.node_id,
             verdict: "pane_missing",
             evidenceSource: "tmux_session",
             reason: "session_missing",
-            evidence: { registeredPane: seat.tmux_pane, observedPid: null, observedCommand: null, matchedLayer: null },
-            sessionName: seat.session_name,
-            observedAt: this.now().toISOString(),
+            evidence: { registeredPane: target.tmux_pane, observedPid: null, observedCommand: null, matchedLayer: null },
+            sessionName: target.session_name,
+            observedAt,
         });
     }
     getSessionMeta(sessionName) {
@@ -976,9 +1095,11 @@ export class SessionTransport {
         // transport blip must never read as a dead seat, and absence is only ever
         // asserted on positive tmux evidence.
         try {
+            const target = this.absenceProbeTarget(sessionName);
+            const observedAt = this.now().toISOString();
             const probe = await this.tmuxAdapter.probeSession(sessionName);
             if (probe.state === "absent") {
-                this.recordSessionMissingVerdict(sessionName);
+                this.recordSessionMissingVerdict(target, observedAt);
                 return {
                     ok: false,
                     sessionName,
@@ -1089,6 +1210,7 @@ export class SessionTransport {
         // the positive-picker guard (FR-4 — the footgun separation). The advisory is carried on the
         // success result via `warning` so the honest telemetry is surfaced.
         let sendAdvisory;
+        let promptOverride = false;
         if (waitForIdleMs === undefined) {
             const readiness = await this.classifySendReadiness({
                 sessionName,
@@ -1128,7 +1250,8 @@ export class SessionTransport {
                             error: `Refused: --dangerously-interact requires an auditable override record, which could not be persisted (${audit.reason}). No text was sent.`,
                         };
                     }
-                    // audited → proceed to the send.
+                    // Audited answers use unbracketed input; a choice may submit itself.
+                    promptOverride = true;
                 }
                 else {
                     return {
@@ -1186,10 +1309,15 @@ export class SessionTransport {
         const targetFailure = await checkClaudeTarget();
         if (targetFailure)
             return observe(targetFailure);
-        // 3. Send text (paste)
+        // 3. Deliver ordinary messages as paste, audited prompt answers as key input.
         if (observed)
             observed.sentHash = hashSentText(text);
-        const textResult = await this.runStage("session_transport.send_text", () => { opts?.beforeWrite?.(); return opts?.beforeWrite ? this.tmuxAdapter.sendText(sessionName, text, opts.beforeWrite) : this.tmuxAdapter.sendText(sessionName, text); }, (result) => result.ok ? "ok" : "failed");
+        const textResult = await this.runStage("session_transport.send_text", () => {
+            opts?.beforeWrite?.();
+            if (promptOverride)
+                return this.tmuxAdapter.sendText(sessionName, text, opts?.beforeWrite, { bracketed: false });
+            return opts?.beforeWrite ? this.tmuxAdapter.sendText(sessionName, text, opts.beforeWrite) : this.tmuxAdapter.sendText(sessionName, text);
+        }, (result) => result.ok ? "ok" : "failed");
         if (!textResult.ok) {
             return observe({
                 ok: false,
@@ -1204,6 +1332,16 @@ export class SessionTransport {
         await this.sleep(200);
         if (runtime === "claude-code" && bindingChanged())
             return observe(changedRecipient(true));
+        if (promptOverride) {
+            const pane = await this.runStage("session_transport.prompt_override_pre_submit_capture", () => this.tmuxAdapter.capturePaneContent(sessionName, 50)).catch(() => null);
+            if (runtime === "claude-code" && bindingChanged())
+                return observe(changedRecipient(true));
+            if (!promptAnswerStaged(pane, text, runtime)) {
+                return observe({ ok: true, sessionName, sent: true, verified: false, outcome: "rendered-unconfirmed", promptInteraction: "unverified",
+                    warning: "prompt-override: answer sent as unbracketed input; submission unverified. No trailing Enter: the complete answer is not visibly staged (it may have been consumed, the prompt changed, or observation is unavailable)." });
+            }
+            sendAdvisory = "prompt-override: answer sent as unbracketed input; Enter submitted the complete still-staged answer.";
+        }
         // 5. Submit (Enter)
         const submitResult = await this.runStage("session_transport.submit", () => { opts?.beforeWrite?.(); return opts?.beforeWrite ? this.tmuxAdapter.sendKeys(sessionName, ["Enter"], opts.beforeWrite) : this.tmuxAdapter.sendKeys(sessionName, ["Enter"]); }, (result) => result.ok ? "ok" : "failed");
         if (!submitResult.ok) {
@@ -1216,6 +1354,7 @@ export class SessionTransport {
                 ...(waitMode ? { sent: true, ...waitEvidence } : {}),
             });
         }
+        const interaction = promptOverride ? { promptInteraction: "enter-sent" } : {};
         // 6. Verify if requested. At this point text + Enter BOTH succeeded, so the
         // message LANDED; the capture only re-confirms the render. Not re-confirming
         // (a TUI redraw race, or the capture throwing) is therefore the honest
@@ -1231,16 +1370,16 @@ export class SessionTransport {
                 const preCount = countOccurrences(preVerifyContent ?? "", snippet);
                 const postCount = countOccurrences(content ?? "", snippet);
                 const verified = postCount > preCount;
-                return observe({ ok: true, sessionName, verified, outcome: verified ? "delivered" : "rendered-unconfirmed", ...(sendAdvisory ? { warning: sendAdvisory } : {}), ...(waitMode ? { sent: true, ...waitEvidence } : {}) });
+                return observe({ ok: true, sessionName, ...interaction, verified, outcome: verified ? "delivered" : "rendered-unconfirmed", ...(sendAdvisory ? { warning: sendAdvisory } : {}), ...(waitMode ? { sent: true, ...waitEvidence } : {}) });
             }
             catch {
                 if (observed && observed.post.state === "not_reached") {
                     observed.post = { state: "unavailable", cause: "capture_error", capturedAt: this.now().toISOString(), captureSeq };
                 }
-                return observe({ ok: true, sessionName, verified: false, outcome: "rendered-unconfirmed", ...(sendAdvisory ? { warning: sendAdvisory } : {}), ...(waitMode ? { sent: true, ...waitEvidence } : {}) });
+                return observe({ ok: true, sessionName, ...interaction, verified: false, outcome: "rendered-unconfirmed", ...(sendAdvisory ? { warning: sendAdvisory } : {}), ...(waitMode ? { sent: true, ...waitEvidence } : {}) });
             }
         }
-        return observe({ ok: true, sessionName, ...(sendAdvisory ? { warning: sendAdvisory } : {}), ...(waitMode ? { sent: true, ...waitEvidence } : {}) });
+        return observe({ ok: true, sessionName, ...interaction, ...(sendAdvisory ? { warning: sendAdvisory } : {}), ...(waitMode ? { sent: true, ...waitEvidence } : {}) });
     }
     runStage(site, fn, classify) {
         return this.slowOpRecorder?.runStage
@@ -1462,6 +1601,19 @@ export class SessionTransport {
             (hookActivity.state === "running" || hookActivity.state === "needs_input")) {
             return hookActivity;
         }
+        // A latest hook saying the seat waits on a person (approval, picker or elicitation) stays positive
+        // picker evidence past the send window, and past the store's freshness window: nothing newer was
+        // recorded, so nothing answered it. The pane alone can miss a picker it has no signature for (a
+        // Claude AskUserQuestion with option previews read unknown, and a watchdog wake's Enter chose its
+        // first option). An UNKNOWN pane keeps the hook's verdict; a pane that reads work or a recognized
+        // empty composer shows the seat has moved on.
+        if (probe.state === "unknown" && hookActivity && latestHookWaitsOnPerson(hookActivity, input.runtime)) {
+            return {
+                ...hookActivity,
+                state: "needs_input",
+                reason: `${hookActivity.rawSubtype ?? hookActivity.rawEvent ?? "needs_input"}; latest hook, pane unrecognized`,
+            };
+        }
         return probe;
     }
     // OPR.0.4.1.10 — a runtime-hook is authoritative for send-readiness only within the tight send
@@ -1616,9 +1768,11 @@ export class SessionTransport {
         // Classified probe (OPR.0.5.4.2) — same discipline as the send gate: a
         // transport blip is a transport answer, never a dead-seat answer.
         try {
+            const target = this.absenceProbeTarget(sessionName);
+            const observedAt = this.now().toISOString();
             const probe = await this.tmuxAdapter.probeSession(sessionName);
             if (probe.state === "absent") {
-                this.recordSessionMissingVerdict(sessionName);
+                this.recordSessionMissingVerdict(target, observedAt);
                 return {
                     ok: false,
                     sessionName,