@gmickel/gno 2.4.0 → 2.6.0

package/src/cli/commands/shared.ts

@@ -9,7 +9,11 @@ import type { Collection, Config } from "../../config/types";
 import type { SyncResult } from "../../ingestion";
 import type { SearchResults } from "../../pipeline/types";
 
-import { decorateUriForIndex, getIndexDbPath } from "../../app/constants";
+import {
+  DEFAULT_INDEX_NAME,
+  decorateUriForIndex,
+  getIndexDbPath,
+} from "../../app/constants";
 import {
   getConfigPaths,
   isInitialized,
@@ -17,6 +21,7 @@ import {
   writeConfigWarningsToStderr,
 } from "../../config";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
+import { assertCliSessionBinding } from "../session-binding";
 
 /**
  * Result of CLI store initialization.
@@ -90,6 +95,14 @@ export async function initStore(
     };
   }
 
+  // Every index a command opens (including one named by a `?index=` URI)
+  // honours the session-archive config/index binding.
+  await assertCliSessionBinding(
+    options.configPath,
+    options.indexName ?? DEFAULT_INDEX_NAME,
+    config
+  );
+
   // Ensure data directory exists (may have been deleted by reset)
   const { ensureDirectories } = await import("../../config");
   await ensureDirectories();

package/src/cli/errors.ts

@@ -15,7 +15,9 @@ export type CliErrorCode =
   | "NOT_RUNNING"
   | "BUSY"
   | "AUDIT_FINDINGS"
-  | "AUDIT_PARTIAL";
+  | "AUDIT_PARTIAL"
+  | "CONTEXT_STALE"
+  | "CONTEXT_CONFLICT";
 
 export interface CliErrorOptions {
   details?: Record<string, unknown>;
@@ -72,10 +74,15 @@ export function exitCodeFor(err: CliError): 1 | 2 | 3 | 4 | 5 {
   if (err.code === "VALIDATION") {
     return 1;
   }
-  if (err.code === "NOT_RUNNING") {
+  if (err.code === "NOT_RUNNING" || err.code === "CONTEXT_STALE") {
     return 3;
   }
-  if (err.code === "BUSY" || err.code === "AUDIT_FINDINGS") return 4;
+  if (
+    err.code === "BUSY" ||
+    err.code === "AUDIT_FINDINGS" ||
+    err.code === "CONTEXT_CONFLICT"
+  )
+    return 4;
   if (err.code === "AUDIT_PARTIAL") return 5;
   return 2;
 }

package/src/cli/program.ts

@@ -344,7 +344,7 @@ export function createProgram(): Command {
     .option("--no-pager", "disable automatic paging of long output");
 
   // Resolve globals ONCE before any command runs (ensures consistency)
-  program.hook("preAction", (thisCommand) => {
+  program.hook("preAction", async (thisCommand) => {
     const rootOpts = thisCommand.optsWithGlobals();
     const globals = parseGlobalOptions(rootOpts);
     if (!isValidIndexName(globals.index)) {
@@ -355,6 +355,8 @@ export function createProgram(): Command {
     }
     applyGlobalOptions(globals);
     globalState.current = globals;
+    const { assertCliSessionBinding } = await import("./session-binding");
+    await assertCliSessionBinding(globals.config, globals.index);
   });
 
   // Wire command groups
@@ -362,6 +364,7 @@ export function createProgram(): Command {
   wireOnboardingCommands(program);
   wireCaptureCommand(program);
   wireMemoryCommands(program);
+  wireSessionsCommands(program);
   wireManagementCommands(program);
   wireTraceCommands(program);
   wirePublishCommand(program);
@@ -1874,6 +1877,10 @@ function wireCaptureCommand(program: Command): void {
     .option("--source-author <author>", "source author")
     .option("--source-date <date>", "source observed date/time")
     .option("--source-id <id>", "source external id")
+    .option(
+      "--request-id <id>",
+      "retry identity: reuse it to retry this same capture after a lost response"
+    )
     .option("--json", "JSON output")
     .action(
       async (contentParts: string[], cmdOpts: Record<string, unknown>) => {
@@ -1902,6 +1909,7 @@ function wireCaptureCommand(program: Command): void {
           sourceAuthor: cmdOpts.sourceAuthor as string | undefined,
           sourceDate: cmdOpts.sourceDate as string | undefined,
           sourceId: cmdOpts.sourceId as string | undefined,
+          requestId: cmdOpts.requestId as string | undefined,
         });
         const output = formatCaptureReceipt(receipt, {
           json: format === "json",
@@ -1910,6 +1918,27 @@ function wireCaptureCommand(program: Command): void {
         await writeOutput(output, format);
       }
     );
+
+  program
+    .command("request-status <request-id>")
+    .description(
+      "Show whether a capture/remember request ID is pending, committed, or unknown"
+    )
+    .option("--json", "JSON output")
+    .action(async (requestId: string, cmdOpts: Record<string, unknown>) => {
+      const format = getFormat(cmdOpts);
+      const globals = getGlobals();
+      const { formatRequestStatusOutput, requestStatus } =
+        await import("./commands/request-status");
+      const result = await requestStatus({
+        requestId,
+        indexName: globals.index,
+      });
+      await writeOutput(
+        formatRequestStatusOutput(result, { json: format === "json" }),
+        format
+      );
+    });
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1957,6 +1986,10 @@ function wireMemoryCommands(program: Command): void {
       "--session <id>",
       "session identity (default: $GNO_MEMORY_SESSION or ppid:<pid>)"
     )
+    .option(
+      "--request-id <id>",
+      "retry identity: reuse it to retry this same write after a lost response"
+    )
     .option("--json", "JSON output")
     .action(async (text: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
@@ -1979,6 +2012,7 @@ function wireMemoryCommands(program: Command): void {
         source: cmdOpts.source as string | undefined,
         caller: cmdOpts.caller as string | undefined,
         session: cmdOpts.session as string | undefined,
+        requestId: cmdOpts.requestId as string | undefined,
       });
       await writeOutput(
         formatRememberResult(result, {
@@ -2038,6 +2072,358 @@ function wireMemoryCommands(program: Command): void {
     });
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Session archive commands (manual import only)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function wireSessionsCommands(program: Command): void {
+  const sessionsCmd = program
+    .command("sessions")
+    .description(
+      "Discover and manually import local agent sessions into a dedicated archive"
+    );
+  const context = () => {
+    const globals = getGlobals();
+    return { configPath: globals.config, indexName: globals.index };
+  };
+  const asJson = (cmdOpts: Record<string, unknown>) =>
+    getFormat(cmdOpts) === "json";
+
+  sessionsCmd
+    .command("discover", { isDefault: true })
+    .description("Preview supported local session sources (never imports)")
+    .option("--json", "JSON output")
+    .action(async (cmdOpts: Record<string, unknown>) => {
+      const { discoverSessions, formatDiscovery } =
+        await import("./commands/sessions");
+      const result = await discoverSessions(context());
+      await writeOutput(
+        formatDiscovery(result, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+
+  sessionsCmd
+    .command("init")
+    .description("Create or extend the dedicated archive config/index pair")
+    .option(
+      "--archive <dir>",
+      "absolute archive directory (outside the curated vault)"
+    )
+    .option("--collection <name>", "archive collection to create")
+    .option("--json", "JSON output")
+    .action(async (cmdOpts: Record<string, unknown>) => {
+      const { initSessions } = await import("./commands/sessions");
+      const result = await initSessions(context(), {
+        archive: cmdOpts.archive as string | undefined,
+        collection: cmdOpts.collection as string | undefined,
+      });
+      await writeOutput(
+        asJson(cmdOpts)
+          ? JSON.stringify(result, null, 2)
+          : `Session archive ${result.created ? "created" : "ready"}: ${result.archiveRoot} (collection ${result.collection}, index ${result.index}, config ${result.configPath})`,
+        getFormat(cmdOpts)
+      );
+    });
+
+  const sourceCmd = sessionsCmd
+    .command("source")
+    .description("Register or unregister owner session sources");
+  sourceCmd
+    .command("add <id>")
+    .description("Register a harness session root for manual import")
+    .option("--harness <harness>", "codex | claude-code | openclaw | hermes")
+    .option("--path <path>", "absolute harness session root, file or database")
+    .option("--collection <name>", "default archive collection")
+    .option(
+      "--project <prefix=collection>",
+      "owner-approved working-directory mapping (repeatable)",
+      collectRepeatableValue,
+      []
+    )
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { addSource } = await import("./commands/sessions");
+      const result = await addSource(context(), {
+        id,
+        harness: cmdOpts.harness as string | undefined,
+        path: cmdOpts.path as string | undefined,
+        collection: cmdOpts.collection as string | undefined,
+        projects: cmdOpts.project as string[],
+      });
+      await writeOutput(
+        asJson(cmdOpts)
+          ? JSON.stringify(result, null, 2)
+          : `Source ${result.id} registered. Nothing was imported.`,
+        getFormat(cmdOpts)
+      );
+    });
+  sourceCmd
+    .command("remove <id>")
+    .description("Unregister a source (its archive is retained)")
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { removeSource } = await import("./commands/sessions");
+      const result = await removeSource(context(), id);
+      await writeOutput(
+        asJson(cmdOpts)
+          ? JSON.stringify(result, null, 2)
+          : `Source ${result.id} removed; archived sessions were retained.`,
+        getFormat(cmdOpts)
+      );
+    });
+
+  sessionsCmd
+    .command("import [paths...]")
+    .description("Import selected sources or paths into the archive (manual)")
+    .option("--source <id>", "registered source to import")
+    .option(
+      "--collection <name>",
+      "destination archive collection (path imports)"
+    )
+    .option("--format <harness>", "codex | claude-code | openclaw | hermes")
+    .option("--dry-run", "parse and report without writing archive or index")
+    .option("--limit <n>", "maximum changed units processed this run")
+    .option("--json", "JSON output")
+    .action(async (paths: string[], cmdOpts: Record<string, unknown>) => {
+      const { formatImportReceipt, importSessions } =
+        await import("./commands/sessions");
+      const receipt = await importSessions(context(), {
+        paths,
+        source: cmdOpts.source as string | undefined,
+        collection: cmdOpts.collection as string | undefined,
+        format: cmdOpts.format as string | undefined,
+        dryRun: Boolean(cmdOpts.dryRun),
+        limit: cmdOpts.limit,
+      });
+      await writeOutput(
+        formatImportReceipt(receipt, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+      if (receipt.status === "failed") {
+        const unsupportedOnly =
+          receipt.counts.unsupported > 0 &&
+          receipt.counts.failed === 0 &&
+          receipt.counts.incomplete === 0;
+        throw unsupportedOnly
+          ? new CliError(
+              "VALIDATION",
+              "No selected unit is a supported session format; see receipt.",
+              { details: { sessionsCode: "SESSIONS_UNSUPPORTED_FORMAT" } }
+            )
+          : new CliError("RUNTIME", "Session import failed; see receipt.", {
+              details: { sessionsCode: "SESSIONS_IMPORT_FAILED" },
+            });
+      }
+    });
+
+  sessionsCmd
+    .command("status")
+    .description("Show archive, source and checkpoint status")
+    .option("--json", "JSON output")
+    .action(async (cmdOpts: Record<string, unknown>) => {
+      const { formatStatus, sessionsStatus } =
+        await import("./commands/sessions");
+      const result = await sessionsStatus(context());
+      await writeOutput(
+        formatStatus(result, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+
+  wireSessionsAutomationCommands(sessionsCmd, context, asJson);
+
+  sessionsCmd
+    .command("prune")
+    .description(
+      "Preview (or --apply) removal of archives whose source is gone"
+    )
+    .option("--source <id>", "source to prune")
+    .option("--apply", "delete the previewed archive files")
+    .option("--json", "JSON output")
+    .action(async (cmdOpts: Record<string, unknown>) => {
+      const { formatPrune, pruneSessions } =
+        await import("./commands/sessions");
+      const result = await pruneSessions(context(), {
+        source: cmdOpts.source as string | undefined,
+        apply: Boolean(cmdOpts.apply),
+      });
+      await writeOutput(
+        formatPrune(result, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+}
+
+/** Opt-in automation: profiles, explicit trigger switches, run-now, host hook. */
+function wireSessionsAutomationCommands(
+  sessionsCmd: Command,
+  context: () => { configPath?: string; indexName: string },
+  asJson: (cmdOpts: Record<string, unknown>) => boolean
+): void {
+  const automationCmd = sessionsCmd
+    .command("automation")
+    .description(
+      "Opt-in hooks and daemon schedules for registered sources (off until enabled)"
+    );
+
+  automationCmd
+    .command("set <profile>")
+    .description(
+      "Create or reconfigure a profile (sources, cadence, budget); enables nothing"
+    )
+    .option(
+      "--source <id>",
+      "registered source to include (repeatable)",
+      collectRepeatableValue,
+      []
+    )
+    .option("--cadence <n>", "elapsed schedule cadence <n>s|m|h|d (min 1m)")
+    .option("--limit <n>", "changed units per source per run")
+    .option("--retries <n>", "automatic retries after a failed run")
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { formatAutomationPreview, setAutomation } =
+        await import("./commands/sessions");
+      const preview = await setAutomation(context(), id, {
+        sources: cmdOpts.source as string[],
+        cadence: cmdOpts.cadence as string | undefined,
+        limit: cmdOpts.limit,
+        retries: cmdOpts.retries,
+      });
+      await writeOutput(
+        formatAutomationPreview(preview, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+
+  automationCmd
+    .command("preview <profile>")
+    .description(
+      "Show sources, destinations, hook command, schedule and daemon prerequisite"
+    )
+    .option("--settings <path>", "Claude Code settings file to preview")
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { formatAutomationPreview, previewAutomation } =
+        await import("./commands/sessions");
+      const preview = await previewAutomation(context(), id, {
+        settings: cmdOpts.settings as string | undefined,
+      });
+      await writeOutput(
+        formatAutomationPreview(preview, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+
+  automationCmd
+    .command("enable <profile>")
+    .description(
+      "Explicitly switch on a host hook and/or the daemon schedule for a profile"
+    )
+    .option("--hook <harness>", "install the owned hook (claude-code)")
+    .option(
+      "--settings <path>",
+      "Claude Code settings file (default: $CLAUDE_CONFIG_DIR or ~/.claude settings.json)"
+    )
+    .option("--schedule", "run on the daemon's elapsed cadence")
+    .option("--cadence <n>", "elapsed cadence <n>s|m|h|d (min 1m)")
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { enableAutomationCli, formatAutomationPreview } =
+        await import("./commands/sessions");
+      const preview = await enableAutomationCli(context(), id, {
+        hook: cmdOpts.hook as string | undefined,
+        settings: cmdOpts.settings as string | undefined,
+        schedule: Boolean(cmdOpts.schedule),
+        cadence: cmdOpts.cadence as string | undefined,
+      });
+      await writeOutput(
+        formatAutomationPreview(preview, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+
+  automationCmd
+    .command("disable <profile>")
+    .description(
+      "Pause: switch triggers off, remove the owned hook entry, clear pending work"
+    )
+    .option("--hook", "only the hook")
+    .option("--schedule", "only the schedule")
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { disableAutomationCli, formatAutomationChange } =
+        await import("./commands/sessions");
+      const change = await disableAutomationCli(context(), id, {
+        hook: Boolean(cmdOpts.hook),
+        schedule: Boolean(cmdOpts.schedule),
+      });
+      await writeOutput(
+        formatAutomationChange(change, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+
+  automationCmd
+    .command("remove <profile>")
+    .description(
+      "Uninstall owned integrations and delete the profile (archive retained)"
+    )
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { formatAutomationChange, removeAutomation } =
+        await import("./commands/sessions");
+      const change = await removeAutomation(context(), id);
+      await writeOutput(
+        formatAutomationChange(change, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+    });
+
+  automationCmd
+    .command("run <profile>")
+    .description("Run a profile now through the manual importer")
+    .option("--json", "JSON output")
+    .action(async (id: string, cmdOpts: Record<string, unknown>) => {
+      const { formatAutomationRun, runAutomation } =
+        await import("./commands/sessions");
+      const result = await runAutomation(context(), id);
+      await writeOutput(
+        formatAutomationRun(result, asJson(cmdOpts)),
+        getFormat(cmdOpts)
+      );
+      if (result.outcome === "failed" && result.reason === "busy") {
+        throw new CliError(
+          "BUSY",
+          "The archive is busy (another import or index writer); the run is recorded; a running daemon retries it, or run it again once the archive is free.",
+          { details: { sessionsCode: "SESSIONS_BUSY" } }
+        );
+      }
+      if (result.outcome === "failed") {
+        throw new CliError(
+          "RUNTIME",
+          `Automation run failed (${result.reason ?? "unknown"}); see gno sessions status.`,
+          { details: { sessionsCode: "SESSIONS_IMPORT_FAILED" } }
+        );
+      }
+    });
+
+  sessionsCmd
+    .command("hook <harness>")
+    .description(
+      "Host hook entrypoint: durably mark a profile pending (installed by automation enable)"
+    )
+    .option("--profile <id>", "automation profile")
+    .action(async (harness: string, cmdOpts: Record<string, unknown>) => {
+      const { runSessionsHook } = await import("./commands/sessions");
+      const line = await runSessionsHook(context(), harness, {
+        profile: cmdOpts.profile as string | undefined,
+      });
+      process.stdout.write(`${line}\n`);
+    });
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Retrieval Commands (get, multi-get, ls)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -2169,6 +2555,7 @@ function wireRetrievalCommands(program: Command): void {
         const { ls, formatLs } = await import("./commands/ls");
         const result = await ls(scope, {
           configPath: globals.config,
+          indexName: globals.index,
           limit: cmdOpts.limit as number | undefined,
           offset: cmdOpts.offset as number | undefined,
           json: format === "json",
@@ -2803,6 +3190,76 @@ function wireManagementCommands(program: Command): void {
       await writeOutput(output, format === "json" ? "json" : "md");
     });
 
+  const compiledCmd = contextCmd
+    .command("compiled")
+    .description("Compile, check and refresh verified project context");
+  for (const operation of ["preview", "compile", "check", "refresh"] as const) {
+    const command = compiledCmd
+      .command(
+        operation === "check" || operation === "refresh"
+          ? `${operation} <file>`
+          : operation
+      )
+      .description(`${operation} a separate managed context artifact`)
+      .option("--json", "JSON output");
+    if (operation === "preview" || operation === "compile") {
+      command
+        .requiredOption("--capsule <file>", "explicit Capsule JSON file")
+        .requiredOption("--budget <tokens>", "whole-output token budget")
+        .option("--bytes <bytes>", "whole-output byte budget");
+    }
+    if (operation === "compile")
+      command.requiredOption(
+        "--output <file>",
+        "new *.gno-context.md artifact"
+      );
+    if (operation === "check")
+      command.option("--capsule <file>", "relocated Capsule JSON file");
+    if (operation === "refresh")
+      command.requiredOption(
+        "--capsule-output <file>",
+        "explicit refreshed Capsule destination"
+      );
+    command.action(async (...args: unknown[]) => {
+      const file =
+        operation === "check" || operation === "refresh"
+          ? (args[0] as string)
+          : undefined;
+      const opts = args[file === undefined ? 0 : 1] as Record<string, unknown>;
+      const globals = getGlobals();
+      const { contextCompiled } = await import("./commands/context-compiled");
+      const result = await contextCompiled(operation, {
+        configPath: globals.config,
+        indexName: globals.index,
+        capsulePath: opts.capsule as string | undefined,
+        capsuleOutputPath: opts.capsuleOutput as string | undefined,
+        outputPath: file ?? (opts.output as string | undefined),
+        budgetTokens:
+          opts.budget === undefined
+            ? undefined
+            : parseContextInteger("budget", opts.budget),
+        budgetBytes:
+          opts.bytes === undefined
+            ? undefined
+            : parseContextInteger("bytes", opts.bytes),
+        json: Boolean(opts.json || globals.json),
+      });
+      await writeOutput(
+        result.output,
+        opts.json || globals.json ? "json" : "terminal"
+      );
+      if (result.status && result.status !== "current") {
+        const code =
+          result.status === "stale"
+            ? "CONTEXT_STALE"
+            : result.status === "conflict"
+              ? "CONTEXT_CONFLICT"
+              : "RUNTIME";
+        throw new CliError(code, result.status, { silent: true });
+      }
+    });
+  }
+
   contextCmd
     .command("verify <file>")
     .description("Verify a saved Context Capsule without rebuilding it")

package/src/cli/session-binding.ts

@@ -0,0 +1,49 @@
+/**
+ * CLI-wide enforcement of the session-archive config/index binding.
+ *
+ * Runs before every command and again whenever a command opens an index
+ * (`initStore`, which also covers indexes named by a `?index=` URI): a config
+ * bound to a session archive index cannot be used with another index, and an
+ * archive index cannot be opened with a different config.
+ *
+ * @module src/cli/session-binding
+ */
+
+import type { Config } from "../config/types";
+
+import { getIndexDbPath } from "../app/constants";
+import { getConfigPaths, loadConfig } from "../config";
+import { assertSessionBinding } from "../sessions/binding";
+import { SessionsError } from "../sessions/types";
+import { CliError } from "./errors";
+
+export async function assertCliSessionBinding(
+  configPath: string | undefined,
+  indexName: string,
+  loadedConfig?: Config
+): Promise<void> {
+  const path = configPath ?? getConfigPaths().configFile;
+  let config = loadedConfig;
+  if (!config) {
+    if (!(await Bun.file(path).exists())) return;
+    const loaded = await loadConfig(path);
+    // Unreadable configs are reported by the command itself.
+    if (!loaded.ok) return;
+    config = loaded.value;
+  }
+  try {
+    await assertSessionBinding({
+      config,
+      configPath: path,
+      indexName,
+      dbPath: getIndexDbPath(indexName),
+    });
+  } catch (error) {
+    if (error instanceof SessionsError) {
+      throw new CliError("VALIDATION", error.message, {
+        details: { sessionsCode: error.code },
+      });
+    }
+    throw error;
+  }
+}

package/src/config/types.ts

@@ -12,6 +12,7 @@ import { z } from "zod";
 import { URI_PREFIX } from "../app/constants";
 import { JsonlFieldMappingSchema } from "../converters/adapters/jsonl/config";
 import { MCP_TOOL_PROFILES } from "../mcp/tool-profile";
+import { SessionsConfigSchema } from "../sessions/config";
 import { ChunkingConfigSchema, type ChunkingParams } from "./chunking";
 import { RetrievalTraceConfigSchema } from "./retrieval-traces";
 
@@ -614,6 +615,13 @@ export const ConfigSchema = z.object({
   /** Bounded project-aware retrieval affinity. */
   projectAffinity: ProjectAffinityConfigSchema.optional(),
 
+  /**
+   * Session-archive binding. Present only in a dedicated archive config; it
+   * binds the file to one index name and archive root and lists
+   * owner-registered session sources.
+   */
+  sessions: SessionsConfigSchema.optional(),
+
   /** Machine-local, timestamp-free project profile provenance. */
   projectProfileBindings: z
     .array(ProjectProfileBindingSchema)