commandmate 0.26.1 → 0.27.0

package/dist/server/src/lib/cli-tools/opencode.js

@@ -6,8 +6,8 @@
  * @remarks Follows the same tmux-based pattern as Claude/Codex/Gemini/VibeLocal tools.
  * - startSession: launches `opencode` TUI in tmux
  * - sendMessage: sends text via tmux send-keys + Enter
- * - killSession: sends `/exit` command then falls back to tmux kill-session
- * - interrupt(): inherits BaseCLITool default (Escape key) [D2-008]
+ * - killSession: types `/exit` + a separate Enter, then falls back to tmux kill-session
+ * - interrupt(): Escape TWICE, 300 ms apart -- one press does not abort (Issue #1894)
  *
  * ## Structured events (Issue #1763, Epic #1720 Phase 4-5)
  *
@@ -24,20 +24,35 @@
  * both when the pane is killed. Every one of them is fail-open — a session that
  * starts without structured events is the pre-#1763 status quo, and the screen
  * scraper keeps deciding for it exactly as before.
+ *
+ * ## Launch side effects (Issue #1908)
+ *
+ * Two things this file used to do on the way up are gone. The 15-second sleep
+ * between the launch keystroke and `attachOpencodeEventStream` is now a poll for
+ * opencode's own composer ({@link OpenCodeTool.waitForReady}), and
+ * `ensureOpencodeConfig` no longer writes into the worktree unless the operator
+ * opted in — see `./opencode-config`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenCodeTool = exports.OPENCODE_INIT_WAIT_MS = exports.OPENCODE_PANE_HEIGHT = exports.OPENCODE_EXIT_COMMAND = void 0;
+exports.OpenCodeTool = exports.OPENCODE_READY_MAX_ATTEMPTS = exports.OPENCODE_READY_POLL_INTERVAL_MS = exports.OPENCODE_PANE_HEIGHT = exports.OPENCODE_EXIT_COMMAND = void 0;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
+const cli_patterns_1 = require("../detection/cli-patterns");
 const submit_verified_sender_1 = require("./submit-verified-sender");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const opencode_config_1 = require("./opencode-config");
+const tmux_pane_config_1 = require("../../config/tmux-pane-config");
+Object.defineProperty(exports, "OPENCODE_PANE_HEIGHT", { enumerable: true, get: function () { return tmux_pane_config_1.OPENCODE_PANE_HEIGHT; } });
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const logger_1 = require("../../lib/logger");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const runtime_1 = require("../../lib/hooks/sources/opencode/runtime");
+const ports_1 = require("../../lib/hooks/sources/opencode/ports");
+const client_1 = require("../../lib/hooks/sources/opencode/client");
+const graceful_exit_1 = require("./graceful-exit");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
+const session_start_error_1 = require("../session/session-start-error");
 const logger = (0, logger_1.createLogger)('cli-tools/opencode');
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /**
@@ -53,18 +68,32 @@ function getErrorMessage(error) {
 /** OpenCode TUI graceful exit command [D1-006] */
 exports.OPENCODE_EXIT_COMMAND = '/exit';
 /**
- * OpenCode tmux pane height (rows).
- * Set to 200 to expand the TUI content area (~190 visible lines),
- * allowing most responses to be captured in a single tmux capture-pane.
- * OpenCode runs in alternate screen mode with no scrollback buffer,
- * so only visible rows are capturable.
+ * Interval between readiness polls while opencode paints its TUI (Issue #1908).
+ *
+ * Half of copilot's second (`COPILOT_POLL_INTERVAL_MS`) because the thing being
+ * waited for lands at ~3 s: a one-second cadence rounds a 3.0 s launch up to
+ * 4 s for no reason, and the poll is one `capture-pane`.
+ */
+exports.OPENCODE_READY_POLL_INTERVAL_MS = 500;
+/**
+ * Readiness poll attempts — 60 * 500 ms = the same 30-second window copilot's
+ * `waitForReady` uses (Issue #1908).
+ *
+ * Sized off the slow end rather than the typical one. On an unloaded machine the
+ * composer is drawn 2.9-3.6 s after the launch keystroke; under the load of six
+ * parallel agents the same launch was measured at 24.1 s. The window has to
+ * cover that, which is precisely what a fixed wait cannot do — see
+ * {@link OpenCodeTool.waitForReady}.
  */
-exports.OPENCODE_PANE_HEIGHT = 200;
+exports.OPENCODE_READY_MAX_ATTEMPTS = 60;
 /**
- * Wait for OpenCode TUI to initialize after launch.
- * Set to 15000ms to accommodate GPU model loading via Ollama.
+ * Scrollback rows to include in a readiness capture.
+ *
+ * `capturePane(name, n)` is `-S -n -E -`, i.e. n rows of history *plus* the whole
+ * visible pane, so every one of the 200 rows in {@link OPENCODE_PANE_HEIGHT} is
+ * in the frame regardless of this number. Matches copilot's 50.
  */
-exports.OPENCODE_INIT_WAIT_MS = 15000;
+const OPENCODE_READY_CAPTURE_LINES = 50;
 /**
  * OpenCode CLI tool implementation
  * Manages OpenCode interactive sessions using tmux
@@ -73,8 +102,6 @@ class OpenCodeTool extends base_1.BaseCLITool {
     id = 'opencode';
     name = 'OpenCode';
     command = 'opencode';
-    // interrupt() is inherited from BaseCLITool (Escape key) [D2-008]
-    // OpenCode TUI supports Escape for interruption ("esc interrupt" display)
     /**
      * Check if OpenCode session is running for a worktree
      */
@@ -89,10 +116,10 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * @param worktreeId - Worktree ID
      * @param worktreePath - Worktree path
      */
-    async startSession(worktreeId, worktreePath, instanceId) {
+    async launchSession(worktreeId, worktreePath, instanceId) {
         const opencodeAvailable = await this.isInstalled();
         if (!opencodeAvailable) {
-            throw new Error('OpenCode is not installed or not in PATH');
+            throw new session_start_error_1.SessionStartUnavailableError(this.name, 'OpenCode is not installed or not in PATH');
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);
@@ -100,7 +127,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
         if (exists) {
             await this.reconcileExistingSession(sessionName, {
                 windowWidth: 80,
-                windowHeight: exports.OPENCODE_PANE_HEIGHT,
+                windowHeight: tmux_pane_config_1.OPENCODE_PANE_HEIGHT,
             });
             // Issue #1763: the pane outlived this process (a CommandMate restart), so
             // the subscription that used to watch it is gone while its server is
@@ -135,7 +162,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 await execFileAsync('tmux', [
                     // Issue #1156: exact-match target so resize never leaks to a prefix-colliding instance
                     'resize-window', '-t', (0, tmux_1.exactTarget)(sessionName),
-                    '-x', '80', '-y', String(exports.OPENCODE_PANE_HEIGHT),
+                    '-x', '80', '-y', String(tmux_pane_config_1.OPENCODE_PANE_HEIGHT),
                 ]);
             }
             catch {
@@ -158,11 +185,19 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 worktreePath,
             });
             await (0, tmux_1.sendKeys)(sessionName, launchCommand, true);
-            // Wait for OpenCode to initialize (GPU model loading via Ollama)
-            await new Promise((resolve) => setTimeout(resolve, exports.OPENCODE_INIT_WAIT_MS));
-            // Issue #1763: subscribe once the server has had the same time to come up
-            // that the TUI has. Health-checked first, so an opencode too old to know
-            // `--port` costs one probe and nothing else.
+            // Issue #1908: poll for opencode's own composer instead of sleeping 15 s.
+            await this.waitForReady(sessionName);
+            // Issue #1763: subscribe once the server is up. Health-checked first, so
+            // an opencode too old to know `--port` costs one probe and nothing else.
+            //
+            // Issue #1908 measured the ordering this depends on: opencode's HTTP
+            // server answers `/global/health` 1.3-1.8 s *before* the composer is
+            // painted, in every run (9.4 s / 11.2 s, 12.2 s / 14.0 s, 22.8 s / 24.1 s
+            // under load). Structurally so — the TUI is a client of its own server
+            // (#1758 §5.1.2). Waiting for the composer therefore reaches this line
+            // with the server already listening, which the fixed 15 s wait did not
+            // guarantee: the 22.8 s run had nothing to probe at 15 s and would have
+            // lost structured events for the whole session.
             await (0, runtime_1.attachOpencodeEventStream)(target);
             logger.info('started-opencode-session:sessionname');
         }
@@ -171,6 +206,71 @@ class OpenCodeTool extends base_1.BaseCLITool {
             throw new Error(`Failed to start OpenCode session: ${errorMessage}`);
         }
     }
