@gmickel/gno 1.16.0 → 1.18.0

package/src/app/context-surface.ts

@@ -0,0 +1,145 @@
+/** Closed wire contracts shared by Context Capsule REST and MCP surfaces. */
+
+import { z } from "zod";
+
+import type { ContextCapsuleBuildInput } from "./context-runtime-types";
+
+import { ContextCapsuleContractError } from "../core/context-capsule";
+
+const queryModeSchema = z
+  .object({
+    mode: z.enum(["term", "intent", "hyde"]),
+    text: z.string(),
+  })
+  .strict();
+
+const stringList = z.array(z.string());
+const positiveInteger = z.number().int().positive();
+const nonnegativeInteger = z.number().int().nonnegative();
+
+/** Host-owned index identity is deliberately absent from this public input. */
+export const contextBuildSurfaceSchema = z
+  .object({
+    goal: z.string(),
+    query: z.string().optional(),
+    collections: stringList.optional(),
+    uriPrefix: z.string().nullable().optional(),
+    queryModes: z.array(queryModeSchema).optional(),
+    tagsAll: stringList.optional(),
+    tagsAny: stringList.optional(),
+    categories: stringList.optional(),
+    author: z.string().optional(),
+    lang: z.string().optional(),
+    since: z.string().optional(),
+    until: z.string().optional(),
+    graph: z.boolean().optional(),
+    limit: positiveInteger.optional(),
+    candidateLimit: positiveInteger.optional(),
+    budgetTokens: positiveInteger,
+    budgetBytes: positiveInteger.optional(),
+    safetyMarginTokens: nonnegativeInteger.optional(),
+    safetyMarginBytes: nonnegativeInteger.optional(),
+    depthPolicy: z.enum(["fast", "balanced", "thorough"]).optional(),
+    format: z.enum(["json", "md"]).optional(),
+  })
+  .strict();
+
+export const contextVerifySurfaceSchema = z
+  .object({
+    capsule: z.record(z.string(), z.unknown()),
+    format: z.enum(["json", "md"]).optional(),
+  })
+  .strict();
+
+export type ContextSurfaceFormat = "json" | "md";
+
+export interface ParsedContextBuildSurfaceInput {
+  input: ContextCapsuleBuildInput;
+  format: ContextSurfaceFormat;
+}
+
+export interface ParsedContextVerifySurfaceInput {
+  capsule: Record<string, unknown>;
+  format: ContextSurfaceFormat;
+}
+
+const CONTEXT_SURFACE_ERROR_MESSAGES = {
+  capsule_mutated_during_verify:
+    "The Context Capsule changed during verification.",
+  chunk_coordinate_mismatch:
+    "Indexed evidence coordinates do not match the source.",
+  chunk_load_failed: "Context Capsule evidence chunks could not be loaded.",
+  collection_load_failed: "Context Capsule collections could not be loaded.",
+  content_load_failed: "Context Capsule source content could not be loaded.",
+  context_changed_during_compile:
+    "Configured context changed during compilation.",
+  context_changed_during_verify:
+    "Configured context changed during verification.",
+  context_load_failed: "Configured context could not be loaded.",
+  document_load_failed: "Context Capsule documents could not be loaded.",
+  identity_mismatch: "The Context Capsule identity does not match its content.",
+  index_changed_during_compile: "The index changed during compilation.",
+  index_changed_during_verify: "The index changed during verification.",
+  index_snapshot_failed: "The index snapshot could not be loaded.",
+  index_snapshot_mismatch:
+    "Indexed evidence does not match the captured snapshot.",
+  invalid_budget: "The Context Capsule budget is invalid.",
+  invalid_filter: "A Context Capsule filter is invalid.",
+  invalid_goal: "The Context Capsule goal is invalid.",
+  invalid_input: "The Context Capsule request is invalid.",
+  invalid_uri: "The Context Capsule URI is invalid.",
+  no_evidence: "No in-scope evidence was available for the Context Capsule.",
+  retrieval_failed: "Context Capsule retrieval failed.",
+  runtime_error: "The Context Capsule request failed.",
+  stored_provenance_mismatch:
+    "Stored evidence provenance does not match the source.",
+  tokenizer_unavailable: "The required tokenizer is unavailable.",
+} as const;
+
+export type ContextSurfaceErrorCode =
+  keyof typeof CONTEXT_SURFACE_ERROR_MESSAGES;
+
+const invalidInput = (error: z.ZodError): ContextCapsuleContractError =>
+  new ContextCapsuleContractError(
+    "invalid_input",
+    error.issues
+      .map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`)
+      .join("; ")
+  );
+
+export const parseContextBuildSurfaceInput = (
+  value: unknown,
+  indexName: string
+): ParsedContextBuildSurfaceInput => {
+  const parsed = contextBuildSurfaceSchema.safeParse(value);
+  if (!parsed.success) throw invalidInput(parsed.error);
+  const { format = "json", ...input } = parsed.data;
+  return { input: { ...input, indexName }, format };
+};
+
+export const parseContextVerifySurfaceInput = (
+  value: unknown
+): ParsedContextVerifySurfaceInput => {
+  const parsed = contextVerifySurfaceSchema.safeParse(value);
+  if (!parsed.success) throw invalidInput(parsed.error);
+  return {
+    capsule: parsed.data.capsule,
+    format: parsed.data.format ?? "json",
+  };
+};
+
+export const contextSurfaceError = (
+  error: unknown
+): { code: ContextSurfaceErrorCode; message: string } => {
+  const candidate =
+    error !== null &&
+    typeof error === "object" &&
+    "code" in error &&
+    typeof error.code === "string"
+      ? error.code
+      : "runtime_error";
+  const code = Object.hasOwn(CONTEXT_SURFACE_ERROR_MESSAGES, candidate)
+    ? (candidate as ContextSurfaceErrorCode)
+    : "runtime_error";
+  return { code, message: CONTEXT_SURFACE_ERROR_MESSAGES[code] };
+};

package/src/cli/commands/context-build.ts

@@ -0,0 +1,149 @@
+/** Context Capsule build command over the shared application runtime. */
+
+import type { ContextCapsuleBuildInput } from "../../app/context-runtime";
+import type { EmbeddingPort, RerankPort } from "../../llm/types";
+import type { VectorIndexPort } from "../../store/vector";
+
+import { formatContextCapsuleMarkdown } from "../../app/context-format";
+import {
+  buildContextCapsule,
+  canonicalBuiltContextCapsuleJson,
+  validateContextCapsuleBuildInput,
+} from "../../app/context-runtime";
+import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
+import { resolveDownloadPolicy } from "../../llm/policy";
+import { resolveModelUri } from "../../llm/registry";
+import { createVectorIndexPort } from "../../store/vector";
+import { CliError } from "../errors";
+import { getGlobals } from "../program";
+import {
+  createProgressRenderer,
+  createThrottledProgressRenderer,
+} from "../progress";
+import { initStore } from "./shared";
+
+export interface ContextBuildCommandOptions extends Omit<
+  ContextCapsuleBuildInput,
+  "goal"
+> {
+  configPath?: string;
+  format: "json" | "md";
+}
+
+const validationCodes = new Set([
+  "identity_mismatch",
+  "invalid_budget",
+  "invalid_filter",
+  "invalid_goal",
+  "invalid_input",
+  "invalid_uri",
+]);
+
+export const contextCliError = (error: unknown): CliError => {
+  const contextCode =
+    error !== null &&
+    typeof error === "object" &&
+    "code" in error &&
+    typeof error.code === "string"
+      ? error.code
+      : "runtime_error";
+  return new CliError(
+    validationCodes.has(contextCode) ? "VALIDATION" : "RUNTIME",
+    error instanceof Error ? error.message : String(error),
+    { details: { contextCode } }
+  );
+};
+
+// oxlint-disable-next-line max-lines-per-function -- owns one bounded model/store lifecycle
+export const contextBuild = async (
+  goal: string,
+  options: ContextBuildCommandOptions
+): Promise<string> => {
+  try {
+    validateContextCapsuleBuildInput({ goal, ...options }, options.indexName);
+  } catch (error) {
+    throw contextCliError(error);
+  }
+  const initResult = await initStore({
+    configPath: options.configPath,
+    indexName: options.indexName,
+    syncConfig: true,
+  });
+  if (!initResult.ok) {
+    throw new CliError("RUNTIME", initResult.error);
+  }
+  const { config, store } = initResult;
+  const llm = new LlmAdapter(config);
+  let embedPort: EmbeddingPort | null = null;
+  let rerankPort: RerankPort | null = null;
+  let vectorIndex: VectorIndexPort | null = null;
+  try {
+    validateContextCapsuleBuildInput(
+      { goal, ...options },
+      options.indexName,
+      config.collections.map((collection) => collection.name)
+    );
+    if (options.depthPolicy !== "fast") {
+      const globals = getGlobals();
+      const policy = resolveDownloadPolicy(process.env, {
+        offline: globals.offline,
+      });
+      const showProgress = process.stderr.isTTY && !globals.quiet;
+      const progress = showProgress
+        ? createThrottledProgressRenderer(createProgressRenderer())
+        : undefined;
+      const collection =
+        options.collections?.length === 1 ? options.collections[0] : undefined;
+      const embedUri = resolveModelUri(config, "embed", undefined, collection);
+      const embedResult = await llm.createEmbeddingPort(embedUri, {
+        policy,
+        onProgress: progress ? (value) => progress("embed", value) : undefined,
+      });
+      if (embedResult.ok) {
+        embedPort = embedResult.value;
+        const initialized = await embedPort.init();
+        if (initialized.ok) {
+          const vectorResult = await createVectorIndexPort(store.getRawDb(), {
+            model: embedUri,
+            dimensions: embedPort.dimensions(),
+          });
+          if (vectorResult.ok) vectorIndex = vectorResult.value;
+        }
+      }
+      const rerankUri = resolveModelUri(
+        config,
+        "rerank",
+        undefined,
+        collection
+      );
+      const rerankResult = await llm.createRerankPort(rerankUri, {
+        policy,
+        onProgress: progress ? (value) => progress("rerank", value) : undefined,
+      });
+      if (rerankResult.ok) rerankPort = rerankResult.value;
+      if (showProgress && progress) process.stderr.write("\n");
+    }
+    const capsule = await buildContextCapsule(
+      { goal, ...options },
+      {
+        store,
+        config,
+        indexName: options.indexName,
+        vectorIndex,
+        embedPort,
+        rerankPort,
+      }
+    );
+    return options.format === "md"
+      ? formatContextCapsuleMarkdown(capsule)
+      : canonicalBuiltContextCapsuleJson(capsule);
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw contextCliError(error);
+  } finally {
+    await embedPort?.dispose();
+    await rerankPort?.dispose();
+    await llm.dispose();
+    await store.close();
+  }
+};

package/src/cli/commands/context-verify.ts

@@ -0,0 +1,90 @@
+/** Context Capsule verification command over the shared application runtime. */
+
+import { formatContextCapsuleVerificationMarkdown } from "../../app/context-format";
+import {
+  canonicalVerifiedContextCapsuleJson,
+  verifyContextCapsuleRuntime,
+} from "../../app/context-runtime";
+import { canonicalizeIndexName } from "../../app/index-name";
+import { parseCanonicalContextCapsuleForVerification } from "../../core/context-verifier";
+import { CliError } from "../errors";
+import { contextCliError } from "./context-build";
+import { initStore } from "./shared";
+
+export interface ContextVerifyCommandOptions {
+  configPath?: string;
+  indexName?: string;
+  format: "json" | "md";
+}
+
+const readCapsule = async (source: string): Promise<unknown> => {
+  let raw: string;
+  try {
+    raw =
+      source === "-" ? await Bun.stdin.text() : await Bun.file(source).text();
+  } catch (error) {
+    throw new CliError(
+      "RUNTIME",
+      `Failed to read Context Capsule: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+  try {
+    return JSON.parse(raw) as unknown;
+  } catch (error) {
+    throw new CliError("VALIDATION", "Context Capsule must be valid JSON", {
+      details: {
+        contextCode: "invalid_input",
+        cause: error instanceof Error ? error.message : String(error),
+      },
+    });
+  }
+};
+
+export const contextVerify = async (
+  source: string,
+  options: ContextVerifyCommandOptions
+): Promise<string> => {
+  const input = await readCapsule(source);
+  let capsule: ReturnType<typeof parseCanonicalContextCapsuleForVerification>;
+  try {
+    capsule = parseCanonicalContextCapsuleForVerification(input);
+  } catch (error) {
+    throw contextCliError(error);
+  }
+  if (
+    options.indexName !== undefined &&
+    canonicalizeIndexName(options.indexName) !== capsule.scope.indexName
+  ) {
+    throw new CliError(
+      "VALIDATION",
+      `Context Capsule index ${capsule.scope.indexName} does not match --index ${options.indexName}`,
+      { details: { contextCode: "invalid_filter" } }
+    );
+  }
+  const initResult = await initStore({
+    configPath: options.configPath,
+    indexName: capsule.scope.indexName,
+    syncConfig: true,
+  });
+  if (!initResult.ok) {
+    throw new CliError("RUNTIME", initResult.error);
+  }
+  const { config, store } = initResult;
+  try {
+    const receipt = await verifyContextCapsuleRuntime(capsule, {
+      store,
+      config,
+      indexName: capsule.scope.indexName,
+    });
+    return options.format === "md"
+      ? formatContextCapsuleVerificationMarkdown(receipt)
+      : canonicalVerifiedContextCapsuleJson(receipt);
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw contextCliError(error);
+  } finally {
+    await store.close();
+  }
+};

