@agentprojectcontext/apx 1.0.3 → 1.2.0

package/src/core/apc-context-skill.md

@@ -1,150 +1,102 @@
 
 # Agent Project Context
 
-This project uses APC. All agent context lives in `.apc/` — not in `.claude/`, `.cursor/`, `.windsurf/`, or any other IDE folder.
+This project uses APC. APC stores portable project context in `.apc/` and `AGENTS.md`.
+
+APC does not store raw runtime sessions. Sessions, conversations, messages, caches, provider
+threads, and private runtime memory stay in the IDE, CLI, daemon, or user-level store that created
+them.
 
 ## FIRST: check for pending migration
 
-**Before doing anything else**, check if `.apc/migrate.md` exists:
+Before doing anything else, check if `.apc/migrate.md` exists:
 
 ```bash
 cat .apc/migrate.md 2>/dev/null
 ```
 
-If it exists, open the conversation with this message — do not answer any other question first:
-
-> I see this project was just initialized with **Agent Project Context (APC)**.
->
-> I found context files that haven't been migrated yet:
-> [list files from .apc/migrate.md]
->
-> I'll read them, understand what's in them, and migrate intelligently — keeping only what APC doesn't already handle.
->
-> **Want me to start?**
+If it exists, offer to migrate before answering anything else. Read detected files, separate durable
+project context from runtime/private state, and migrate only what belongs in APC.
 
-### How to migrate — think, don't copy
+If the user says no or later, delete `.apc/migrate.md` so the offer is not repeated.
 
-**Step 1 — Read everything first.** Read all detected context files in full. Also read `AGENTS.md` if it exists. Understand the full project structure, conventions, and any referenced directories (e.g. `works/`, `docs/`, `notes/`).
+## Migration rule: think, do not copy
 
-**Step 2 — Classify each piece of content:**
+Classify content:
 
-| What it says | What to do |
+| Content | Action |
 |---|---|
-| Agent definitions (role, model, skills) | Create `.apc/agents/<slug>.md` |
-| Any instruction about writing sessions to a custom path (`works/sessions/`, `notes/`, etc.) | **Drop it** — APC handles sessions natively in `.apc/agents/<slug>/sessions/` |
-| Any instruction about writing memory to a custom path (`works/memory.md`, etc.) | **Drop it** — APC handles memory natively in `.apc/agents/<slug>/memory.md` |
-| "List agents in `AGENTS.md`" or any auto-generation rule for `AGENTS.md` | **Drop it** — APC handles this natively |
-| Project-specific directories not covered by APC (e.g. `works/specs/`, `works/tasks/`) | **Keep in `AGENTS.md`** — document the convention there |
-| Project rules, testing policy, stack notes, URLs, credentials | **Keep in `AGENTS.md`** — project context that APC doesn't define |
-| IDE-specific shortcuts or instructions (e.g. "run `npm run dev` in Claude terminal") | **Keep in `AGENTS.md`** — still useful to all agents |
-
-**Step 3 — Write `AGENTS.md`.** Start from what already exists in `AGENTS.md`, add what you kept from the classified content. Remove anything that duplicates APC native behavior. Keep it agent-neutral — no IDE-specific framing.
-
-**Step 4 — Delete the original files** (`CLAUDE.md`, `.cursorrules`, etc.). Do not leave stubs. The content either moved to `AGENTS.md` / `.apc/agents/` or was intentionally dropped because APC covers it.
-
-**Step 5 — Delete `.apc/migrate.md`** to mark migration complete.
-
-**Step 6 — Summarize** what was created, what was kept, and what was dropped (and why).
-
-If the user says no or later: delete `.apc/migrate.md` immediately so this offer is not shown again in future sessions.
-
----
-
-## Structure
-
-```
-AGENTS.md                        ← project context: rules, stack, conventions (commit)
+| Agent definitions: role, model, skills, description | Put in `.apc/agents/<slug>.md` and/or `AGENTS.md` |
+| Shared project rules, stack notes, commands, testing policy | Keep in `AGENTS.md` |
+| Reusable instruction blocks | Move to `.apc/skills/<name>.md` |
+| Durable safe facts useful to all contributors | Add to `.apc/agents/<slug>/memory.md` only after curation |
+| MCP expectations without secrets | Add to `.apc/mcps.json` |
+| Raw sessions, transcripts, conversations, messages, tool logs | Do not move into `.apc/`; leave with source runtime |
+| Secrets, tokens, credentials, private headers | Do not store in repository |
+| IDE UI settings or personal aliases | Leave in IDE/user config |
+| Instructions to store sessions under `.apc/` | Drop as obsolete |
+
+## APC structure
+
+```text
+AGENTS.md                        ← root project contract
 .apc/