+    /**
+     * Wait until opencode has painted something only opencode paints.
+     *
+     * Issue #1908 replaced a fixed 15-second sleep here. That number was written
+     * as "GPU model loading via Ollama", which the measurements do not support:
+     * opencode loads no model at launch (nothing is loaded until the first
+     * request), and the TUI it is waiting for is drawn at 2.9-3.6 s on an idle
+     * machine — so every session paid ~11 s of nothing, inside the HTTP request
+     * that started it. A fixed wait is also wrong in the other direction: with six
+     * agents running, the same launch took 24.1 s, and 15 s was not enough.
+     *
+     * ## What counts as evidence
+     *
+     * `OPENCODE_IDLE_COMPOSER_PATTERN` (Issue #1883) — the `Ask anything...`
+     * placeholder **behind the input box's gutter**. Not reimplemented here on
+     * purpose; it is the same positive-evidence row `status-detector` reads.
+     *
+     * The copilot hazard that #1907 hit does not reach opencode, and this was
+     * checked rather than assumed. Removing copilot's blind sleep exposed the
+     * shell frame to the first poll, and `^[>❯]\s` matches starship / pure /
+     * agnoster prompts, so a shell was read as a ready copilot. opencode's boot
+     * shows the same shell frame — measured, the launch line sits under a `❯`
+     * prompt for the first ~0.7 s — but the gutter anchor cannot match it, and the
+     * frames captured for `tests/fixtures/opencode-launch-boot-11821.ts` confirm
+     * the pattern stays false until the composer exists.
+     *
+     * `OPENCODE_SELECTION_LIST_PATTERN` is the second accepted signal, because the
+     * `Connect a provider` overlay **removes the composer from the frame**
+     * (measured: `Ask anything` occurs zero times while it is up). Without it a
+     * pane parked on that overlay would burn the whole 30-second window. It is
+     * *not* answered — every option on it writes provider credentials into the
+     * operator's config, which is the same line codex's launch draws at its
+     * hooks-review dialog (#1760).
+     *
+     * ## On failure
+     *
+     * Returns false and lets the launch continue, exactly as the sleep did: a
+     * session that is slower than the window is still a session, and the screen
+     * scraper decides for it from there.
+     *
+     * @param sessionName - tmux session name
+     * @returns Whether readiness evidence was seen inside the window
+     */
+    async waitForReady(sessionName) {
+        for (let attempt = 0; attempt < exports.OPENCODE_READY_MAX_ATTEMPTS; attempt++) {
+            try {
+                const output = (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, OPENCODE_READY_CAPTURE_LINES));
+                // Do NOT stripBoxDrawing() this frame: the gutter is the anchor.
+                if (cli_patterns_1.OPENCODE_IDLE_COMPOSER_PATTERN.test(output)) {
+                    logger.info('opencode-composer-detected', { attempt });
+                    return true;
+                }
+                if (cli_patterns_1.OPENCODE_SELECTION_LIST_PATTERN.test(output)) {
+                    logger.info('opencode-overlay-detected', { attempt });
+                    return true;
+                }
+            }
+            catch {
+                // Capture may fail while the pane is still coming up - keep polling
+            }
+            await new Promise((resolve) => setTimeout(resolve, exports.OPENCODE_READY_POLL_INTERVAL_MS));
+        }
+        logger.info('opencode-ready-detection-timeout');
+        return false;
+    }
     /**
      * Send a message to OpenCode interactive session
      * [D1-004] Same pattern as Codex/Gemini/VibeLocal (future Template Method candidate)
@@ -191,6 +291,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 sessionName,
                 message,
                 cliToolId: 'opencode',
+                composer: this.describeComposer(),
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
@@ -206,30 +307,80 @@ class OpenCodeTool extends base_1.BaseCLITool {
      *
      * Shutdown sequence [D1-006, D1-007]:
      * 1. Check if session exists
-     * 2. If exists: send `/exit` TUI command for graceful shutdown
+     * 2. If exists: type `/exit`, then submit it with a separate Enter
      * 3. Wait 2s for OpenCode to process the exit command
      * 4. Re-check session: if still running, force-kill via tmux kill-session
      * 5. If session did not exist: attempt kill anyway (cleanup stale sessions)
      *
+     * Step 2 used to be a single `send-keys '/exit' C-m` — the pre-#1471 shape.
+     * Measured on opencode 1.18.21 (private tmux socket, 200x50): the batched
+     * form does NOT exit. Typing `/` opens the command palette, and the `C-m`
+     * that arrives in the same tmux command is consumed by the palette rather
+     * than submitting, leaving `/exit` in the composer with the palette open —
+     * still up 10.8 s later, 2 runs out of 2. A separate Enter from that state
+     * exits in 0.34 s; typed-then-submitted from a clean composer it exits in
+     * 0.445 / 0.456 / 0.458 s (n=3). Until now nothing noticed, because
+     * `kill-session`'s route reached past this method into tmux (Issue #1905).
+     *
+     * `sendMessageWithSubmitVerification` is deliberately not reused here: it
+     * reads the pane back to confirm the submit and THROWS when it cannot, which
+     * for a command whose success condition is "the TUI is gone" would turn every
+     * successful exit into an error.
+     *
      * @param worktreeId - Worktree ID
      */
     async killSession(worktreeId, instanceId) {
         const sessionName = this.getSessionName(worktreeId, instanceId);
+        const target = (0, runtime_1.opencodeTarget)(worktreeId, instanceId);
+        // Issue #1933 S10: read the port BEFORE the release below drops it, because
+        // the postcondition is about that number and the release is what forgets it.
+        // Null whenever structured events are off or no port was ever allocated, and
+        // then the health probe is skipped entirely — there is nothing to orphan.
+        const assignedPort = (0, ports_1.getAssignedOpencodePort)(target);
         // Issue #1763: stop watching before the pane goes, so the stream is not
         // reconnecting to a server that is being shut down. Also gives the port
         // back — the pane is what held it. Never throws.
-        await (0, runtime_1.releaseOpencodeEventStream)((0, runtime_1.opencodeTarget)(worktreeId, instanceId));
+        await (0, runtime_1.releaseOpencodeEventStream)(target);
         try {
             // Step 1: Check if the tmux session currently exists
             const exists = await (0, tmux_1.hasSession)(sessionName);
             if (exists) {
-                // Step 2: Send /exit command for graceful TUI shutdown [D1-006]
-                await (0, tmux_1.sendKeys)(sessionName, exports.OPENCODE_EXIT_COMMAND, true);
+                // Step 2: Send /exit command for graceful TUI shutdown [D1-006].
+                // Body and Enter are separate tmux commands (see the note above).
+                await (0, tmux_1.sendKeys)(sessionName, exports.OPENCODE_EXIT_COMMAND, false);
+                await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
+                await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
                 // Step 3: Wait for OpenCode to process the exit command
                 await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.OPENCODE_EXIT_WAIT_MS));
-                // Step 4: Check if session still exists; force-kill if needed [D1-007]
-                const stillExists = await (0, tmux_1.hasSession)(sessionName);
-                if (stillExists) {
+                // Step 4: check the postcondition, and force-kill when it is not met
+                // (Issue #1933 S10, 方針書 §13.2). Two things have to be true and only
+                // one of them was ever checked:
+                //
+                //   - the pane is gone. It was not, in the case this branch already
+                //     handled; the reason token is `graceful_exit_timeout`.
+                //   - the port this instance was allocated has stopped answering
+                //     `/global/health`. opencode's TUI *is* an HTTP server once it is
+                //     given `--port` (#1758 §5.1.2), and `ports.ts` hands the number to
+                //     the next instance that asks. A server that outlives its pane
+                //     therefore collects the NEXT instance's subscription, and that
+                //     instance's events are filed against the wrong worktree with no
+                //     error anywhere — `port_orphaned`.
+                //
+                // Both verdicts force-kill; the difference is what gets logged, because
+                // an orphaned port is a number that must not be handed out again yet and
+                // nothing else in the system can see that it happened.
+                const verdict = await (0, graceful_exit_1.verifyGracefulExit)({
+                    sessionAlive: () => (0, tmux_1.hasSession)(sessionName),
+                    portAnswering: assignedPort === null
+                        ? null
+                        : async () => (await (0, client_1.fetchOpencodeHealth)(assignedPort)) !== null,
+                });
+                if (!verdict.ok) {
+                    logger.warn('opencode-graceful-exit-postcondition-failed', {
+                        sessionName,
+                        reason: verdict.reason,
+                        ...(assignedPort !== null ? { port: assignedPort } : {}),
+                    });
                     await (0, tmux_1.killSession)(sessionName);
                 }
             }
@@ -246,5 +397,57 @@ class OpenCodeTool extends base_1.BaseCLITool {
             throw error;
         }
     }
