harnery 0.36.0 → 0.38.0

package/src/commands/artifacts.ts

@@ -4,12 +4,17 @@ import { monorepoRoot, resolveOwner } from "../core/agents/index.ts";
 import { readLiveCoordinationRow } from "../core/agents/state/live-coordination-view.ts";
 import {
   type ArtifactActor,
+  adoptUnmanagedArtifactFiles,
+  artifactCapabilities,
   cleanArtifacts,
   createArtifact,
+  holdArtifact,
   inventoryArtifacts,
+  migrateArtifacts,
   releaseArtifact,
   renewArtifact,
   showArtifact,
+  unholdArtifact,
 } from "../core/artifacts/index.ts";
 import { artifactDefaultRetentionDays, coordFreshnessSeconds } from "../core/config.ts";
 
@@ -28,25 +33,74 @@ export function registerArtifactsCommand(
     .description("Create one managed artifact workspace and print its path.")
     .requiredOption("--purpose <text>", "What the files are for")
     .option("--days <n>", "Retention in days (default from artifacts.default_retention_days)")
-    .action((slug: string, opts: { purpose: string; days?: string }) => {
+    .option("--big", "Acknowledge that this workspace may exceed the per-bundle size ceiling")
+    .option("--hold <id>", "Create the workspace with this hold already present")
+    .option("--hold-reason <text>", "Why the initial hold is required")
+    .option("--actor <instance-id>", "Stable owner identity for the initial hold")
+    .action(
+      (
+        slug: string,
+        opts: {
+          purpose: string;
+          days?: string;
+          big?: boolean;
+          hold?: string;
+          holdReason?: string;
+          actor?: string;
+        },
+      ) => {
+        run(emit, () => {
+          const repoRoot = requireRepoRoot(context);
+          const actor = opts.actor ? { instance_id: opts.actor } : currentActor(repoRoot);
+          if (!!opts.hold !== !!opts.holdReason)
+            throw new Error("--hold and --hold-reason must be used together");
+          const retentionDays = opts.days
+            ? parseDays(opts.days)
+            : artifactDefaultRetentionDays(repoRoot);
+          const created = createArtifact(repoRoot, {
+            slug,
+            purpose: opts.purpose,
+            retentionDays,
+            actor,
+            big: opts.big,
+            holds: opts.hold ? [{ id: opts.hold, reason: opts.holdReason! }] : [],
+          });
+          emit.data({
+            path: created.path,
+            artifact_id: created.manifest.artifact_id,
+            expires_at: created.manifest.retention.expires_at,
+            owner_instance_id: actor?.instance_id ?? null,
+            holds: created.manifest.holds,
+          });
+        });
+      },
+    );
+
+  root
+    .command("adopt-unmanaged")
+    .description("Preview loose direct-child files, or move them into one managed workspace.")
+    .option(
+      "--purpose <text>",
+      "Why the adopted files are being retained",
+      "Adopt legacy loose artifact files",
+    )
+    .option("--days <n>", "Retention in days (default from artifacts.default_retention_days)")
+    .option("--big", "Acknowledge an adopted bundle above the per-bundle size ceiling")
+    .option("--yes", "Move the exact previewed regular files into a managed workspace")
+    .action((opts: { purpose: string; days?: string; big?: boolean; yes?: boolean }) => {
       run(emit, () => {
         const repoRoot = requireRepoRoot(context);
-        const actor = currentActor(repoRoot);
-        const retentionDays = opts.days
-          ? parseDays(opts.days)
-          : artifactDefaultRetentionDays(repoRoot);
-        const created = createArtifact(repoRoot, {
-          slug,
-          purpose: opts.purpose,
-          retentionDays,
-          actor,
-        });
-        emit.data({
-          path: created.path,
-          artifact_id: created.manifest.artifact_id,
-          expires_at: created.manifest.retention.expires_at,
-          owner_instance_id: actor?.instance_id ?? null,
-        });
+        emit.data(
+          adoptUnmanagedArtifactFiles(repoRoot, {
+            yes: opts.yes,
+            big: opts.big,
+            purpose: opts.purpose,
+            retentionDays: opts.days
+              ? parseDays(opts.days)
+              : artifactDefaultRetentionDays(repoRoot),
+            actor: currentActor(repoRoot),
+          }),
+        );
       });
     });
 
@@ -102,6 +156,53 @@ export function registerArtifactsCommand(
       });
     });
 