package/src/cli/commands/daemon.ts

@@ -1,9 +1,18 @@
 import type { CollectionSyncResult } from "../../ingestion";
+import type { HttpGatewayOverrides } from "../../mcp/http-security";
 import type { BackgroundRuntimeResult } from "../../serve/background-runtime";
+import type { ResidentRuntime } from "../../serve/resident-runtime";
 
+import {
+  DEFAULT_HTTP_GATEWAY_PORT,
+  isHttpGatewayLoopbackBind,
+  resolveHttpGatewayConfig,
+} from "../../mcp/http-security";
 import { startBackgroundRuntime } from "../../serve/background-runtime";
+import { handleResidentStatus, handleStatus } from "../../serve/routes/api";
+import { createMcpHttpGateway } from "../../serve/routes/mcp";
 
-export interface DaemonOptions {
+export interface DaemonOptions extends HttpGatewayOverrides {
   configPath?: string;
   index?: string;
   offline?: boolean;
@@ -24,6 +33,8 @@ type DaemonLogger = {
 
 type DaemonDeps = {
   startBackgroundRuntime?: typeof startBackgroundRuntime;
+  createMcpHttpGateway?: typeof createMcpHttpGateway;
+  serve?: typeof Bun.serve;
   logger?: DaemonLogger;
 };
 
@@ -31,6 +42,18 @@ function formatCollectionSyncSummary(result: CollectionSyncResult): string {
   return `${result.collection}: ${result.filesAdded} added, ${result.filesUpdated} updated, ${result.filesUnchanged} unchanged, ${result.filesErrored} errors`;
 }
 
+export function handleDaemonAppStatus(
+  runtime: ResidentRuntime,
+  host: string
+): Promise<Response> | Response {
+  if (!isHttpGatewayLoopbackBind(host)) {
+    return new Response(null, { status: 404 });
+  }
+  return handleStatus(runtime.ctxHolder.current, {
+    getResidentStatus: () => runtime.getStatus(),
+  });
+}
+
 function createSignalPromise(
   signal: AbortSignal | undefined,
   logger: DaemonLogger,
@@ -79,6 +102,7 @@ export async function daemon(
   const runtimeResult: BackgroundRuntimeResult = await (
     deps.startBackgroundRuntime ?? startBackgroundRuntime
   )({
+    mode: "daemon",
     configPath: options.configPath,
     index: options.index,
     requireCollections: true,
@@ -108,11 +132,52 @@ export async function daemon(
   }
 
   const { runtime } = runtimeResult;
+  const gatewayConfig = resolveHttpGatewayConfig(runtime.config.gateway, {
+    host: options.host,
+    port: options.port ?? DEFAULT_HTTP_GATEWAY_PORT,
+    tokenFile: options.tokenFile,
+    allowedHosts: options.allowedHosts,
+    allowedOrigins: options.allowedOrigins,
+    enableWrite: options.enableWrite,
+  });
+  let gateway: Awaited<ReturnType<typeof createMcpHttpGateway>> | undefined;
+  let server: ReturnType<typeof Bun.serve> | undefined;
   try {
+    gateway = await (deps.createMcpHttpGateway ?? createMcpHttpGateway)(
+      runtime as ResidentRuntime,
+      gatewayConfig
+    );
+    server = (deps.serve ?? Bun.serve)({
+      port: gatewayConfig.port,
+      hostname: gatewayConfig.host,
+      development: false,
+      routes: {
+        "/mcp": gateway.route,
+        "/api/status": {
+          GET: () =>
+            handleDaemonAppStatus(
+              runtime as ResidentRuntime,
+              gatewayConfig.host
+            ),
+        },
+        "/api/resident/status": {
+          GET: () =>
+            handleResidentStatus(() =>
+              (runtime as ResidentRuntime).getStatus()
+            ),
+        },
+      },
+    });
+    (runtime as Partial<ResidentRuntime>).setListenerPort?.(
+      server.port ?? gatewayConfig.port
+    );
     if (!options.quiet) {
       logger.log(
         `GNO daemon started for index "${options.index ?? "default"}" using ${runtime.config.collections.length} collection${runtime.config.collections.length === 1 ? "" : "s"}.`
       );
+      logger.log(
+        `MCP gateway listening at http://${gatewayConfig.host}:${server.port}/mcp`
+      );
       const watchState = runtime.watchService.getState();
       if (watchState.activeCollections.length > 0) {
         logger.log(`watching: ${watchState.activeCollections.join(", ")}`);
@@ -154,6 +219,8 @@ export async function daemon(
       error: error instanceof Error ? error.message : String(error),
     };
   } finally {
-    await runtime.dispose();
+    await Promise.allSettled([server?.stop(true)]);
+    await Promise.allSettled([gateway?.close()]);
+    await Promise.allSettled([runtime.dispose()]);
   }
 }

package/src/cli/commands/models/pull.ts

@@ -35,6 +35,8 @@ export interface ModelsPullOptions {
   force?: boolean;
   /** Progress callback for UI (omit to disable progress) */
   onProgress?: (type: ModelType, progress: DownloadProgress) => void;
+  /** Stop before the next model and suppress subsequent work. */
+  signal?: AbortSignal;
 }
 
 export interface ModelPullResult {
@@ -52,6 +54,10 @@ export interface ModelsPullResult {
   skipped: number;
 }
 
+export interface ModelsPullDependencies {
+  cache?: Pick<ModelCache, "download" | "getCachedPath" | "isCached">;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Implementation
 // ─────────────────────────────────────────────────────────────────────────────
@@ -87,7 +93,8 @@ function getTypesToPull(options: ModelsPullOptions): ModelType[] {
  * Execute gno models pull command.
  */
 export async function modelsPull(
-  options: ModelsPullOptions = {}
+  options: ModelsPullOptions = {},
+  deps: ModelsPullDependencies = {}
 ): Promise<ModelsPullResult> {
   // Use provided config, or load from disk (use defaults if not initialized)
   let config = options.config;
@@ -98,7 +105,7 @@ export async function modelsPull(
   }
 
   const preset = getActivePreset(config);
-  const cache = new ModelCache(getModelsCachePath());
+  const cache = deps.cache ?? new ModelCache(getModelsCachePath());
   const types = getTypesToPull(options);
 
   const results: ModelPullResult[] = [];
@@ -106,6 +113,7 @@ export async function modelsPull(
   let skipped = 0;
 
   for (const type of types) {
+    if (options.signal?.aborted) break;
     const uri =
       type === "expand" ? (preset.expand ?? preset.gen) : preset[type];
 
@@ -133,8 +141,10 @@ export async function modelsPull(
       (progress) => {
         options.onProgress?.(type, progress);
       },
-      options.force
+      options.force,
+      options.signal
     );
+    if (options.signal?.aborted) break;
 
     if (result.ok) {
       results.push({

package/src/cli/commands/status.ts

@@ -15,6 +15,7 @@ import { buildActivationStatus } from "../../core/activation-status";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
 import { getConnectorVerificationTargets } from "../../serve/connectors";
+import { createStandaloneResidentStatus } from "../../serve/resident-status";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
 
 /**
@@ -277,6 +278,7 @@ export function formatStatus(
     const s = result.status;
     return JSON.stringify(
       {
+        resident: createStandaloneResidentStatus("direct-cli"),
         indexName: s.indexName,
         configPath: s.configPath,
         dbPath: s.dbPath,

package/src/cli/detach.ts

@@ -20,9 +20,12 @@ import { mkdir, stat, unlink } from "node:fs/promises";
 // node:path — no Bun path utils.
 import { dirname, join } from "node:path";
 
+import type { ResidentStatus } from "../serve/status-model";
+
 import { VERSION, resolveDirs } from "../app/constants";
 import { toAbsolutePath } from "../config/paths";
 import { atomicWrite } from "../core/file-ops";
+import { isResidentStatus } from "../serve/resident-status";
 import { CliError } from "./errors";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -63,6 +66,7 @@ export interface ProcessStatus {
   version: string | null;
   started_at: string | null;
   uptime_seconds: number | null;
+  resident: ResidentStatus | null;
   pid_file: string;
   log_file: string;
   log_size_bytes: number | null;
@@ -424,7 +428,7 @@ export interface SpawnDetachedOptions {
    * self-contained executable like a single `.mjs` file).
    */
   entryScript?: string | null;
-  /** Optional port to embed in the pid-file payload (serve only). */
+  /** Optional resident HTTP port to embed in the pid-file payload. */
   port?: number | null;
   /** Working directory for the child. Defaults to `process.cwd()`. */
   cwd?: string;
@@ -736,6 +740,23 @@ export interface StatusOptions {
   logFile: string;
   /** Clock override for deterministic tests. Defaults to `Date.now`. */
   now?: () => number;
+  fetchResidentStatus?: (port: number) => Promise<ResidentStatus | null>;
+}
+
+async function fetchResidentStatus(
+  port: number
+): Promise<ResidentStatus | null> {
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${port}/api/resident/status`,
+      { signal: AbortSignal.timeout(500) }
+    );
+    if (!response.ok) return null;
+    const body: unknown = await response.json();
+    return isResidentStatus(body) ? body : null;
+  } catch {
+    return null;
+  }
 }
 
 /**
@@ -765,6 +786,7 @@ export async function statusProcess(
       version: null,
       started_at: null,
       uptime_seconds: null,
+      resident: null,
       pid_file: options.pidFile,
       log_file: options.logFile,
       log_size_bytes: logSize,
@@ -789,33 +811,28 @@ export async function statusProcess(
     ? Math.max(0, Math.floor((now() - Date.parse(payload.started_at)) / 1000))
     : null;
 
-  // Schema invariant: a live serve must report a numeric port. If the pid-file
-  // is missing one somehow, fall back to not-running rather than lying.
-  const portForRunningServe =
-    running && effectiveKind === "serve"
-      ? typeof payload.port === "number"
-        ? payload.port
-        : null
-      : running && effectiveKind === "daemon"
-        ? null
-        : (payload.port ?? null);
-
-  const runningFinal =
-    running && !(effectiveKind === "serve" && portForRunningServe === null);
+  // Both resident modes expose an HTTP listener. If a live pid-file is
+  // missing its port, fall back to not-running rather than claiming a gateway
+  // that clients cannot locate.
+  const portForRunningProcess =
+    running && typeof payload.port === "number" ? payload.port : null;
+  const runningFinal = running && portForRunningProcess !== null;
+  const resident =
+    runningFinal && portForRunningProcess !== null
+      ? await (options.fetchResidentStatus ?? fetchResidentStatus)(
+          portForRunningProcess
+        )
+      : null;
 
   return {
     running: runningFinal,
     pid: payload.pid,
-    port:
-      runningFinal && effectiveKind === "serve"
-        ? portForRunningServe
-        : effectiveKind === "daemon"
-          ? null
-          : (payload.port ?? null),
+    port: runningFinal ? portForRunningProcess : (payload.port ?? null),
     cmd: effectiveKind,
     version: payload.version,
     started_at: payload.started_at,
     uptime_seconds: runningFinal ? uptimeSeconds : null,
+    resident,
     pid_file: options.pidFile,
     log_file: options.logFile,
     log_size_bytes: logSize,