ticlawk 0.1.12-dev.0

package/src/runtimes/opencode/session.mjs

@@ -0,0 +1,413 @@
+/**
+ * opencode local session helpers.
+ *
+ * opencode (https://opencode.ai) exposes a one-shot CLI mode via
+ * `opencode run [--session <id>] [--format json] <message>`. With
+ * `--format json` it emits newline-delimited JSON events on stdout
+ * during the turn — these carry the live `sessionID`, partial text,
+ * tool calls, and turn boundaries. The process exits when the turn
+ * finishes.
+ *
+ * Sessions are persisted under `~/.local/share/opencode/` as per-key
+ * JSON files (not append-only JSONL like Claude Code / Codex). For
+ * discovery we shell out to `opencode session list --format json`
+ * rather than walking the storage layout, since the list subcommand
+ * is the canonical interface and is robust to opencode's internal
+ * storage changes.
+ *
+ * NOTE: Verified against opencode 1.14.x:
+ *   step_start  -> { type, sessionID, part: { type: 'step-start', ... } }
+ *   text        -> { type, sessionID, part: { type: 'text', text: '...' } }
+ *   step_finish -> { type, sessionID, part: { type: 'step-finish', reason, tokens, cost } }
+ *   error       -> { type, sessionID, message?, error? } (shape inferred)
+ * The text payload is at `event.part.text` and may arrive as a single
+ * batched event for short replies or as multiple events as the model
+ * streams. We treat each `text` event's payload as a delta and
+ * concatenate; if a future opencode version emits cumulative text we
+ * will need to switch to "last text wins".
+ */
+
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { debugLog, debugError } from '../../core/logger.mjs';
+import { buildRuntimeEnv } from '../../core/runtime-env.mjs';
+import { getRuntimeExecutableConfig } from '../../core/config.mjs';
+import { isExecutablePath, resolveExecutable } from '../../core/executables.mjs';
+
+export const OPENCODE_DATA_DIR = process.env.OPENCODE_DATA_DIR
+  || `${process.env.XDG_DATA_HOME || `${homedir()}/.local/share`}/opencode`;
+export const OPENCODE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_OPENCODE_RUN_TIMEOUT_MS = 7200 * 1000;
+export const DEFAULT_OPENCODE_COMMAND = 'opencode';
+
+export function resolveOpenCodePath(preferredPath = null) {
+  return resolveExecutable({
+    command: DEFAULT_OPENCODE_COMMAND,
+    preferredPath,
+    configuredPath: getRuntimeExecutableConfig('opencode'),
+    envKey: 'OPENCODE_BIN',
+  });
+}
+
+export function requireOpenCodePath(preferredPath = null) {
+  const requested = String(preferredPath || '').trim();
+  if (requested && requested.includes('/') && !isExecutablePath(requested)) {
+    throw new Error(`opencode binary is no longer available at: ${requested}. Reconnect this opencode agent or set OPENCODE_BIN / \`ticlawk config set runtimes.opencode.path <path>\`.`);
+  }
+  const opencodePath = resolveOpenCodePath(preferredPath);
+  if (opencodePath) return opencodePath;
+  throw new Error('opencode CLI not found. Install opencode, ensure it is on PATH, or set OPENCODE_BIN / `ticlawk config set runtimes.opencode.path <path>`.');
+}
+
+export function getOpenCodeRuntimeHealth(preferredPath = null) {
+  const opencodePath = resolveOpenCodePath(preferredPath);
+  return {
+    available: Boolean(opencodePath),
+    path: opencodePath,
+    // opencode's npm shim can hang and leave the native binary orphaned when
+    // called with --version. Health must stay side-effect free and fast.
+    version: null,
+  };
+}
+
+function buildOpenCodeError(message, info) {
+  const wrapped = new Error(message);
+  wrapped.info = info;
+  return wrapped;
+}
+
+function extractEventText(event) {
+  if (!event || typeof event !== 'object') return '';
+  // Verified shape from `opencode run --format json` output (opencode 1.14.x):
+  //   { type: 'text', sessionID, part: { type: 'text', text: '...' } }
+  // Fall through to flatter shapes for forward-compat.
+  const candidate = event.part?.text ?? event.text ?? event.delta ?? event.content;
+  return typeof candidate === 'string' ? candidate : '';
+}
+
+function extractSessionId(event) {
+  if (!event || typeof event !== 'object') return null;
+  return event.sessionID || event.session_id || event.sessionId || null;
+}
+
+function extractErrorMessage(event) {
+  if (!event || typeof event !== 'object') return null;
+  // Verified shape from opencode 1.14.x: { type: 'error', error: { name, data: { message, statusCode, ... } } }
+  return event.error?.data?.message
+    || event.error?.message
+    || event.message
+    || (typeof event.error === 'string' ? event.error : null)
+    || null;
+}
+
+/**
+ * Enumerate opencode sessions for a given project directory.
+ *
+ * `opencode session list --format json` is project-scoped — it only
+ * returns sessions when run from inside the project's directory. Without
+ * a cwd we cannot enumerate, so callers must always pass one. opencode
+ * 1.14.x stores sessions in a SQLite DB at `~/.local/share/opencode/`
+ * which is not stable to walk directly.
+ */
+export const DEFAULT_OPENCODE_DISCOVER_TIMEOUT_MS = 15000;
+
+export async function discoverOpenCodeSessions(cwd, opts = {}) {
+  if (!cwd) return [];
+  const timeoutMs = Number(opts.timeoutMs || process.env.OPENCODE_DISCOVER_TIMEOUT_MS || DEFAULT_OPENCODE_DISCOVER_TIMEOUT_MS);
+  return new Promise((resolve) => {
+    const opencodeCommand = requireOpenCodePath(opts.opencodePath || opts.runtimePath);
+    const child = spawn(opencodeCommand, ['session', 'list', '--format', 'json'], {
+      cwd,
+      env: buildRuntimeEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    let stdout = '';
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      resolve(value);
+    };
+    // `opencode session list` reads the SQLite DB — if the DB is locked
+    // by another opencode process or the CLI itself hangs we'd leave
+    // `ticlawk connect --session-id ...` blocking forever. Kill
+    // and return [] after a bounded wait so the connect call surfaces
+    // a clean "session not found" path instead.
+    const timeout = timeoutMs > 0 ? setTimeout(() => {
+      debugError('opencode', 'discover.timeout', { pid: child.pid, cwd, timeoutMs });
+      try { child.kill('SIGTERM'); } catch {}
+      settle([]);
+    }, timeoutMs) : null;
+    timeout?.unref?.();
+    child.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });
+    child.on('error', () => settle([]));
+    child.on('exit', (code) => {
+      if (code !== 0) { settle([]); return; }
+      try {
+        const parsed = JSON.parse(stdout);
+        if (!Array.isArray(parsed)) { settle([]); return; }
+        settle(parsed
+          .map((entry) => {
+            const sessionId = entry?.id || entry?.sessionID || entry?.sessionId;
+            if (!sessionId) return null;
+            return {
+              sessionId: String(sessionId),
+              cwd: entry?.directory || entry?.cwd || cwd,
+              title: entry?.title || null,
+              raw: entry,
+            };
+          })
+          .filter(Boolean));
+      } catch {
+        settle([]);
+      }
+    });
+  });
+}
+
+export async function findOpenCodeSessionById(sessionId, cwd, opts = {}) {
+  if (!sessionId || !cwd) return null;
+  const sessions = await discoverOpenCodeSessions(cwd, opts);
+  return sessions.find((entry) => entry.sessionId === sessionId) || null;
+}
+
+function buildOpenCodeRunArgs({ sessionId, message, files = [] }) {
+  const base = ['run', '--format', 'json', '--dangerously-skip-permissions'];
+  if (sessionId) {
+    base.push('--session', sessionId);
+  }
+  for (const file of files) {
+    if (typeof file === 'string' && file) {
+      base.push('--file', file);
+    }
+  }
+  // `--` ends option parsing. Without it, `--file` (array type) would
+  // greedily consume the message string as another file path and fail
+  // with "File not found: <message text>". Always use the delimiter so
+  // adding/removing files doesn't change the parsing semantics.
+  base.push('--', message);
+  return base;
+}
+
+/**
+ * Spawn `opencode run` and resolve with the final result.
+ *
+ * If `onEvent` is provided it is invoked for each parsed event during
+ * the turn — `{ type: 'turn.started', sessionId }`,
+ * `{ type: 'message.delta', sessionId, text }`, etc. — so callers can
+ * forward typing indicators / partial text to the chat client.
+ *
+ * Resolves with `{ sessionId, cwd, text, durationMs }` on success.
+ * Rejects with an Error whose `.info` carries `{ ok: false, kind, ... }`
+ * matching the shape `reportSubprocessFailure` expects.
+ */
+export function runOpenCodePrompt({
+  sessionId,
+  cwd,
+  message,
+  files = [],
+  opencodePath = null,
+  timeoutMs = Number(process.env.OPENCODE_RUN_TIMEOUT_MS || DEFAULT_OPENCODE_RUN_TIMEOUT_MS),
+  onEvent,
+}) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const opencodeCommand = requireOpenCodePath(opencodePath);
+    const child = spawn(opencodeCommand, buildOpenCodeRunArgs({ sessionId, message, files }), {
+      cwd,
+      env: buildRuntimeEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    debugLog('opencode', 'run.spawned', {
+      pid: child.pid,
+      cwd,
+      resume: Boolean(sessionId),
+      timeoutMs,
+      textLength: message.length,
+      fileCount: Array.isArray(files) ? files.length : 0,
+    });
+
+    let activeSessionId = sessionId || null;
+    let finalText = '';
+    let buffer = '';
+    let stdoutTail = '';
+    let lastError = null;
+    let settled = false;
+    let turnStartedEmitted = false;
+    let eventChain = Promise.resolve();
+
+    const emit = (event) => {
+      if (typeof onEvent !== 'function') return;
+      eventChain = eventChain.then(() => onEvent(event)).catch(() => {});
+    };
+
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      eventChain.catch(() => {}).finally(() => fn(value));
+    };
+
+    const handleEvent = (event) => {
+      const eventSessionId = extractSessionId(event);
+      if (eventSessionId) activeSessionId = eventSessionId;
+
+      if (!turnStartedEmitted && (event?.type === 'step_start' || event?.type === 'turn.started')) {
+        turnStartedEmitted = true;
+        emit({ type: 'turn.started', sessionId: activeSessionId });
+      }
+
+      if (event?.type === 'text' || event?.type === 'reasoning') {
+        const delta = extractEventText(event);
+        if (delta) {
+          finalText += delta;
+          emit({ type: 'message.delta', sessionId: activeSessionId, text: delta });
+        }
+      }
+
+      if (event?.type === 'error') {
+        lastError = extractErrorMessage(event) || 'opencode error';
+      }
+    };
+
+    child.stdout.on('data', (chunk) => {
+      buffer += chunk.toString('utf8');
+      stdoutTail = (stdoutTail + chunk.toString('utf8')).slice(-4000);
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let event;
+        try { event = JSON.parse(trimmed); } catch { continue; }
+        handleEvent(event);
+      }
+    });
+
+    let timeout = null;
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        try { child.kill('SIGTERM'); } catch {}
+        settle(reject, buildOpenCodeError('opencode run timed out', {
+          ok: false,
+          code: null,
+          signal: 'SIGTERM',
+          durationMs: Date.now() - startedAt,
+          kind: 'killed',
+          errorMessage: 'opencode run timed out',
+        }));
+      }, timeoutMs);
+      timeout.unref();
+    }
+
+    child.on('error', (err) => {
+      debugError('opencode', 'run.spawn-failed', {
+        pid: child.pid,
+        durationMs: Date.now() - startedAt,
+        error: err.message,
+      });
+      settle(reject, buildOpenCodeError(err.message || 'opencode spawn failed', {
+        ok: false,
+        code: null,
+        signal: null,
+        durationMs: Date.now() - startedAt,
+        kind: 'spawn-failed',
+        error: err.message,
+      }));
+    });
+
+    child.on('exit', (code, signal) => {
+      // opencode's stdout chunk handler keeps any incomplete final line
+      // in `buffer` waiting for the next \n. If the process exits before
+      // the last line is terminated we lose that event — which can be
+      // the only `text` (so we'd resolve with empty text) or the only
+      // event carrying `sessionID` (so we'd reject with "sessionID
+      // missing"). Flush the remaining buffer through handleEvent
+      // before deciding the outcome.
+      if (buffer) {
+        const trimmed = buffer.trim();
+        buffer = '';
+        if (trimmed) {
+          try {
+            handleEvent(JSON.parse(trimmed));
+          } catch {
+            // malformed final fragment — fall through to normal exit handling
+          }
+        }
+      }
+      const durationMs = Date.now() - startedAt;
+      if (signal) {
+        settle(reject, buildOpenCodeError(lastError || `opencode killed by ${signal}`, {
+          ok: false,
+          code: null,
+          signal,
+          durationMs,
+          kind: 'killed',
+          errorMessage: lastError,
+        }));
+        return;
+      }
+      if (code !== 0) {
+        settle(reject, buildOpenCodeError(lastError || `opencode exited with code ${code}`, {
+          ok: false,
+          code,
+          signal: null,
+          durationMs,
+          kind: 'exit-error',
+          errorMessage: lastError || stdoutTail || null,
+        }));
+        return;
+      }
+      if (!activeSessionId) {
+        settle(reject, buildOpenCodeError('opencode sessionID missing from output', {
+          ok: false,
+          code: 0,
+          signal: null,
+          durationMs,
+          kind: 'invalid-output',
+          errorMessage: 'opencode sessionID missing from output',
+        }));
+        return;
+      }
+      // opencode exits with code 0 even when an `error` event was emitted
+      // mid-run (e.g. provider 4xx). Treat any captured error as a turn
+      // failure rather than resolving with the empty text it accumulated.
+      if (lastError && !finalText) {
+        settle(reject, buildOpenCodeError(lastError, {
+          ok: false,
+          code: 0,
+          signal: null,
+          durationMs,
+          kind: 'gateway-error',
+          errorMessage: lastError,
+        }));
+        return;
+      }
+      settle(resolve, {
+        sessionId: activeSessionId,
+        cwd,
+        text: finalText,
+        durationMs,
+      });
+    });
+  });
+}
+
+export function streamOpenCodePrompt(opts) {
+  return runOpenCodePrompt(opts);
+}
+
+/**
+ * Create a fresh opencode session by running with no `--session`. The
+ * sessionID is captured from the first event that carries one.
+ */
+export async function createOpenCodeSession({ cwd, message, opencodePath = null, timeoutMs }) {
+  const result = await runOpenCodePrompt({ sessionId: null, cwd, message, opencodePath, timeoutMs });
+  return {
+    sessionId: result.sessionId,
+    cwd: result.cwd || cwd,
+    text: result.text,
+  };
+}