-  project.json                   ← metadata + apx field (commit)
-  .gitignore                     ← safe defaults, created by apx init (commit)
-  agents/<slug>.md               ← agent definition (commit)
-  agents/<slug>/
-    memory.md                    ← curated memory (commit)
-    sessions/                    ← raw session logs (local-only, gitignored)
-  skills/                        ← reusable prompt fragments (commit)
-  mcps.json                      ← MCP declarations without secrets (commit)
+  project.json                   ← project metadata
+  .gitignore                     ← safety guard
+  agents/<slug>.md               ← agent definition
+  agents/<slug>/memory.md        ← optional curated project memory
+  skills/<name>.md               ← reusable project instructions
+  mcps.json                      ← MCP hints without secrets
 ```
 
-## Visibility rules
-
-| What | Visibility | Commit? |
-|---|---|---|
-| Agent definitions, skills, rules | `stable` / `project` | Yes |
-| `memory.md` | `project` | Yes |
-| `sessions/` | `local` | No — gitignored |
-| `secrets/`, `*.secret.json`, `*.env` | `private` | Never |
-| `cache/`, `tmp/` | `ephemeral` | No — gitignored |
-| `migrate.md` | `ephemeral` | No — gitignored |
-
-**Write sessions to `.apc/agents/<slug>/sessions/`** — they stay local. Extract meaningful decisions into `memory.md` — that travels with the repo.
-
-## Rules
-
-1. Read your definition and memory from `.apc/agents/<your-slug>/`
-2. Write memory to `.apc/agents/<your-slug>/memory.md` — never to IDE-specific folders
-3. Write raw session logs to `.apc/agents/<your-slug>/sessions/` — they are gitignored
-4. `AGENTS.md` is the neutral project context file — edit it directly, it is not auto-generated
-5. To list agents: read `AGENTS.md` or list `.apc/agents/*.md`
-
-## Sessions — write one at the end of every task
-
-Sessions are the record of what was done, for future agents and for the team.
+Do not store:
+
+```text
+.apc/agents/<slug>/sessions/
+.apc/sessions/
+.apc/conversations/
+.apc/messages/
+.apc/project.db
+.apc/cache/
+.apc/tmp/
+.apc/private/
+.apc/secrets/
+```
 
-**Where to write:**
-- APC standard path: `.apc/agents/<slug>/sessions/<date>-<slug>.md` (gitignored)
-- Project-specific path: check `AGENTS.md` — some projects use `works/sessions/` or similar
+## Operating rules
 
-**Format — always use this frontmatter:**
+1. Read `AGENTS.md` and relevant `.apc/` files before assuming project context.
+2. Read agent definitions from `.apc/agents/<slug>.md` when present.
+3. Read curated project memory from `.apc/agents/<slug>/memory.md` when present.
+4. Write only durable, safe, curated facts to APC memory.
+5. Never write raw sessions, transcripts, messages, conversations, or tool logs into `.apc/`.
+6. Keep secrets out of APC and out of git.
+7. Treat `.apc/mcps.json` as MCP configuration hints, not as an MCP implementation.
 
-```markdown
----
-title: Short title of what was done
-description: One-line summary for the index
-date: YYYY-MM-DD
-status: open | completed | in-progress | abandoned
----
+## Sessions
 
-## Goal
-What was the task or request.
+Sessions belong to the runtime that created them.
 
-## Done
-What was completed. Be specific — file paths, decisions, changes.
+Examples:
 
-## Pending
-Anything left unfinished or deferred.
+```text
+Codex runtime storage
+Claude Code runtime storage
+OpenCode runtime storage
+~/.apx/projects/<project-id>/agents/<slug>/sessions/
 ```
 
-**How to create:**
-- If APX is installed (`apx` field in `project.json` is `"installed"`):
-  ```bash
-  apx session new <slug> --title "Short title"
-  ```
-  Then fill in `description`, update `status` to `completed` when done.
-- If APX is not available: create the file manually following the format above.
-
-**When to write:** at the end of every task session, before closing. Not optional.
+At task end, provide the user a concise result. If project memory should be updated, write a short
+sanitized fact to `.apc/agents/<slug>/memory.md` only when useful and safe.
 
-## APX — check once, remember forever
+## APX
 
-Read `.apc/project.json`. It has an `apx` field:
+APX can provide a local daemon, MCP management, Telegram bridge, routines, and runtime dispatch
+across Codex, Claude Code, OpenCode, Aider, or direct LLM engines. Those are APX runtime features,
+not APC portable-core requirements.
 
-- **`"installed"`** — APX is available. Use `apx` commands freely when useful.
-- **`"declined"`** — user chose not to install. Never suggest or run `apx` commands.
-- **`null` or missing** — unknown. Do the one-time check below, then write the result and never ask again.
+APX runtime state belongs outside the repository:
 
-### One-time APX detection (only when `apx` is null or missing)
-
-```bash
-apx --version 2>/dev/null && echo "FOUND" || echo "NOT_FOUND"
+```text
+~/.apx/projects/<project-id>/
 ```
-
-- If `FOUND`: write `"apx": "installed"` to `.apc/project.json`. Use APX normally.
-- If `NOT_FOUND`: tell the user once:
-
-  > APX is not installed. It adds agent coordination, MCP server management, and memory commands to this project.
-  > Want me to install it? (`npm install -g apx`)
-
-  - If yes: run `npm install -g apx`, then write `"apx": "installed"`.
-  - If no: write `"apx": "declined"`. Never mention APX again in this project.
-
-**Never run `apx` commands if the field is `null`, `"declined"`, or unconfirmed.**

package/src/core/apx-skill.md

@@ -1,7 +1,10 @@
-# APX — Agent Project Framework
+# APX — Agent Project Context Runtime
 
 The daemon runs on `127.0.0.1:7430` and auto-starts on first `apx` call.
 
+APX reads APC project context from `.apc/`, but APX runtime state belongs outside the repository
+under `~/.apx/projects/<project-id>/`.
+
 ---
 
 ## Coordinate with other agents
@@ -48,6 +51,8 @@ apx mcp run filesystem read_file '{"path": "README.md"}'
 
 ## Memory
 
+Write memory only for durable, safe project facts. Do not store raw transcripts or secrets.
+
 ```bash
 apx memory <slug>                       # read agent's memory.md
 apx memory <slug> --append "<fact>"     # append a durable note
@@ -56,8 +61,10 @@ apx memory <slug> --replace < file.md  # replace entire memory from stdin
 
 ## Sessions
 
+Sessions are APX runtime state. They do not belong in `.apc/`.
+
 ```bash
-apx session new <slug> --title "What you did"   # create session file
+apx session new <slug> --title "What you did"   # create APX local session file
 apx session list <slug>                          # list sessions
 apx session check                                # exits 1 if session already active
 ```

package/src/core/config.js

@@ -11,6 +11,21 @@ export const TELEGRAM_STATE_PATH = path.join(APX_HOME, "telegram-state.json");
 // Global channel messages (telegram, direct, whatsapp, …) live here,
 // separated from any project.  Structure: ~/.apx/messages/<channel>/YYYY-MM-DD.jsonl
 export const GLOBAL_MESSAGES_DIR = path.join(APX_HOME, "messages");
+// Per-project runtime storage (conversations, sessions) — never in the repo.
+// Structure: ~/.apx/projects/<apx_id>/agents/<slug>/conversations/
+export const PROJECT_STORE_ROOT = path.join(APX_HOME, "projects");
+export const DEFAULT_PROJECT_ID = "default";
+export const DEFAULT_PROJECT_STORE = path.join(PROJECT_STORE_ROOT, DEFAULT_PROJECT_ID);
+
+export function projectStorageRoot(apxId) {
+  return path.join(PROJECT_STORE_ROOT, apxId);
+}
+
+export function ensureProjectStorage(apxId) {
+  const root = projectStorageRoot(apxId);
+  fs.mkdirSync(root, { recursive: true });
+  return root;
+}
 
 const DEFAULT_CONFIG = {
   port: 7430,

package/src/core/messages-store.js

@@ -1,7 +1,7 @@
 // Messages store: filesystem source-of-truth + SQLite cache mirror.
 //
 // On disk (project-specific — runtime, a2a, exec):
-//   <project>/.apc/messages/YYYY-MM-DD.jsonl
+//   ~/.apx/projects/<project-id>/messages/YYYY-MM-DD.jsonl
 //
 // On disk (global cross-project channels — telegram, direct, whatsapp, …):
 //   ~/.apx/messages/<channel>/YYYY-MM-DD.jsonl
@@ -24,12 +24,12 @@ const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
 function dayPathJsonl(projectRoot, ts) {
   const day = (ts || nowIso()).slice(0, 10);
-  return path.join(projectRoot, ".apc", "messages", `${day}.jsonl`);
+  return path.join(projectRoot, "messages", `${day}.jsonl`);
 }
 
 function dayPathMd(projectRoot, ts) {
   const day = (ts || nowIso()).slice(0, 10);
-  return path.join(projectRoot, ".apc", "messages", `${day}.md`);
+  return path.join(projectRoot, "messages", `${day}.md`);
 }
 
 export function appendMessageToFs({ projectRoot, channel, direction, author, body, meta = {}, ts, agent_slug, session_id, external_id }) {
@@ -262,7 +262,7 @@ function sanitizeAssistantForContext(content) {
 // ---------------------------------------------------------------------------
 
 export function readProjectMessages(projectRoot, { channel, agent_slug, since, limit = 100 } = {}) {
-  const dir = path.join(projectRoot, ".apc", "messages");
+  const dir = path.join(projectRoot, "messages");
   if (!fs.existsSync(dir)) return [];
   const all = [];
   for (const f of fs.readdirSync(dir).sort()) {
@@ -285,7 +285,7 @@ export function readProjectMessages(projectRoot, { channel, agent_slug, since, l
 export function searchProjectMessages(projectRoot, query, limit = 50) {
   if (!query) return [];
   const q = query.toLowerCase();
-  const dir = path.join(projectRoot, ".apc", "messages");
+  const dir = path.join(projectRoot, "messages");
   if (!fs.existsSync(dir)) return [];
   const all = [];
   for (const f of fs.readdirSync(dir).sort()) {
@@ -392,10 +392,10 @@ export function readGlobalMessages({ channel, limit = 100, since } = {}) {
   return all.slice(-limit);
 }
 
-// Wipe the cache and re-populate from .apc/messages/*. Reads BOTH `.jsonl`
+// Wipe the cache and re-populate from APX project messages. Reads BOTH `.jsonl`
 // (current format) and `.md` (legacy). Called by rebuild.
 export function rebuildMessagesFromFs(db, projectRoot) {
-  const dir = path.join(projectRoot, ".apc", "messages");
+  const dir = path.join(projectRoot, "messages");
   if (!fs.existsSync(dir)) return { count: 0 };
   db.prepare("DELETE FROM messages").run();
 

package/src/core/scaffold.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import crypto from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { readAgents, readAgentsFromDir, VAULT_DIR } from "./parser.js";
 
@@ -188,9 +189,13 @@ const AGENTS_MD_TEMPLATE = `# Agents
 -->
 `;
 
-const APC_GITIGNORE = `# APC runtime data — local-first by default
+const APC_GITIGNORE = `# APC runtime data — never in the repository
+# Chat conversations and runtime sessions belong in ~/.apx/projects/<id>/
 agents/*/sessions/
