@gmickel/gno 2.5.1 → 2.7.0

package/src/serve/public/pages/Sessions.tsx

@@ -0,0 +1,350 @@
+import {
+  ArchiveIcon,
+  InfoIcon,
+  Loader2Icon,
+  MessagesSquareIcon,
+} from "lucide-react";
+import {
+  type FormEvent,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+} from "react";
+
+import type {
+  SessionImportReceipt,
+  SessionsStatus,
+} from "../components/sessions/api";
+
+import { sessionsApi } from "../components/sessions/api";
+import { AutomationPanel } from "../components/sessions/AutomationPanel";
+import { SessionSearch } from "../components/sessions/SessionSearch";
+import { SourcesPanel } from "../components/sessions/SourcesPanel";
+import { Badge } from "../components/ui/badge";
+import { Button } from "../components/ui/button";
+import { Card, CardContent } from "../components/ui/card";
+import { Input } from "../components/ui/input";
+import { fetchServerCapabilities } from "../lib/server-capabilities";
+
+interface PageProps {
+  navigate: (to: string | number) => void;
+}
+
+/** Codes meaning "this instance is not a usable session archive". */
+const UNBOUND_CODES = new Set([
+  "SESSIONS_NOT_CONFIGURED",
+  "SESSIONS_BINDING_MISMATCH",
+]);
+
+const INIT_COMMAND =
+  "gno --config <archive.yml> --index sessions sessions init --archive <dir> --collection <name>";
+const SERVE_COMMAND = "gno --config <archive.yml> --index sessions serve";
+
+function CommandLine({ children }: { children: string }) {
+  return (
+    <code className="block whitespace-pre-wrap break-all rounded-md border border-border/60 bg-muted/40 px-3 py-2 font-mono text-xs">
+      {children}
+    </code>
+  );
+}
+
+function InitForm({ onDone }: { onDone: () => Promise<void> }) {
+  const [archive, setArchive] = useState("");
+  const [collection, setCollection] = useState("sessions");
+  const [error, setError] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
+
+  const submit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    setSaving(true);
+    const result = await sessionsApi("/api/sessions/init", {
+      method: "POST",
+      body: JSON.stringify({
+        archive: archive.trim(),
+        collection: collection.trim(),
+      }),
+    });
+    setSaving(false);
+    if (result.error) {
+      setError(result.error);
+      return;
+    }
+    setError(null);
+    await onDone();
+  };
+
+  return (
+    <form
+      aria-label="Create session archive"
+      className="grid gap-3 sm:grid-cols-2"
+      onSubmit={(event) => void submit(event)}
+    >
+      <label className="grid gap-1 text-sm" htmlFor="sessions-init-archive">
+        Archive directory (absolute path)
+        <Input
+          id="sessions-init-archive"
+          onChange={(event) => setArchive(event.currentTarget.value)}
+          placeholder="/home/me/agent-archive"
+          required
+          value={archive}
+        />
+      </label>
+      <label className="grid gap-1 text-sm" htmlFor="sessions-init-collection">
+        First archive collection
+        <Input
+          id="sessions-init-collection"
+          onChange={(event) => setCollection(event.currentTarget.value)}
+          pattern="[a-z0-9][a-z0-9_-]{0,63}"
+          required
+          value={collection}
+        />
+      </label>
+      {error && (
+        <p
+          className="break-words text-destructive text-sm sm:col-span-2"
+          role="alert"
+        >
+          {error}
+        </p>
+      )}
+      <div className="sm:col-span-2">
+        <Button disabled={saving} type="submit">
+          {saving && <Loader2Icon className="animate-spin" />}
+          Create archive for this instance
+        </Button>
+        <p className="mt-2 text-muted-foreground text-xs">
+          Only works when this server was started with a dedicated archive
+          config and a named index; the default config is refused.
+        </p>
+      </div>
+    </form>
+  );
+}
+
+export default function Sessions({ navigate }: PageProps) {
+  const [status, setStatus] = useState<SessionsStatus | null>(null);
+  const [unbound, setUnbound] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [localClient, setLocalClient] = useState(false);
+  const [busy, setBusy] = useState<string | null>(null);
+  const [receipts, setReceipts] = useState<
+    Record<string, SessionImportReceipt>
+  >({});
+  // Bumped when an action (import/remove) fails so focus moves to the alert
+  // instead of dropping to <body> from the disabled button.
+  const [actionErrorCount, setActionErrorCount] = useState(0);
+  const errorRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (actionErrorCount > 0) errorRef.current?.focus();
+  }, [actionErrorCount]);
+
+  const loadStatus = useCallback(async () => {
+    const result = await sessionsApi<SessionsStatus>("/api/sessions/status");
+    setLoading(false);
+    if (result.data) {
+      setStatus(result.data);
+      setUnbound(null);
+      setError(null);
+      return;
+    }
+    if (result.sessionsCode && UNBOUND_CODES.has(result.sessionsCode)) {
+      setStatus(null);
+      setUnbound(result.error);
+      setError(null);
+      return;
+    }
+    // A transient failure (for example during background polling) keeps the
+    // last good status on screen, so run monitoring and controls survive.
+    setError(result.error);
+  }, []);
+
+  useEffect(() => {
+    void loadStatus();
+    void fetchServerCapabilities().then(({ data }) => {
+      setLocalClient(data?.localClient === true);
+    });
+  }, [loadStatus]);
+
+  const runImport = async (sourceId: string, dryRun: boolean) => {
+    setBusy(`${sourceId}:${dryRun ? "preview" : "import"}`);
+    const result = await sessionsApi<SessionImportReceipt>(
+      "/api/sessions/import",
+      {
+        method: "POST",
+        body: JSON.stringify({ sourceId, dryRun }),
+      }
+    );
+    setBusy(null);
+    if (!result.data) {
+      setError(result.error);
+      setActionErrorCount((count) => count + 1);
+      return;
+    }
+    const receipt = result.data;
+    setError(null);
+    setReceipts((current) => ({ ...current, [sourceId]: receipt }));
+    if (!dryRun) await loadStatus();
+  };
+
+  const removeSource = async (sourceId: string) => {
+    setBusy(`${sourceId}:remove`);
+    const result = await sessionsApi(
+      `/api/sessions/sources/${encodeURIComponent(sourceId)}`,
+      { method: "DELETE" }
+    );
+    setBusy(null);
+    if (result.error) {
+      setError(result.error);
+      setActionErrorCount((count) => count + 1);
+      return;
+    }
+    setReceipts((current) => {
+      const next = { ...current };
+      delete next[sourceId];
+      return next;
+    });
+    await loadStatus();
+  };
+
+  const archiveCollections = status?.collections.map((c) => c.name) ?? [];
+
+  return (
+    <div className="min-h-screen">
+      <main className="mx-auto max-w-5xl space-y-8 px-4 py-6 sm:p-8">
+        <header className="flex flex-wrap items-start justify-between gap-4">
+          <div className="min-w-0 max-w-3xl space-y-3">
+            <div className="flex items-center gap-2 text-primary">
+              <ArchiveIcon aria-hidden="true" className="size-4" />
+              <span className="font-medium text-sm tracking-wide uppercase">
+                Agent session archive
+              </span>
+            </div>
+            <h1 className="font-semibold text-2xl tracking-tight sm:text-3xl">
+              Agent sessions
+            </h1>
+            {status && (
+              <p className="flex flex-wrap items-center gap-2 text-sm">
+                <span className="text-muted-foreground">Archive index</span>
+                <Badge className="font-mono" variant="secondary">
+                  {status.index}
+                </Badge>
+                <span className="text-muted-foreground">
+                  · {status.collections.length} collection
+                  {status.collections.length === 1 ? "" : "s"}
+                </span>
+              </p>
+            )}
+            <p className="text-muted-foreground text-sm">
+              Import is manual by default. Nothing watches your agents or
+              imports on its own unless you switch on a hook or schedule below.
+            </p>
+          </div>
+          <Button onClick={() => navigate("/")} variant="outline">
+            Back to Dashboard
+          </Button>
+        </header>
+
+        <aside className="flex gap-3 rounded-lg border border-border/60 bg-muted/30 p-4 text-sm">
+          <InfoIcon
+            aria-hidden="true"
+            className="mt-0.5 size-4 shrink-0 text-primary"
+          />
+          <p className="min-w-0">
+            This archive index is separate from your curated index. Broad search
+            in a curated instance does not include archived sessions unless you
+            explicitly register an archive collection in that index. Human turns
+            are what you wrote; assistant turns are agent output — suggestions,
+            not your decisions.
+          </p>
+        </aside>
+
+        {error && (
+          <Card className="border-destructive bg-destructive/10">
+            <CardContent
+              className="break-words py-4 text-destructive outline-none focus-visible:ring-2 focus-visible:ring-ring/50"
+              ref={errorRef}
+              role="alert"
+              tabIndex={-1}
+            >
+              {error}
+            </CardContent>
+          </Card>
+        )}
+
+        {loading && (
+          <p className="flex items-center gap-2 text-muted-foreground">
+            <Loader2Icon className="size-4 animate-spin" />
+            Loading archive status…
+          </p>
+        )}
+
+        {unbound !== null && (
+          <section
+            aria-labelledby="sessions-unbound-heading"
+            className="space-y-4 rounded-lg border border-dashed border-border/70 p-4 sm:p-6"
+          >
+            <div className="flex items-center gap-2">
+              <MessagesSquareIcon
+                aria-hidden="true"
+                className="size-5 text-primary"
+              />
+              <h2
+                className="font-semibold text-xl"
+                id="sessions-unbound-heading"
+              >
+                This server is not a session archive
+              </h2>
+            </div>
+            <p className="break-words text-muted-foreground text-sm">
+              {unbound}
+            </p>
+            <p className="text-sm">
+              Session archives live in their own config file and named index.
+              Create one, then start a server for it:
+            </p>
+            <CommandLine>{INIT_COMMAND}</CommandLine>
+            <CommandLine>{SERVE_COMMAND}</CommandLine>
+            {localClient && <InitForm onDone={loadStatus} />}
+          </section>
+        )}
+
+        {status && (
+          <>
+            {status.warnings.length > 0 && (
+              <ul className="list-disc space-y-1 pl-5 text-amber-800 text-sm dark:text-amber-200">
+                {status.warnings.map((warning) => (
+                  <li className="break-words" key={warning}>
+                    {warning}
+                  </li>
+                ))}
+              </ul>
+            )}
+            <SourcesPanel
+              archiveCollections={archiveCollections}
+              busy={busy}
+              localClient={localClient}
+              onChanged={loadStatus}
+              onImport={(sourceId, dryRun) => void runImport(sourceId, dryRun)}
+              onRemove={(sourceId) => void removeSource(sourceId)}
+              receipts={receipts}
+              sources={status.sources}
+            />
+            <AutomationPanel
+              automation={status.automation}
+              localClient={localClient}
+              onChanged={loadStatus}
+              sources={status.sources}
+            />
+            <SessionSearch
+              collections={archiveCollections}
+              navigate={(to) => navigate(to)}
+            />
+          </>
+        )}
+      </main>
+    </div>
+  );
+}