package/src/runtimes/pi/index.mjs

@@ -0,0 +1,287 @@
+/**
+ * pi runtime entry point.
+ *
+ * Wraps the pi CLI RPC mode and exposes the ticlawk runtime contract.
+ */
+
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import {
+  buildPiImagesFromInbound,
+  discoverPiSessions,
+  findPiSessionById,
+  getPiRuntimeHealth,
+  PI_MAX_AGE_MS,
+  PI_SESSIONS_DIR,
+  requirePiPath,
+  runPiPrompt,
+} from './session.mjs';
+import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
+import {
+  shouldStreamRuntime,
+  createDeltaAggregator,
+  sendAdapterMessage,
+  sendResult,
+  reportSubprocessFailure,
+  terminalRuntimeFailure,
+  updateBindingRuntimeMeta,
+} from '../../core/runtime-support.mjs';
+
+export const piRuntime = {
+  name: 'pi',
+
+  runTurn({ sessionId, cwd, piPath }, text, opts = {}) {
+    return runPiPrompt({
+      sessionId,
+      cwd,
+      message: text,
+      images: opts.images,
+      piPath,
+      timeoutMs: opts.timeoutMs,
+    });
+  },
+
+  runTurnStream({ sessionId, cwd, piPath }, text, opts = {}) {
+    return runPiPrompt({
+      sessionId,
+      cwd,
+      message: text,
+      images: opts.images,
+      piPath,
+      timeoutMs: opts.timeoutMs,
+      onEvent: opts.onEvent,
+    });
+  },
+
+  async listLocalSessions(cwd = null) {
+    return discoverPiSessions(cwd);
+  },
+
+  async resolveBinding(payload) {
+    const requestedCwd = String(payload?.cwd || payload?.workdir || payload?.projectDir || '').trim();
+    const piPath = requirePiPath(payload?.piPath || payload?.runtimePath);
+    const piVersion = getPiRuntimeHealth(piPath).version;
+
+    if (payload?.sessionId) {
+      const session = findPiSessionById(payload.sessionId, requestedCwd || null);
+      if (!session) {
+        throw new Error(requestedCwd
+          ? `pi session ${payload.sessionId} not found in ${requestedCwd}`
+          : `pi session ${payload.sessionId} not found locally`);
+      }
+      return {
+        runtime: this.name,
+        displayName: payload.name || basename(session.cwd || requestedCwd) || 'pi',
+        runtimeMeta: {
+          sessionId: session.sessionId,
+          workdir: session.cwd || requestedCwd,
+          cwd: session.cwd || requestedCwd,
+          path: session.path || null,
+          runtimePath: piPath,
+          piPath,
+          piVersion,
+          rotatePending: false,
+        },
+      };
+    }
+
+    if (!requestedCwd) {
+      throw new Error('cwd or sessionId is required for pi binding');
+    }
+    if (!existsSync(requestedCwd)) {
+      throw new Error(`pi cwd not found locally: ${requestedCwd}`);
+    }
+
+    return {
+      runtime: this.name,
+      displayName: payload.name || basename(requestedCwd) || 'pi',
+      runtimeMeta: {
+        sessionId: null,
+        workdir: requestedCwd,
+        cwd: requestedCwd,
+        path: null,
+        runtimePath: piPath,
+        piPath,
+        piVersion,
+        rotatePending: false,
+      },
+    };
+  },
+
+  async health(meta = {}) {
+    return getPiRuntimeHealth(meta?.piPath || meta?.runtimePath);
+  },
+
+  async deliverTurn(inbound, ctx) {
+    const binding = ctx.getBinding(inbound.bindingId);
+    if (!binding) return false;
+    const adapter = ctx.adapter;
+    const meta = binding.runtimeMeta || {};
+
+    if (!meta.cwd || !existsSync(meta.cwd)) {
+      await sendAdapterMessage(adapter, binding, {
+        type: 'assistant',
+        text: `⚠️ pi cwd not found: ${meta.cwd || '(missing)'}`,
+        media: [],
+        replyToMessageId: inbound.messageId || null,
+      });
+      return true;
+    }
+
+    let images = [];
+    let message = inbound.text || '';
+    if (inbound.action === 'image') {
+      images = await buildPiImagesFromInbound(inbound);
+      const captionText = (inbound.text || '').trim();
+      if (images.length === 0 && !captionText) {
+        await sendAdapterMessage(adapter, binding, {
+          type: 'assistant',
+          text: '⚠️ Image attached, but I could not access the image data and there is no caption to fall back on. Try sending the image again, or include a text caption.',
+          media: [],
+          replyToMessageId: inbound.messageId || null,
+        });
+        return true;
+      }
+      if (images.length === 0 && captionText) {
+        await sendAdapterMessage(adapter, binding, {
+          type: 'assistant',
+          text: '⚠️ Could not access the attached image data; acting on the caption text only.',
+          media: [],
+          replyToMessageId: inbound.messageId || null,
+        });
+      }
+      message = captionText || 'Please analyze the attached image(s).';
+    }
+
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+    const deltaAggregator = createDeltaAggregator({
+      flushDelta: async ({ text, sessionId, cwd }) => {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || meta.sessionId || binding.id,
+          cwd: cwd || meta.cwd,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'worker.message.delta',
+            worker_event_name: 'worker.message.delta',
+            delta: text,
+          },
+          logger: ctx.logger,
+        });
+      },
+    });
+
+    try {
+      const runtimePiPath = requirePiPath(meta.piPath || meta.runtimePath);
+      const runtimePiVersion = getPiRuntimeHealth(runtimePiPath).version || meta.piVersion || null;
+      const result = shouldStreamRuntime(this.name, this)
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, piPath: runtimePiPath }, message, {
+            images,
+            onEvent: async (event) => {
+              if (event?.type === 'turn.started') {
+                await emitWorkerEvent({
+                  adapter,
+                  binding,
+                  agent: this.name,
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  cwd: meta.cwd,
+                  replyToMessageId: inbound.messageId || null,
+                  event: {
+                    hook_event_name: 'worker.turn.start',
+                    worker_event_name: 'worker.turn.start',
+                  },
+                  logger: ctx.logger,
+                });
+              } else if (event?.type === 'message.delta' && event.text) {
+                deltaAggregator.push(event.text, {
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  cwd: meta.cwd,
+                });
+              }
+            },
+          })
+        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: meta.cwd, piPath: runtimePiPath }, message, { images });
+
+      await deltaAggregator.flush();
+      const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
+        sessionId: result?.sessionId || meta.sessionId,
+        cwd: result?.cwd || meta.cwd,
+        path: result?.path || meta.path || null,
+        runtimePath: runtimePiPath,
+        piPath: runtimePiPath,
+        piVersion: runtimePiVersion,
+        rotatePending: false,
+        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
+      }, { status: 'connected' });
+      await sendResult(adapter, nextBinding, inbound, result);
+      await emitWorkerEvent({
+        adapter,
+        binding: nextBinding,
+        agent: this.name,
+        sessionId: result?.sessionId || meta.sessionId || binding.id,
+        cwd: result?.cwd || meta.cwd,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'Stop',
+          worker_event_name: 'worker.turn.complete',
+        },
+        logger: ctx.logger,
+      });
+      return true;
+    } catch (err) {
+      await deltaAggregator.flush().catch(() => {});
+      await emitWorkerEvent({
+        adapter,
+        binding,
+        agent: this.name,
+        sessionId: meta.sessionId || binding.id,
+        cwd: meta.cwd,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'worker.turn.error',
+          worker_event_name: 'worker.turn.error',
+          error: err?.message || 'pi failed',
+        },
+        logger: ctx.logger,
+      });
+      await reportSubprocessFailure({
+        adapter,
+        binding,
+        inbound,
+        runtimeName: 'pi',
+        info: err?.info || {
+          ok: false,
+          kind: 'exit-error',
+          errorMessage: err?.message || 'pi failed',
+          durationMs: 0,
+        },
+      });
+      return terminalRuntimeFailure(err?.message || 'pi failed');
+    }
+  },
+
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    await emitWorkerEvent({
+      adapter: ctx.adapter,
+      binding,
+      agent: this.name,
+      sessionId: meta.sessionId || binding.id,
+      cwd: meta.cwd || '',
+      event: {
+        hook_event_name: 'Stop',
+        worker_event_name: 'worker.turn.complete',
+        reason: 'connector.restart.reconcile',
+      },
+      logger: ctx.logger,
+    });
+    return 1;
+  },
+
+  sessionsDir: PI_SESSIONS_DIR,
+  maxAgeMs: PI_MAX_AGE_MS,
+};
+
+export default piRuntime;