+agents/*/conversations/
 sessions/
+conversations/
+messages/
 chats/
 cache/
 tmp/
@@ -200,6 +205,7 @@ secrets/
 *.secret.json
 *.env
 *.env.*
+project.db
 migrate.md
 `;
 
@@ -241,6 +247,20 @@ function writeMigrateMd(apfDir, found) {
   fs.writeFileSync(path.join(apfDir, "migrate.md"), lines.join("\n") + "\n");
 }
 
+// Get the stable APX storage ID for a project, generating one if it doesn't exist.
+// Called by the daemon when registering a project.
+export function getOrCreateApxId(root) {
+  const p = path.join(root, ".apc", "project.json");
+  if (!fs.existsSync(p)) return null;
+  let cfg;
+  try { cfg = JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+  if (cfg.apx_id) return cfg.apx_id;
+  const apxId = crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+  cfg.apx_id = apxId;
+  fs.writeFileSync(p, JSON.stringify(cfg, null, 2) + "\n");
+  return apxId;
+}
+
 export function initApf(directory, { name } = {}) {
   const root = path.resolve(directory);
   fs.mkdirSync(root, { recursive: true });
@@ -252,6 +272,7 @@ export function initApf(directory, { name } = {}) {
 
   const projectJson = path.join(apfDir, "project.json");
   if (!fs.existsSync(projectJson)) {
+    const apxId = crypto.randomUUID().replace(/-/g, "").slice(0, 12);
     fs.writeFileSync(
       projectJson,
       JSON.stringify(
@@ -261,7 +282,7 @@ export function initApf(directory, { name } = {}) {
           apf: SPEC_VERSION,
           created: nowIso(),
           apx: null,
-          sessions: { defaultVisibility: "local" },
+          apx_id: apxId,
         },
         null,
         2
@@ -291,7 +312,7 @@ export function initApf(directory, { name } = {}) {
 
 export function ensureAgentDir(root, slug) {
   const dir = path.join(root, ".apc", "agents", slug);
-  fs.mkdirSync(path.join(dir, "sessions"), { recursive: true });
+  fs.mkdirSync(dir, { recursive: true });
   const memory = path.join(dir, "memory.md");
   if (!fs.existsSync(memory)) {
     fs.writeFileSync(

package/src/core/session-store.js

@@ -5,9 +5,9 @@
 import fs from "node:fs";
 import path from "node:path";
 
-export function generateSessionId(projectRoot, agentSlug) {
+export function generateSessionId(storageRoot, agentSlug) {
   const today = new Date().toISOString().slice(0, 10);
-  const dir = path.join(projectRoot, ".apc", "agents", agentSlug, "sessions");
+  const dir = path.join(storageRoot, "agents", agentSlug, "sessions");
   let next = 1;
   if (fs.existsSync(dir)) {
     for (const f of fs.readdirSync(dir)) {

package/src/core/update-check.js

@@ -0,0 +1,99 @@
+// Update checker — non-blocking, cached 24h.
+// On each command: reads cache → shows message if newer version exists.
+// In background: refreshes cache from npm registry (fire-and-forget).
+// Never slows down the main command.
+
+import fs from "node:fs";
+import path from "node:path";
+import https from "node:https";
+import { APX_HOME } from "./config.js";
+
+const PACKAGE_NAME = "@agentprojectcontext/apx";
+const CACHE_PATH = path.join(APX_HOME, "update-check.json");
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+
+function readCache() {
+  try {
+    const raw = fs.readFileSync(CACHE_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(data) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(data) + "\n");
+  } catch {}
+}
+
+// Compare semver strings. Returns true if `latest` > `current`.
+function isNewer(current, latest) {
+  if (!current || !latest) return false;
+  const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
+  const [ma, mi, pa] = parse(current);
+  const [mb, mib, pb] = parse(latest);
+  if (mb > ma) return true;
+  if (mb === ma && mib > mi) return true;
+  if (mb === ma && mib === mi && pb > pa) return true;
+  return false;
+}
+
+// Fetch latest version from npm registry (async, no deps).
+function fetchLatest() {
+  return new Promise((resolve) => {
+    const url = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+    const req = https.get(url, { timeout: 5000 }, (res) => {
+      let body = "";
+      res.on("data", (c) => (body += c));
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(body).version || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+  });
+}
+
+// Fire-and-forget background refresh. Never awaited by the caller.
+function refreshInBackground(currentVersion) {
+  fetchLatest().then((latest) => {
+    if (latest) {
+      writeCache({ latest, current: currentVersion, checkedAt: Date.now() });
+    }
+  }).catch(() => {});
+}
+
+// Call this at the END of every command (after output is printed).
+// Shows an update notice if a newer version is cached.
+// Also triggers a background refresh if cache is stale.
+export function checkForUpdate(currentVersion) {
+  const cache = readCache();
+  const now = Date.now();
+
+  // Trigger background refresh if cache is stale or missing.
+  if (!cache || (now - (cache.checkedAt || 0)) > CACHE_TTL_MS) {
+    refreshInBackground(currentVersion);
+  }
+
+  // Show notice if cache has a newer version.
+  if (cache && isNewer(currentVersion, cache.latest)) {
+    const divider = "─".repeat(56);
+    process.stderr.write(
+      `\n${divider}\n` +
+      `  apx update available  ${currentVersion} → ${cache.latest}\n` +
+      `  run: apx update\n` +
+      `${divider}\n`
+    );
+  }
+}
+
+// Used by `apx update` command to get the latest version (with network call).
+export async function getLatestVersion() {
+  return await fetchLatest();
+}

package/src/daemon/apc-runtime-context.js

@@ -1,13 +1,13 @@
 // Helpers that wrap external runtimes (Claude Code, Codex, OpenCode, Aider)
 // with APC awareness:
 //
-//   1. Create an APC session BEFORE the runtime starts.
+//   1. Create an APX runtime session BEFORE the runtime starts.
 //   2. Inject an "APC Runtime Context" block into the system prompt so the
 //      runtime knows the session id, the cwd of the project, and the apx
 //      commands it can use to update memory / append session notes.
 //   3. After the runtime returns, capture the external transcript path
 //      (Claude Code gives one, Codex/OpenCode/Aider don't yet) and write it
-//      into the APC session frontmatter.
+//      into the APX session frontmatter.
 //   4. Close the session with a synthesised result (truncated stdout).
 //
 // Used by both POST /projects/:pid/agents/:slug/runtime (CLI) and the
@@ -22,12 +22,12 @@ const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 const APC_RUNTIME_HINT = `
 # APC Runtime Context
 
-You are running inside an APC (Agent Project Framework) project. APC gives you durable session state across runs.
+You are running inside an APC (Agent Project Context) project. APC gives you portable project context. APX gives you local runtime session state.
 
 - **Project**: {{name}}  ({{path}})
 - **Agent**: {{agent}}
 - **APC session id**: {{session_id}}
-  (filename: .apc/agents/{{agent}}/sessions/{{session_id}}.md)
+  (stored in APX local runtime storage, outside .apc/)
 
 ## Commands you can use during this run
 
@@ -52,11 +52,11 @@ export function buildApfHint({ projectName, projectPath, agentSlug, sessionId })
     .replace(/\{\{session_id\}\}/g, sessionId);
 }
 
-// Create the APC session file on disk. Returns { id, filename, path }.
-export function createRuntimeSession({ projectRoot, agentSlug, runtime, taskRef = "", title }) {
-  const dir = path.join(projectRoot, ".apc", "agents", agentSlug, "sessions");
+// Create the APX runtime session file on disk. Returns { id, filename, path }.
+export function createRuntimeSession({ projectRoot, storageRoot = projectRoot, agentSlug, runtime, taskRef = "", title }) {
+  const dir = path.join(storageRoot, "agents", agentSlug, "sessions");
   fs.mkdirSync(dir, { recursive: true });
-  const id = generateSessionId(projectRoot, agentSlug);
+  const id = generateSessionId(storageRoot, agentSlug);
   const file = path.join(dir, `${id}.md`);
   const started = nowIso();
   const sessionTitle = title || `Runtime: ${runtime}`;