pi-lxmf 0.1.0

package/src/commands.js

@@ -0,0 +1,288 @@
+/**
+ * @file commands.js
+ *
+ * The bridge-command layer for chat messages (SPEC §7): parsing, the
+ * command table, model matching, and the formatters used by command
+ * replies. Commands are executed by the bridge with a `ctx` bundling the
+ * `PiRpcClient` and bridge state; each implementation returns the reply
+ * text (or a `{ text, shutdown }` action).
+ */
+
+import { basename } from "node:path";
+import { formatDuration, formatTokens } from "./text.js";
+
+/**
+ * Parses bridge-command syntax out of a chat message.
+ *
+ * - `/name args…` and `!name args…` are commands (name lowercased).
+ * - A bare `!` is the quick interrupt (name `""`).
+ * - Anything else is not a command (a prompt).
+ *
+ * @param {string} text
+ * @returns {{name: string, args: string}|null}
+ */
+export function parseCommand(text) {
+  const trimmed = text.trim();
+  if (trimmed === "!") return { name: "", args: "" };
+  if (!trimmed.startsWith("/") && !trimmed.startsWith("!")) return null;
+  const rest = trimmed.slice(1);
+  if (rest.length === 0) return null;
+  const match = rest.match(/^(\S+)\s*([\s\S]*)$/);
+  if (!match) return null;
+  return { name: match[1].toLowerCase(), args: match[2].trim() };
+}
+
+/**
+ * Fuzzy-matches a model query against the available models: exact
+ * `provider/id` (case-insensitive) first, then substring on `provider/id`,
+ * then substring on the display name.
+ *
+ * @param {Array<{id?: string, provider?: string, name?: string}>} models
+ * @param {string} query
+ * @returns {{id?: string, provider?: string, name?: string}|null}
+ */
+export function matchModel(models, query) {
+  const q = query.trim().toLowerCase();
+  if (!q || !Array.isArray(models) || models.length === 0) return null;
+  const full = models.find((m) => `${m.provider}/${m.id}`.toLowerCase() === q);
+  if (full) return full;
+  const byId = models.find((m) =>
+    `${m.provider}/${m.id}`.toLowerCase().includes(q),
+  );
+  if (byId) return byId;
+  return models.find((m) => (m.name ?? "").toLowerCase().includes(q)) ?? null;
+}
+
+/**
+ * Formats the model list with the current model marked.
+ *
+ * @param {Array<{id?: string, provider?: string, name?: string}>} models
+ * @param {{provider?: string, id?: string}|null} current
+ * @returns {string}
+ */
+export function formatModelList(models, current) {
+  const currentKey =
+    current?.provider && current?.id
+      ? `${current.provider}/${current.id}`.toLowerCase()
+      : null;
+  const lines = models.map((m) => {
+    const key = `${m.provider}/${m.id}`;
+    const marker = key.toLowerCase() === currentKey ? " ← current" : "";
+    const name = m.name && m.name !== m.id ? ` — ${m.name}` : "";
+    return `${key}${name}${marker}`;
+  });
+  return [`Models (${models.length}):`, ...lines].join("\n");
+}
+
+/**
+ * Formats `get_state` + bridge info as the `/status` reply.
+ *
+ * @param {any} state - `get_state` data.
+ * @param {object} bridgeInfo
+ * @param {string} bridgeInfo.identityHash - This node's Reticulum identity hash.
+ * @param {string} bridgeInfo.deliveryHash - This node's `lxmf.delivery` destination hash.
+ * @param {string|null} bridgeInfo.owner - Paired owner hash.
+ * @param {number} bridgeInfo.uptimeMs
+ * @returns {string}
+ */
+export function formatStatus(state, bridgeInfo) {
+  const model = state?.model
+    ? `${state.model.provider}/${state.model.id}`
+    : "(none)";
+  const session = state?.sessionFile
+    ? `${state.sessionName ?? "(unnamed)"} · ${basename(state.sessionFile)}`
+    : "(none)";
+  return [
+    `model: ${model}`,
+    `thinking: ${state?.thinkingLevel ?? "off"}`,
+    `busy: ${state?.isStreaming ? "yes" : "no"}`,
+    `session: ${session}`,
+    `node: ${bridgeInfo.identityHash}`,
+    `lxmf: ${bridgeInfo.deliveryHash}`,
+    `owner (identity): ${bridgeInfo.owner ?? "?"}`,
+    `uptime: ${formatDuration(bridgeInfo.uptimeMs)}`,
+  ].join("\n");
+}
+
+/**
+ * Formats `get_session_stats` data as the `/session` reply.
+ *
+ * @param {any} stats
+ * @returns {string}
+ */
+export function formatSessionStats(stats) {
+  if (!stats) return "No session stats available.";
+  return [
+    `messages: ${stats.userMessages ?? 0} in / ${stats.assistantMessages ?? 0} out` +
+      ` (${stats.toolCalls ?? 0} tool calls)`,
+    `usage: ${formatTokens(stats)}`,
+    `session: ${stats.sessionId ?? "?"}`,
+  ].join("\n");
+}
+
+/**
+ * @typedef {object} CommandContext
+ * @property {import("./rpc.js").PiRpcClient} rpc
+ * @property {() => string} getTitle - Reply title (session name or node name).
+ * @property {() => {identityHash: string, deliveryHash: string, owner: string, uptimeMs: number}} getBridgeInfo
+ */
+
+/**
+ * @typedef {object} CommandResult
+ * @property {string} [text] - Reply text; omitted when there is nothing to say.
+ * @property {boolean} [shutdown] - Shut the bridge down (after replying).
+ */
+
+/**
+ * The bridge command table. `run` returns the reply text or a result object.
+ *
+ * @type {Record<string, {description: string, run: (ctx: CommandContext, args: string) => Promise<string|CommandResult|void>}>}
+ */
+export const bridgeCommands = {
+  help: {
+    description: "List bridge commands",
+    async run(ctx) {
+      const mine = Object.entries(bridgeCommands).map(
+        ([name, def]) => `/${name} — ${def.description}`,
+      );
+      /** @type {string[]} */
+      let piCommands = [];
+      try {
+        const commands = await ctx.rpc.getCommands();
+        piCommands = commands.map(
+          (/** @type {{name?: string, description?: string}} */ c) =>
+            `/${c.name}${c.description ? ` — ${c.description}` : ""}`,
+        );
+      } catch {
+        /* pi unavailable: bridge commands still listed */
+      }
+      const parts = [
+        ["Bridge commands:", ...mine, "! (bare) — quick interrupt"].join("\n"),
+      ];
+      if (piCommands.length > 0) {
+        parts.push(
+          ["Pi commands (sent as prompts):", ...piCommands].join("\n"),
+        );
+      }
+      parts.push("Anything else is sent to the agent as a prompt.");
+      return parts.join("\n\n");
+    },
+  },
+
+  status: {
+    description: "Show model, session and bridge status",
+    async run(ctx) {
+      const state = await ctx.rpc.getState();
+      return formatStatus(state, ctx.getBridgeInfo());
+    },
+  },
+
+  session: {
+    description: "Show session stats (messages, tokens, cost)",
+    async run(ctx) {
+      return formatSessionStats(await ctx.rpc.getSessionStats());
+    },
+  },
+
+  new: {
+    description: "Start a fresh Pi session",
+    async run(ctx) {
+      const data = await ctx.rpc.newSession();
+      if (data?.cancelled) return "New session was cancelled by an extension.";
+      return "New session started.";
+    },
+  },
+
+  name: {
+    description: "Show or set the session display name",
+    async run(ctx, args) {
+      if (!args) {
+        const state = await ctx.rpc.getState();
+        return `Session name: ${state?.sessionName ?? "(none)"}`;
+      }
+      await ctx.rpc.setSessionName(args);
+      return `Session name set to: ${args}`;
+    },
+  },
+
+  compact: {
+    description: "Compact the conversation context",
+    async run(ctx, args) {
+      const result = await ctx.rpc.compact(args || undefined);
+      const before = result?.tokensBefore;
+      const after = result?.estimatedTokensAfter;
+      if (typeof before === "number" && typeof after === "number") {
+        return `Compacted: ~${before.toLocaleString()} → ~${after.toLocaleString()} tokens.`;
+      }
+      return "Compacted.";
+    },
+  },
+
+  model: {
+    description: "List models, or switch: /model <provider/id or search>",
+    async run(ctx, args) {
+      const models = await ctx.rpc.getAvailableModels();
+      if (!args) {
+        const state = await ctx.rpc.getState();
+        return formatModelList(models, state?.model ?? null);
+      }
+      const match = matchModel(models, args);
+      if (!match?.provider || !match?.id) {
+        return `No model matched "${args}". Use /model without arguments to list models.`;
+      }
+      await ctx.rpc.setModel(match.provider, match.id);
+      return `Model set to ${match.provider}/${match.id}.`;
+    },
+  },
+
+  think: {
+    description: "Set thinking level: /think <off|minimal|low|medium|high|max>",
+    async run(ctx, args) {
+      const levels = await ctx.rpc.getAvailableThinkingLevels();
+      const level = (args || "").toLowerCase();
+      if (!level || !levels.includes(level)) {
+        return `Thinking levels: ${levels.join(", ")} (current model).`;
+      }
+      await ctx.rpc.setThinkingLevel(level);
+      return `Thinking level set to ${level}.`;
+    },
+  },
+
+  abort: {
+    description: "Abort the current run and drop queued messages",
+    async run(ctx) {
+      /** @type {string[]} */
+      const dropped = [];
+      try {
+        const response = await ctx.rpc.clearQueue();
+        if (response?.success) {
+          dropped.push(...(response.data?.steering ?? []));
+          dropped.push(...(response.data?.followUp ?? []));
+        }
+      } catch {
+        /* older pi without clear_queue: abort alone still works */
+      }
+      ctx.rpc.abort();
+      return dropped.length > 0
+        ? `Aborted. Dropped ${dropped.length} queued message(s).`
+        : "Aborted.";
+    },
+  },
+
+  quit: {
+    description: "Shut down the bridge and Pi",
+    async run() {
+      return { text: "Shutting down. Bye!", shutdown: true };
+    },
+  },
+};
+
+/**
+ * The recovery prompt used when a run settles without any reply text
+ * (SPEC §6.3 — a run that ends on a tool call never wrote its answer).
+ */
+export const EMPTY_REPLY_RECOVERY_PROMPT =
+  "You are being driven over LXMF messaging. Your previous run finished " +
+  "without writing any reply text. Write the reply to the user's message " +
+  "now; if the work is not finished, describe the current state and what " +
+  "you still need to do.";