package/src/serve/resident-runtime.ts

@@ -9,6 +9,7 @@ import type { SyncResult } from "../ingestion";
 import type { ModelManager } from "../llm/nodeLlamaCpp/lifecycle";
 import type { ToolContext } from "../mcp/context";
 import type { HttpMcpTransportStatus } from "../mcp/http-transport";
+import type { SessionAutomationRunResult } from "../sessions/types";
 import type { DocumentEventBus } from "./doc-events";
 import type { EmbedResult, EmbedScheduler } from "./embed-scheduler";
 import type { ContextHolder } from "./routes/api";
@@ -44,13 +45,16 @@ import { JobManager } from "../core/job-manager";
 import { recordContentMutation } from "../core/mutation-generations";
 import {
   shutdownDuration,
+  RESIDENT_BUSY_TIMEOUT_MS,
   SHUTDOWN_DRAIN_MS,
   SHUTDOWN_ABORT_MS,
 } from "../core/shutdown-budget";
+import { acquireCliWriteLease } from "../core/write-lease";
 import { defaultSyncService, withContentTypeRules } from "../ingestion";
 import { withOwnedInferenceScope } from "../llm/inference-scope";
 import { getActivePreset } from "../llm/registry";
 import { createToolContext, Mutex } from "../mcp/context";