+    /**
+     * Abort the running turn: Escape, wait, Escape (Issue #1894).
+     *
+     * `BaseCLITool.interrupt()` sends ONE Escape, and on opencode 1.18 that
+     * aborts nothing. The first press is a confirmation prompt drawn in the
+     * footer -- `esc interrupt` becomes `esc again to interrupt` -- and only a
+     * second press while that label is up ends the turn. Measured on opencode
+     * 1.18.21 at the production 80x200 geometry, in a private tmux socket:
+     *
+     * - one Escape 4-6 s into a generation: the label flips, the generation
+     *   continues, and the turn reaches a natural
+     *   `▣  Build · GPT-5.6 Luna · 11.3s` / `· 16.3s` / `· 19.0s`. 3 runs, 3
+     *   completions, 0 aborts. The default `interrupt()` has therefore never
+     *   interrupted an opencode session, which is what {@link OpenCodeTool} used
+     *   to claim it did [D2-008].
+     * - two Escapes: the turn stops mid-sentence and the transcript marker reads
+     *   `▣  Build · GPT-5.6 Luna · interrupted`. Confirmed twice -- once from a
+     *   shell harness (594 ms apart) and once by calling THIS method against a
+     *   live session, which took 317 ms end to end.
+     *
+     * The deadline is five seconds -- the label was sampled up from 0.31 s to
+     * 4.71 s and reverted by 5.07 s -- and the wait is
+     * {@link OPENCODE_INTERRUPT_SECOND_ESCAPE_DELAY_MS}, which documents both
+     * directions of that budget.
+     *
+     * `sendSpecialKey` twice with an awaited wait between, rather than
+     * `sendSpecialKeys(name, ['Escape', 'Escape'])`: that helper's own
+     * `SPECIAL_KEY_DELAY_MS` is a shared constant tuned for menu navigation, and
+     * this gap is sized against a measured five-second deadline that has nothing
+     * to do with menus. Keeping them separate means a future change to one cannot
+     * silently move the other outside the window.
+     *
+     * Note that a turn ended this way leaves NO duration-carrying completion
+     * marker on the pane (`· interrupted` is not `· 11.3s`), so
+     * `OPENCODE_TURN_COMPLETE_PATTERN` does not match it and the session reaches
+     * `ready` through the staleness fallback rather than through positive
+     * evidence. That is the same treatment Issue #1893 deliberately gave an
+     * aborted turn, and it is left alone here.
+     *
+     * @param worktreeId - Worktree ID
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     */
+    async interrupt(worktreeId, instanceId) {
+        const sessionName = this.getSessionName(worktreeId, instanceId);
+        await (0, tmux_1.sendSpecialKey)(sessionName, 'Escape');
+        await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.OPENCODE_INTERRUPT_SECOND_ESCAPE_DELAY_MS));
+        await (0, tmux_1.sendSpecialKey)(sessionName, 'Escape');
+        // Issue #405: the pane changed (the turn is aborted), so the cached capture
+        // is stale. `killSession` / `sendMessage` do the same after their keystrokes.
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+        logger.info('opencode-interrupt-sent');
+    }
 }
 exports.OpenCodeTool = OpenCodeTool;