package/src/config.js

@@ -0,0 +1,393 @@
+/**
+ * @file config.js
+ *
+ * Configuration loading/validation and the small machine-managed state
+ * files (Pi session pointer) described in SPEC §8.
+ *
+ * The controlling owner is configured (required) by their **Reticulum
+ * identity hash** — protocol-agnostic, and the key a future DACAR-style
+ * permission system (../dacar) would grant to — never by an LXMF
+ * destination hash. `src/identity.js` derives the wire form.
+ *
+ * Config resolution order for the file itself: explicit `path` argument,
+ * `$PI_LXMF_CONFIG`, then `$XDG_CONFIG_HOME/pi-lxmf/config.json`
+ * (default `~/.config/pi-lxmf/config.json`). A missing file is not an
+ * error — the daemon runs on defaults (and first-contact pairing).
+ */
+
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+/** Thrown for unusable configuration (bad path, bad JSON, invalid values). */
+export class ConfigError extends Error {
+  /**
+   * @param {string} message
+   * @param {string} [file]
+   */
+  constructor(message, file) {
+    super(file ? `${message} (${file})` : message);
+    this.name = "ConfigError";
+    this.file = file;
+  }
+}
+
+/** 16-byte destination/source hashes as 32 lowercase hex chars. */
+const HEX32_RE = /^[0-9a-fA-F]{32}$/;
+
+/**
+ * The resolved daemon configuration (output of {@link loadConfig}).
+ *
+ * @typedef {object} PiLxmfConfig
+ * @property {string} owner - Owner's 32-hex Reticulum identity hash (required;
+ *   NOT the `lxmf.delivery` destination hash / "LXMF Address").
+ * @property {string} name - Announce display name.
+ * @property {string} workdir - Project directory Pi runs in.
+ * @property {string|null} model - `--model` pattern passed to Pi.
+ * @property {string} piBin - Pi binary.
+ * @property {string} dataDir - State root (storage, session pointer).
+ * @property {string|null} rnsHost - rnsd TCP interface host (fallback).
+ * @property {number|null} rnsPort - rnsd TCP interface port (fallback).
+ * @property {boolean} skipSharedInstance - Do not attach to the local rnsd
+ *   shared instance; bring up own interfaces (AutoInterface + the optional
+ *   `rnsHost`/`rnsPort` TCP client) instead. Needed where the shared rnsd
+ *   fails to forward routed (multi-hop) traffic to its local clients.
+ * @property {string|null} propagationNode - `lxmf.propagation` hash.
+ * @property {number} syncIntervalSec - Propagation sync cadence (0 = off).
+ * @property {"steer"|"followUp"} midRunBehavior - streamingBehavior for mid-run prompts.
+ * @property {number} chunkChars - Max characters per outbound LXMF message.
+ * @property {number|null} announceIntervalSec - Re-announce cadence.
+ * @property {string|null} configPath - Config file the values came from.
+ */
+
+/**
+ * Validates and normalises a 32-hex destination hash (e.g. an
+ * `lxmf.delivery` address; never a raw 64-hex identity hash).
+ *
+ * @param {unknown} value
+ * @param {string} field
+ * @returns {string} lowercase hex
+ */
+function hashField(value, field) {
+  if (typeof value !== "string" || !HEX32_RE.test(value.trim())) {
+    throw new ConfigError(
+      `Config field "${field}" must be a 32-hex-character hash ` +
+        `(for "owner", the Reticulum identity hash — not the LXMF address), ` +
+        `got: ${JSON.stringify(value)}`,
+    );
+  }
+  return value.trim().toLowerCase();
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} field
+ * @param {number} fallback
+ * @param {number} [min]
+ * @returns {number}
+ */
+function intField(value, field, fallback, min = 0) {
+  if (value === undefined || value === null) return fallback;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < min || Math.floor(n) !== n) {
+    throw new ConfigError(
+      `Config field "${field}" must be an integer >= ${min}, got: ${JSON.stringify(value)}`,
+    );
+  }
+  return n;
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} field
+ * @param {boolean} fallback
+ * @returns {boolean}
+ */
+function boolField(value, field, fallback) {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value !== "boolean") {
+    throw new ConfigError(
+      `Config field "${field}" must be a boolean, got: ${JSON.stringify(value)}`,
+    );
+  }
+  return value;
+}
+
+/**
+ * Default config file path (`$PI_LXMF_CONFIG`, then XDG).
+ *
+ * @param {Record<string, string|undefined>} [env] - Defaults to `process.env`.
+ * @returns {string}
+ */
+export function defaultConfigPath(env = process.env) {
+  if (env.PI_LXMF_CONFIG) return env.PI_LXMF_CONFIG;
+  const base = env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "pi-lxmf", "config.json");
+}
+
+/**
+ * Default state/data directory (`$XDG_DATA_HOME/pi-lxmf`).
+ *
+ * @param {Record<string, string|undefined>} [env] - Defaults to `process.env`.
+ * @returns {string}
+ */
+export function defaultDataDir(env = process.env) {
+  const base = env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+  return join(base, "pi-lxmf");
+}
+
+/**
+ * Known config keys and their validators/defaults. Used both to build the
+ * resolved config and to warn about typos in unknown keys.
+ *
+ * @type {Record<string, {required?: boolean}>}
+ */
+const KNOWN_KEYS = {
+  owner: {},
+  name: {},
+  workdir: {},
+  model: {},
+  piBin: {},
+  dataDir: {},
+  rnsHost: {},
+  rnsPort: {},
+  skipSharedInstance: {},
+  propagationNode: {},
+  syncIntervalSec: {},
+  midRunBehavior: {},
+  chunkChars: {},
+  announceIntervalSec: {},
+};
+
+/**
+ * Loads, validates and resolves the daemon configuration.
+ *
+ * @param {object} [options]
+ * @param {string} [options.path] - Explicit config file path (highest precedence).
+ * @param {Record<string, string|undefined>} [options.env] - Defaults to `process.env`.
+ * @param {string} [options.cwd] - Default for `workdir`. Defaults to `process.cwd()`.
+ * @param {(msg: string) => void} [options.warn] - Sink for warnings (unknown keys). Defaults to `console.error`.
+ * @returns {Promise<PiLxmfConfig>}
+ */
+export async function loadConfig(options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const warn = options.warn ?? console.error;
+  const file = options.path || defaultConfigPath(env);
+
+  /** @type {Record<string, unknown>} */
+  let raw = {};
+  /** @type {string|null} */
+  let configPath = null;
+  if (existsSync(file)) {
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch (e) {
+      throw new ConfigError(`Cannot read config file: ${e}`, file);
+    }
+    try {
+      raw = JSON.parse(text);
+    } catch (e) {
+      throw new ConfigError(`Config file is not valid JSON: ${e}`, file);
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      throw new ConfigError("Config file must contain a JSON object", file);
+    }
+    configPath = file;
+    for (const key of Object.keys(raw)) {
+      if (!(key in KNOWN_KEYS)) {
+        warn(`pi-lxmf: unknown config key "${key}" ignored in ${file}`);
+      }
+    }
+  }
+
+  const { default: pkg } = await import("../package.json", {
+    with: { type: "json" },
+  });
+  const version = /** @type {{version?: string}} */ (pkg).version ?? "0.0.0";
+
+  if (raw.owner === undefined || raw.owner === null) {
+    throw new ConfigError(
+      'Config field "owner" is required: set it to your Reticulum identity ' +
+        "hash (32 hex chars — not the LXMF address). Messages from any other " +
+        "identity are dropped.",
+      configPath ?? undefined,
+    );
+  }
+
+  const midRunBehavior =
+    raw.midRunBehavior === undefined || raw.midRunBehavior === null
+      ? "steer"
+      : raw.midRunBehavior;
+  if (midRunBehavior !== "steer" && midRunBehavior !== "followUp") {
+    throw new ConfigError(
+      `Config field "midRunBehavior" must be "steer" or "followUp", got: ${JSON.stringify(raw.midRunBehavior)}`,
+    );
+  }
+
+  return {
+    owner: hashField(raw.owner, "owner"),
+    name:
+      typeof raw.name === "string" && raw.name.trim()
+        ? raw.name.trim()
+        : `pi-lxmf ${version}`,
+    workdir:
+      typeof raw.workdir === "string" && raw.workdir.trim() ? raw.workdir : cwd,
+    model:
+      typeof raw.model === "string" && raw.model.trim()
+        ? raw.model.trim()
+        : null,
+    piBin:
+      typeof raw.piBin === "string" && raw.piBin.trim()
+        ? raw.piBin.trim()
+        : "pi",
+    dataDir:
+      typeof raw.dataDir === "string" && raw.dataDir.trim()
+        ? raw.dataDir
+        : defaultDataDir(env),
+    rnsHost:
+      typeof raw.rnsHost === "string" && raw.rnsHost.trim()
+        ? raw.rnsHost.trim()
+        : null,
+    rnsPort:
+      raw.rnsPort === undefined || raw.rnsPort === null
+        ? null
+        : intField(raw.rnsPort, "rnsPort", 0, 1),
+    skipSharedInstance: boolField(
+      raw.skipSharedInstance,
+      "skipSharedInstance",
+      false,
+    ),
+    propagationNode:
+      raw.propagationNode === undefined || raw.propagationNode === null
+        ? null
+        : hashField(raw.propagationNode, "propagationNode"),
+    syncIntervalSec: intField(raw.syncIntervalSec, "syncIntervalSec", 0),
+    midRunBehavior,
+    chunkChars: intField(raw.chunkChars, "chunkChars", 2500, 1),
+    announceIntervalSec:
+      raw.announceIntervalSec === undefined || raw.announceIntervalSec === null
+        ? null
+        : intField(raw.announceIntervalSec, "announceIntervalSec", 0, 60),
+    configPath,
+  };
+}
+
+// --- Machine-managed state ------------------------------------------------
+
+/**
+ * Reads a JSON state file, returning `null` when absent or corrupt.
+ *
+ * @param {string} path
+ * @returns {Record<string, any>|null}
+ */
+function readStateFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Writes a JSON state file with `0600` permissions, creating directories.
+ *
+ * @param {string} path
+ * @param {Record<string, any>} data
+ */
+function writeStateFile(path, data) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+}
+
+/**
+ * The pre-migration session pointer path (kept for one-time adoption; see
+ * {@link readSessionPointer}).
+ */
+const LEGACY_SESSION_FILE = "session";
+
+/**
+ * Directory under `dataDir` holding the per-workdir session pointers.
+ */
+const SESSIONS_DIR = "sessions";
+
+/**
+ * A stable, filesystem-safe key for a `workdir`: the first 16 hex chars of
+ * its SHA-256. The key is the absolute path only — not the model, not a
+ * session name — so switching models mid-session keeps the same pointer
+ * (the session is the conversation; the model is orthogonal).
+ *
+ * @param {string} workdir - Absolute workdir (the key is the path only).
+ * @returns {string} a 16-char hex key.
+ */
+function workdirKey(workdir) {
+  return createHash("sha256").update(workdir).digest("hex").slice(0, 16);
+}
+
+/**
+ * The per-workdir session-pointer file path under `dataDir`.
+ *
+ * @param {string} dataDir
+ * @param {string} workdir
+ * @returns {string}
+ */
+function sessionPointerPath(dataDir, workdir) {
+  return join(dataDir, SESSIONS_DIR, `${workdirKey(workdir)}.json`);
+}
+
+/**
+ * Loads the persisted Pi session pointer for `workdir`, if any.
+ *
+ * One-time migration: if no per-workdir pointer exists yet but the legacy
+ * `${dataDir}/session` file does, it is adopted for the current workdir
+ * (the last session was here) and the legacy file is removed, so the
+ * adoption runs exactly once. A workdir with no pointer and no legacy file
+ * starts empty (fresh session).
+ *
+ * @param {string} dataDir
+ * @param {string} workdir - The resolved workdir the pointer is scoped to.
+ * @returns {{sessionFile: string}|null}
+ */
+export function readSessionPointer(dataDir, workdir) {
+  const path = sessionPointerPath(dataDir, workdir);
+  const existing = readStateFile(path);
+  if (existing && typeof existing.sessionFile === "string") {
+    return { sessionFile: existing.sessionFile };
+  }
+  // One-time adoption of the legacy single-file pointer.
+  const legacyPath = join(dataDir, LEGACY_SESSION_FILE);
+  const legacy = readStateFile(legacyPath);
+  if (legacy?.sessionFile && typeof legacy.sessionFile === "string") {
+    writeStateFile(path, { sessionFile: legacy.sessionFile });
+    try {
+      rmSync(legacyPath, { force: true });
+    } catch {
+      /* best effort — the adoption already wrote the new pointer */
+    }
+    return { sessionFile: legacy.sessionFile };
+  }
+  return null;
+}
+
+/**
+ * Persists the Pi session pointer for `workdir` (the JSONL file `pi
+ * --session` resumes), keyed by the workdir so distinct repos keep distinct
+ * sessions.
+ *
+ * @param {string} dataDir
+ * @param {string} workdir - The resolved workdir the pointer is scoped to.
+ * @param {string} sessionFile - Absolute path to the session file.
+ */
+export function writeSessionPointer(dataDir, workdir, sessionFile) {
+  writeStateFile(sessionPointerPath(dataDir, workdir), { sessionFile });
+}