+import { watchedCollections } from "../sessions/config";
 import { SqliteAdapter } from "../store/sqlite/adapter";
 import {
   createServerContext,
@@ -58,7 +62,7 @@ import {
   disposeServerContext,
   type ServerContext,
 } from "./context";
-import { createEmbedScheduler } from "./embed-scheduler";
+import { createEmbedScheduler, embedSchedulerIssues } from "./embed-scheduler";
 import { FindingsScheduler, type FindingsPassResult } from "./findings-pass";
 import { AdmissionController, ReaderGate } from "./resident-admission";
 import { ResidentBackgroundWork } from "./resident-background-work";
@@ -67,6 +71,10 @@ import {
   createStandaloneResidentStatus,
   buildResidentStatusSnapshot,
 } from "./resident-status";
+import {
+  notifyAutomationImport,
+  SessionAutomationScheduler,
+} from "./session-automation";
 import { CollectionWatchService as DefaultCollectionWatchService } from "./watch-service";
 
 const OWNER_LOCK_TIMEOUT_MS = 0;
@@ -83,6 +91,9 @@ export interface ResidentRuntimeOptions {
   watchCallbacks?: CollectionWatchCallbacks;
   /** Daemon mode only: observes every scheduled findings-pass attempt. */
   onFindingsResult?: (result: FindingsPassResult) => void;
+  /** Daemon mode on a session archive: observes every automation run. */
+  onSessionAutomationResult?: (result: SessionAutomationRunResult) => void;
+  onSessionAutomationError?: (error: unknown) => void;
   readerLimit?: number;
   readerQueueLimit?: number;
   shutdownDeadlineMs?: number;
@@ -117,6 +128,8 @@ export interface ResidentRuntime {
   readonly capsuleReverificationScheduler: SavedCapsuleReverificationScheduler;
   /** Present only when daemon mode runs with `findings.enabled`. */
   readonly findingsScheduler: FindingsScheduler | null;
+  /** Present only when daemon mode runs on a session-archive config. */
+  readonly sessionAutomation: SessionAutomationScheduler | null;
   readonly modelManager: Pick<
     ModelManager,
     "acquireLease" | "getLifecycleStats" | "disposeAll"
@@ -178,10 +191,25 @@ export type ResidentRuntimeDeps = {
     eventBus?: DocumentEventBus | null;
     callbacks?: CollectionWatchCallbacks;
     syncOptions?: Parameters<typeof withContentTypeRules>[0];
+    acquireWriteLease?: () => Promise<(() => Promise<void>) | null>;
   }) => CollectionWatchService;
   modelManagerFactory?: (config: Config) => ModelManager;
 };
 
+/** No-wait shared writer lease for background writes; null when held elsewhere. */
+async function acquireBackgroundWriteLease(
+  dbPath: string,
+  command: string
+): Promise<(() => Promise<void>) | null> {
+  const lease = await acquireCliWriteLease({
+    dbPath,
+    waitMs: 0,
+    noWait: true,
+    command,
+  });
+  return lease.ok ? lease.release : null;
+}
+
 export async function startResidentRuntime(
   options: ResidentRuntimeOptions = {},
   deps: ResidentRuntimeDeps = {}
@@ -263,6 +291,11 @@ export async function startResidentRuntime(
   if (!syncCollections.ok) return failStartup(syncCollections.error.message);
   const syncContexts = await store.syncContexts(initialConfig.contexts ?? []);
   if (!syncContexts.ok) return failStartup(syncContexts.error.message);
+  // SQLite busy waits block this event loop; keep each one short enough that
+  // a stop signal is still handled within the stop grace.
+  store.setBusyTimeout?.(RESIDENT_BUSY_TIMEOUT_MS);
+  const leaseFor = (command: string) => () =>
+    acquireBackgroundWriteLease(dbPath, command);
 
   let ctx: ServerContext;
   try {
@@ -311,6 +344,7 @@ export async function startResidentRuntime(
     onEmbedded: () => {
       generations.index += 1;
     },
+    acquireWriteLease: leaseFor(`gno ${mode} (background embed)`),
   });
   ctxHolder.scheduler = scheduler;
   ctxHolder.current.scheduler = scheduler;
@@ -322,7 +356,7 @@ export async function startResidentRuntime(
     deps.watchServiceFactory ??
     ((watchOptions) => new DefaultCollectionWatchService(watchOptions))
   )({
-    collections: initialConfig.collections,
+    collections: watchedCollections(initialConfig),
     store,
     scheduler,
     eventBus: options.eventBus ?? null,
@@ -340,6 +374,7 @@ export async function startResidentRuntime(
       },
     },
     syncOptions: withContentTypeRules({}, initialConfig),
+    acquireWriteLease: leaseFor(`gno ${mode} (watch sync)`),
   });
   watchService.start();
   ctxHolder.watchService = watchService;
@@ -393,6 +428,31 @@ export async function startResidentRuntime(
     // otherwise keep reporting a schedule that no longer exists.
     await deleteFindingsRunState(findingsStatePath);
   }
+  // Session automation drains only in daemon mode on an archive config;
+  // `serve` never runs admitted hook work or schedules.
+  let sessionAutomation: SessionAutomationScheduler | null = null;
+  if (mode === "daemon" && initialConfig.sessions) {
+    sessionAutomation = new SessionAutomationScheduler({
+      store,
+      configPath: actualConfigPath,
+      indexName: canonicalizeIndexName(options.index ?? DEFAULT_INDEX_NAME),
+      dbPath,
+      startBackgroundWork: (operation) => backgroundWork.start(operation),
+      onResult: (result) => {
+        notifyAutomationImport(result, {
+          markMutation: () => {
+            generations.content += 1;
+            generations.index += 1;
+          },
+          notifySyncComplete: (collections) =>
+            scheduler.notifySyncComplete(collections),
+        });
+        options.onSessionAutomationResult?.(result);
+      },
+      onError: options.onSessionAutomationError,
+    });
+    sessionAutomation.start();
+  }
   capsuleReverificationScheduler = new SavedCapsuleReverificationScheduler({
     deps: {
       store,
@@ -412,7 +472,7 @@ export async function startResidentRuntime(
       ctxHolder.config = config;
       ctxHolder.current = { ...ctxHolder.current, config };
       ctxHolder.watchService?.updateCollections(
-        config.collections,
+        watchedCollections(config),
         withContentTypeRules({}, config)
       );
     },
@@ -475,6 +535,7 @@ export async function startResidentRuntime(
     jobManager,
     capsuleReverificationScheduler,
     findingsScheduler,
+    sessionAutomation,
     modelManager,
     mcpContext,
     generations,
@@ -553,6 +614,7 @@ export async function startResidentRuntime(
           failed: jobs.recent.filter((job) => job.status === "failed").length,
         },
         generations: { ...generations },
+        backgroundIssues: embedSchedulerIssues(scheduler.getState()),
       });
     },
     setListenerPort(port) {
@@ -621,7 +683,10 @@ export async function startResidentRuntime(
         mcpContext,
         modelManager,
         ownerLock,
-        stopFindings: () => findingsScheduler?.dispose(),
+        stopFindings: () => {
+          findingsScheduler?.dispose();
+          sessionAutomation?.dispose();
+        },
         stopCapsules: () => capsuleReverificationScheduler.dispose(),
         closeEvents: () => options.eventBus?.close(),
         disposeContext: deps.disposeServerContext ?? disposeServerContext,

package/src/serve/resident-status.ts

@@ -1,6 +1,10 @@
 /** Safe, transport-neutral resident lifecycle status projection. */
 
-import type { ResidentStatus, RuntimeMode } from "./status-model";
+import type {
+  BackgroundIssue,
+  ResidentStatus,
+  RuntimeMode,
+} from "./status-model";
 
 const EMPTY_MODELS: ResidentStatus["models"] = {
   activeLeases: 0,
@@ -50,6 +54,7 @@ export interface ResidentStatusSnapshotInput {
   models: ResidentStatus["models"];
   jobs: ResidentStatus["jobs"];
   generations: ResidentStatus["generations"];
+  backgroundIssues?: BackgroundIssue[];
   now?: number;
 }
 
@@ -72,6 +77,13 @@ export function buildResidentStatusSnapshot(
     models: { ...input.models },
     jobs: { ...input.jobs },
     generations: { ...input.generations },
+    ...(input.backgroundIssues?.length
+      ? {
+          backgroundIssues: input.backgroundIssues.map((issue) => ({
+            ...issue,
+          })),
+        }
+      : {}),
   };
 }