package/dist/server/src/lib/cli-tools/session-name.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * tmux session naming for CLI tool instances.
+ *
+ * ## Issue #1984: なぜ独立したモジュールなのか
+ *
+ * セッション名の決め方は `BaseCLITool.getSessionName()` の中にあり、7 つの具象ツールは
+ * どれもこれを override していない（実装は base の 1 本きり）。にもかかわらず
+ * 「名前が欲しいだけ」の呼び出し側は `CLIToolManager.getInstance().getTool(id)` を
+ * 経由するしかなく、そのために 7 ツールの実装（と、そこから伸びる tmux / child_process
+ * / composer spec のグラフ）を**モジュールロード時に**引かされていた。
+ *
+ * `ws-server.ts` がまさにそれで、`getTool()` を呼ぶのは
+ * ハンドラの中（terminal subscribe / `migrateWorktreeRooms`）だけなのに、
+ * `@/lib/cli-tools/manager` を静的 import していた。実測でこの 1 辺が
+ * `import('../../lib/ws-server')` の 458ms のうち 234ms を占めていた。
+ *
+ * 規則そのものは 1 箇所に保つ — `BaseCLITool.getSessionName()` はこの関数へ委譲する。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSessionName = resolveSessionName;
+const types_1 = require("./types");
+const validation_1 = require("./validation");
+/**
+ * Resolve the tmux session name for a (worktree, CLI tool, instance) triple.
+ *
+ * Format (Issue #868):
+ * - Primary instance (`instanceId` omitted or `=== cliToolId`):
+ *   `mcbd-{cli_tool_id}-{worktree_id}` — the backward-compatible anchor
+ * - Additional instance: `mcbd-{cli_tool_id}-{worktree_id}-{suffix}`
+ *
+ * T2.3 (MF4-001): the result is validated to keep shell metacharacters out of
+ * the tmux command line.
+ *
+ * @param cliToolId - CLI tool ID
+ * @param worktreeId - Worktree ID
+ * @param instanceId - Agent instance ID (defaults to the primary instance)
+ * @returns Session name
+ * @throws Error if the resulting session name is invalid
+ *
+ * @example
+ * ```typescript
+ * resolveSessionName('claude', 'wt-1');            // 'mcbd-claude-wt-1'
+ * resolveSessionName('claude', 'wt-1', 'claude-2'); // 'mcbd-claude-wt-1-2'
+ * ```
+ */
+function resolveSessionName(cliToolId, worktreeId, instanceId) {
+    const base = `mcbd-${cliToolId}-${worktreeId}`;
+    if (!instanceId || instanceId === cliToolId) {
+        (0, validation_1.validateSessionName)(base);
+        return base;
+    }
+    const suffix = (0, types_1.deriveSessionSuffix)(instanceId, cliToolId);
+    const sessionName = suffix ? `${base}-${suffix}` : base;
+    (0, validation_1.validateSessionName)(sessionName);
+    return sessionName;
+}