+  root
+    .command("capabilities")
+    .description("Report artifact schema and hold capabilities for embedding clients.")
+    .option("--json", "Emit the capability document as JSON")
+    .action(() => emit.data(artifactCapabilities()));
+
+  root
+    .command("migrate")
+    .description("Preview the explicit v1 to v2 manifest migration, preserving preimages.")
+    .option("--yes", "Apply the migration to valid v1 manifests")
+    .action((opts: { yes?: boolean }) =>
+      run(emit, () => emit.data({ rows: migrateArtifacts(requireRepoRoot(context), opts) })),
+    );
+
+  root
+    .command("hold <ref>")
+    .description("Protect an artifact from cleanup until its owner removes this exact hold.")
+    .requiredOption("--id <id>", "Unique hold id within this artifact")
+    .requiredOption("--reason <text>", "Why cleanup must retain these files")
+    .option("--actor <instance-id>", "Stable hold owner; defaults to the current agent")
+    .action((ref: string, opts: { id: string; reason: string; actor?: string }) =>
+      run(emit, () => {
+        const repoRoot = requireRepoRoot(context);
+        emit.data(
+          holdArtifact(repoRoot, ref, {
+            id: opts.id,
+            reason: opts.reason,
+            actor: requireHoldActor(repoRoot, opts.actor),
+          }),
+        );
+      }),
+    );
+
+  root
+    .command("unhold <ref>")
+    .description("Remove one exact hold belonging to the supplied owner.")
+    .requiredOption("--id <id>", "Exact hold id to remove")
+    .option("--actor <instance-id>", "Stable hold owner; defaults to the current agent")
+    .action((ref: string, opts: { id: string; actor?: string }) =>
+      run(emit, () => {
+        const repoRoot = requireRepoRoot(context);
+        emit.data(
+          unholdArtifact(repoRoot, ref, opts.id, { actor: requireHoldActor(repoRoot, opts.actor) }),
+        );
+      }),
+    );
+
   root
     .command("clean")
     .description("Preview expired artifact deletion; pass --yes to delete.")
@@ -118,6 +219,12 @@ export function registerArtifactsCommand(
     });
 }
 
+function requireHoldActor(repoRoot: string, explicit?: string): ArtifactActor {
+  const actor = explicit ? { instance_id: explicit } : currentActor(repoRoot);
+  if (!actor) throw new Error("hold operations require --actor or a current agent identity");
+  return actor;
+}
+
 function currentActor(repoRoot: string): ArtifactActor | undefined {
   const instanceId = resolveOwner();
   if (!instanceId) return undefined;
@@ -143,16 +250,23 @@ function parseDays(value: string): number {
   return parsed;
 }
 
-function summarize(rows: { classification: string; action: string }[]): Record<string, unknown> {
+function summarize(
+  rows: { classification: string; action: string; bytes?: number | null }[],
+): Record<string, unknown> {
   const classifications: Record<string, number> = {};
   for (const row of rows) {
     classifications[row.classification] = (classifications[row.classification] ?? 0) + 1;
   }
   return {
     total: rows.length,
+    bytes: rows.reduce((sum, row) => sum + (row.bytes ?? 0), 0),
     classifications,
     would_delete: rows.filter((row) => row.action === "would-delete").length,
     deleted: rows.filter((row) => row.action === "deleted").length,
+    would_delete_bytes: rows.reduce(
+      (sum, row) => sum + (row.action === "would-delete" ? (row.bytes ?? 0) : 0),
+      0,
+    ),
   };
 }
 

package/src/commands/browse-ai.ts

@@ -1,9 +1,9 @@
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import type { Command } from "commander";
-import type { EmitContext } from "../commander.ts";
+import type { EmitContext, HarneryProgramContext } from "../commander.ts";
 import { AgentBrowser, type ExecResult } from "../lib/agent-browser/index.ts";
-import { CookieJar } from "../lib/cookies/index.ts";
+import { applyExtraCookies, CookieJar } from "../lib/cookies/index.ts";
 
 // Module-scoped emit assigned by registerBrowseAiCommand. Same pattern as
 // cookies/read/browse: helper functions close over `emit` so action
@@ -50,7 +50,11 @@ interface BrowseAiOpts {
   timeout: string;
 }
 
-export function registerBrowseAiCommand(program: Command, emitParam: EmitContext): void {
+export function registerBrowseAiCommand(
+  program: Command,
+  emitParam: EmitContext,
+  context?: HarneryProgramContext,
+): void {
   emit = emitParam;
   program
     .command("browse-ai <url>")
@@ -86,7 +90,7 @@ export function registerBrowseAiCommand(program: Command, emitParam: EmitContext
     .option("--timeout <ms>", "Per-step timeout in ms", "60000")
     .action((url: string, opts: BrowseAiOpts) => {
       try {
-        runBrowseAi(url, opts);
+        runBrowseAi(url, opts, context);
       } catch (err: unknown) {
         const msg = err instanceof Error ? err.message : String(err);
         emit.error({ code: "browse_ai_error", message: msg });
@@ -95,11 +99,12 @@ export function registerBrowseAiCommand(program: Command, emitParam: EmitContext
     });
 }
 
-function runBrowseAi(url: string, opts: BrowseAiOpts): void {
+function runBrowseAi(url: string, opts: BrowseAiOpts, context?: HarneryProgramContext): void {
   const jar =
     opts.cookies === false
       ? null
       : new CookieJar({ path: opts.store ?? DEFAULT_STORE, source: "harn-browse-ai" });
+  if (jar) applyExtraCookies(url, jar, context?.extraCookies);
   const ab = new AgentBrowser({
     jar,
     timeoutMs: Number.parseInt(opts.timeout, 10),