@gmickel/gno 2.5.1 → 2.7.0

package/src/cli/program.ts

@@ -41,7 +41,11 @@ import {
   type GlobalOptions,
   parseGlobalOptions,
 } from "./context";
-import { DETACHED_CHILD_FLAG } from "./detach";
+import {
+  DETACHED_CHILD_FLAG,
+  formatBackgroundIssue,
+  residentIssues,
+} from "./detach";
 import { CliError } from "./errors";
 import {
   assertFormatSupported,
@@ -344,7 +348,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 +359,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 +368,7 @@ export function createProgram(): Command {
   wireOnboardingCommands(program);
   wireCaptureCommand(program);
   wireMemoryCommands(program);
+  wireSessionsCommands(program);
   wireManagementCommands(program);
   wireTraceCommands(program);
   wirePublishCommand(program);
@@ -1874,6 +1881,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 +1913,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 +1922,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 +1990,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 +2016,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 +2076,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 +2559,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",
@@ -3157,6 +3548,10 @@ function wireManagementCommands(program: Command): void {
       .option("--model <uri>", "embedding model URI")
       .option("--batch-size <num>", "batch size", "32")
       .option("--force", "regenerate all embeddings")
+      .option(
+        "--new-partition",
+        "confirm building a separate vector partition for an incompatible runtime"
+      )
       .option("--dry-run", "show what would be done")
       .option("--json", "JSON output")
   ).action(
@@ -3180,6 +3575,7 @@ function wireManagementCommands(program: Command): void {
         force: Boolean(cmdOpts.force),
         dryRun: Boolean(cmdOpts.dryRun),
         yes: globals.yes,
+        newPartition: Boolean(cmdOpts.newPartition),
         json: format === "json",
         verbose: globals.verbose,
         offline: globals.offline,
@@ -3288,6 +3684,43 @@ function wireVecCommands(program: Command): void {
     );
   });
 
+  // vec drop
+  addWriteLeaseFlags(
+    vecCmd
+      .command("drop <partition>")
+      .description(
+        "Drop an abandoned shadow vector partition (id prefix from gno status)"
+      )
+      .option("--json", "JSON output")
+  ).action(async (partition: string, cmdOpts: Record<string, unknown>) => {
+    const format = getFormat(cmdOpts);
+    const globals = getGlobals();
+
+    const { vecDrop, formatVecDrop } = await import("./commands/vec");
+    const lease = parseWriteLeaseFlags(cmdOpts);
+    const result = await withCliWriteLease(
+      {
+        indexName: globals.index,
+        lockWaitMs: lease.lockWaitMs,
+        noWait: lease.noWait,
+      },
+      () =>
+        vecDrop(partition, {
+          configPath: globals.config,
+          indexName: globals.index,
+        })
+    );
+    throwIfWriteLeaseBusy(result, format === "json");
+
+    if (!result.success) {
+      throw new CliError("VALIDATION", result.error);
+    }
+
+    process.stdout.write(
+      `${formatVecDrop(result, { json: format === "json" })}\n`
+    );
+  });
+
   // vec rebuild
   addWriteLeaseFlags(
     vecCmd
@@ -4630,6 +5063,9 @@ async function runDaemonStatus(deps: DaemonStatusDeps): Promise<void> {
     } else {
       process.stdout.write(` (${status.log_size_bytes} bytes)\n`);
     }
+    for (const issue of residentIssues(status)) {
+      process.stdout.write(`  issue    ${formatBackgroundIssue(issue)}\n`);
+    }
     if (findings) {
       process.stdout.write(
         `  findings ${formatFindingsRunStatusLine(findings)}\n`
@@ -4985,6 +5421,9 @@ async function runServeStatus(deps: ServeStatusDeps): Promise<void> {
     } else {
       process.stdout.write(` (${status.log_size_bytes} bytes)\n`);
     }
+    for (const issue of residentIssues(status)) {
+      process.stdout.write(`  issue    ${formatBackgroundIssue(issue)}\n`);
+    }
 
     if (foreign) {
       // Terminal mode: emit the operator-facing warning on stderr. JSON

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)