harnery 0.38.0 → 0.40.0

package/src/commands/agents.ts

@@ -27,6 +27,7 @@ import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import type { Adapter } from "../core/adapter.ts";
 import { coordBinPath } from "../core/agents/coord-bin.ts";
 import {
   checkGitFinalization,
@@ -85,11 +86,13 @@ import {
   foldSessionState,
   type TaskState,
 } from "../core/agents/state/session-state.ts";
+import { turnElapsedStatusRow } from "../core/agents/turn-elapsed.ts";
 import {
   coordFreshnessSeconds,
   resolveBinName,
   sessionFinalizationConfig,
 } from "../core/config.ts";
+import { EVENT_ADAPTER_IDS_V3, type EventAdapterIdV3 } from "../core/events/v3/adapter-id.ts";
 import type { EventTypeV3 } from "../core/events/v3/contract.ts";
 import { readEventV3ControlState } from "../core/events/v3/control.ts";
 import {
@@ -118,6 +121,7 @@ import {
   readRuntimeContextUsage,
 } from "../core/hooks/adapter/runtime-telemetry.ts";
 import { type RemoteMachine, readRemoteMachines } from "../core/presence/index.ts";
+import { formatResourceSummary, readResourceStatus } from "../core/resources/status.ts";
 import { registerContextCommand } from "./context.ts";
 
 type LiveCoordinationRow = ReturnType<typeof readLiveCoordinationRows>[number];
@@ -239,6 +243,7 @@ function spawnFailureMessage(
 function formatPlatformLabel(platform?: string | null): string {
   if (platform === "cursor") return "Cursor";
   if (platform === "codex") return "Codex";
+  if (platform === "openclaw") return "OpenClaw";
   return "CC";
 }
 
@@ -669,7 +674,7 @@ function runEndSession(opts: { sessionId?: string; instanceId?: string; outcome:
   const byInstance = listHookProducerStateRecordsV3(root, { includeTerminal: false }).filter(
     ({ state }) => state.instance_id === target,
   );
-  const byNative = (["claude-code", "codex", "cursor"] as const).flatMap((adapter) => {
+  const byNative = EVENT_ADAPTER_IDS_V3.flatMap((adapter) => {
     const state = readHookProducerStateV3(root, adapter, target);
     return state && !state.terminal ? [{ path: "", modified_at_ms: 0, state }] : [];
   });
@@ -786,10 +791,13 @@ function runObserveArchive(opts: {
 }) {
   const root = monorepoRoot();
   if (!root) return failCommand("not_in_repo", "not in an agent session");
-  if (!(["claude-code", "codex", "cursor"] as string[]).includes(opts.adapter)) {
-    return failCommand("invalid_adapter", "adapter must be claude-code, codex, or cursor");
+  if (!(EVENT_ADAPTER_IDS_V3 as readonly string[]).includes(opts.adapter)) {
+    return failCommand(
+      "invalid_adapter",
+      "adapter must be claude-code, codex, cursor, or openclaw",
+    );
   }
-  const adapter = opts.adapter as "claude-code" | "codex" | "cursor";
+  const adapter = opts.adapter as EventAdapterIdV3;
   const observedAt = opts.observedAt ?? new Date().toISOString();
   if (Number.isNaN(Date.parse(observedAt))) {
     return failCommand("invalid_observed_at", "observed-at must be an ISO timestamp");
@@ -2408,12 +2416,20 @@ function runStatus(opts: {
   // the QA run took 58 minutes. Best-effort by contract — no pointer, a
   // malformed one, or any read failure renders no row.
   const qaSignal = qaSignalStatusRow({ coordRoot: root, instanceId: hb.instance_id });
+  // Duration of the turn this box closes. `session` is cumulative, so without
+  // this row an operator cannot tell a twelve-second turn from an eight-minute
+  // one inside the same session. Best-effort by contract — no turn evidence,
+  // no row.
+  const turnElapsed = turnElapsedStatusRow({ coordRoot: root, instanceId: hb.instance_id });
+  const resources = readResourceStatus(root);
 
   const data = {
     name: displayName,
     instance_id: hb.instance_id,
     kind: normalizeKind(hb.kind),
     session_age_secs: ageSecs,
+    turn_elapsed_secs: turnElapsed ? turnElapsed.elapsed.secs : null,
+    turn_complete: turnElapsed ? turnElapsed.elapsed.complete : null,
     activity: activityOf(hb),
     activity_updated_at: hb.activity_updated_at ?? null,
     activity_source: hb.activity_source ?? null,
@@ -2441,6 +2457,7 @@ function runStatus(opts: {
       })),
     })),
     pending_councils: pendingCouncils,
+    resources,
     context_used: ctxUsage && "used" in ctxUsage ? ctxUsage.used : null,
     context_window: ctxUsage && "window" in ctxUsage ? ctxUsage.window : null,
     timestamp_iso: new Date().toISOString(),
@@ -2459,16 +2476,24 @@ function runStatus(opts: {
 
   const rows: Array<[string, string]> = [
     ["session", formatAge(ageSecs)],
+    ...(turnElapsed ? ([["turn", turnElapsed.value]] as Array<[string, string]>) : []),
     ["activity", activityOf(hb)],
     ["lifecycle", lifecycleLabel(hb)],
     ["context", ctxStr],
+    ["resources", formatResourceSummary(resources)],
     ["files", filesStr],
     ["peers", peersStr],
     ["time", timeStr],
   ];
-  // Task gets full text; formatBox word-wraps to MAX_BOX_CONTENT_WIDTH.
+  // Task gets full text; formatBox word-wraps to MAX_BOX_CONTENT_WIDTH. It sits
+  // directly above `activity`, which keeps it under the session/turn clocks
+  // whether or not the turn row rendered.
   if (hb.task && hb.task.length > 0) {
-    rows.splice(1, 0, ["task", hb.task]);
+    rows.splice(
+      rows.findIndex((row) => row[0] === "activity"),
+      0,
+      ["task", hb.task],
+    );
   }
   if (pendingCouncils.length > 0) {
     // Slot the council line right before `time` so it stays in the "what's
@@ -2755,6 +2780,7 @@ function adapterToPlatform(adapter: string | undefined): string {
   if (adapter === "claude-code") return "claude-code";
   if (adapter === "cursor") return "cursor";
   if (adapter === "codex") return "codex";
+  if (adapter === "openclaw") return "openclaw";
   return "unknown";
 }
 
@@ -5061,13 +5087,20 @@ function runHeal(opts: {
   const inferredAdapter = normalizeAdapter(
     opts.adapter?.trim() || currentRow?.platform || commandSessionBootstrap()?.adapter,
   );
+  if (inferredAdapter === "openclaw") {
+    emitHealFailure(
+      "unsupported_adapter",
+      "coordination cache healing is unavailable for observer-only OpenClaw generations",
+    );
+  }
+  const healAdapter: Adapter = inferredAdapter;
   const sessionId =
     opts.sessionId?.trim() ||
     (currentSessionRepair ? sessionIdentityFromEnv() : null) ||
     nativeSessionIdentity(currentRow, owner);
 
   if (kind === "cache") {
-    const refusal = cacheHealAuthorityRefusal(root, owner, sessionId, inferredAdapter, currentRow);
+    const refusal = cacheHealAuthorityRefusal(root, owner, sessionId, healAdapter, currentRow);
     if (refusal) {
       emitHealFailure(refusal.reason, refusal.message);
     }
@@ -5183,7 +5216,7 @@ function runHeal(opts: {
 
   if (proc.status !== 0) {
     emitHealFailure(
-      healFailureReason(root, owner, sessionId, inferredAdapter),
+      healFailureReason(root, owner, sessionId, healAdapter),
       spawnFailureMessage(proc, `agent-coord ${action}`),
     );
   }
@@ -5306,7 +5339,7 @@ function missingAuthorityForCurrentSessionBootstrap(
 ): boolean {
   if (readLiveCoordinationRow(root, owner)) return false;
   try {
-    const nativeSessionHasProducer = (["claude-code", "codex", "cursor"] as const).some(
+    const nativeSessionHasProducer = EVENT_ADAPTER_IDS_V3.some(
       (adapter) => readHookProducerStateV3(root, adapter, sessionId) !== undefined,
     );
     if (nativeSessionHasProducer) return false;

package/src/commands/artifacts.ts

@@ -4,19 +4,34 @@ import { monorepoRoot, resolveOwner } from "../core/agents/index.ts";
 import { readLiveCoordinationRow } from "../core/agents/state/live-coordination-view.ts";
 import {
   type ArtifactActor,
+  type ArtifactDeliveryManifest,
   adoptUnmanagedArtifactFiles,
   artifactCapabilities,
+  artifactReviewGuidance,
+  artifactsRoot,
+  autoCleanArtifacts,
   cleanArtifacts,
   createArtifact,
+  discardArtifact,
   holdArtifact,
   inventoryArtifacts,
   migrateArtifacts,
+  parseArtifactDeliverySpec,
   releaseArtifact,
+  renderArtifactDeliveryCard,
   renewArtifact,
+  repairArtifactActivity,
+  resolveArtifactDeliveryManifest,
   showArtifact,
   unholdArtifact,
+  writeArtifactDeliveryManifest,
 } from "../core/artifacts/index.ts";
-import { artifactDefaultRetentionDays, coordFreshnessSeconds } from "../core/config.ts";
+import {
+  artifactDefaultRetentionDays,
+  coordFreshnessSeconds,
+  reviewPackAutoCleanEnabled,
+} from "../core/config.ts";
+import { deleteExpiredPacks } from "../lib/browser/page-review-pack.ts";
 
 export function registerArtifactsCommand(
   program: Command,
@@ -33,6 +48,7 @@ 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)")
+    .option("--minutes <n>", "Retention in minutes; cannot be combined with --days")
     .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")
@@ -43,6 +59,7 @@ export function registerArtifactsCommand(
         opts: {
           purpose: string;
           days?: string;
+          minutes?: string;
           big?: boolean;
           hold?: string;
           holdReason?: string;
@@ -51,16 +68,29 @@ export function registerArtifactsCommand(
       ) => {
         run(emit, () => {
           const repoRoot = requireRepoRoot(context);
+          if (opts.days !== undefined && opts.minutes !== undefined)
+            throw new Error("choose either --days or --minutes");
           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 retentionMinutes =
+            opts.minutes === undefined ? undefined : parseMinutes(opts.minutes);
+          try {
+            autoCleanArtifacts(repoRoot);
+          } catch (error) {
+            emit.log(
+              `artifact cleanup skipped: ${error instanceof Error ? error.message : String(error)}`,
+              "warn",
+            );
+          }
           const created = createArtifact(repoRoot, {
             slug,
             purpose: opts.purpose,
             retentionDays,
+            retentionMinutes,
             actor,
             big: opts.big,
             holds: opts.hold ? [{ id: opts.hold, reason: opts.holdReason! }] : [],
@@ -71,6 +101,7 @@ export function registerArtifactsCommand(
             expires_at: created.manifest.retention.expires_at,
             owner_instance_id: actor?.instance_id ?? null,
             holds: created.manifest.holds,
+            after_review: artifactReviewGuidance(repoRoot, created.manifest.artifact_id),
           });
         });
       },
@@ -131,15 +162,59 @@ export function registerArtifactsCommand(
       });
     });
 
+  root
+    .command("delivery-card <ref>")
+    .description("Discover or curate a reproducible Markdown delivery card for one artifact.")
+    .option("--title <text>", "Card heading")
+    .option("--url <label=url>", "Add a web destination; repeatable", collect, [])
+    .option(
+      "--path <label=path>",
+      "Add an artifact-relative file or directory; repeatable",
+      collect,
+      [],
+    )
+    .action((ref: string, opts: { title?: string; url: string[]; path: string[] }) => {
+      run(emit, () => {
+        const repoRoot = requireRepoRoot(context);
+        const suppliedItems = [
+          ...opts.url.map((spec) => parseArtifactDeliverySpec("url", spec)),
+          ...opts.path.map((spec) => parseArtifactDeliverySpec("path", spec)),
+        ];
+        let manifest: ArtifactDeliveryManifest;
+        if (suppliedItems.length > 0) {
+          manifest = writeArtifactDeliveryManifest(repoRoot, ref, {
+            title: opts.title ?? "Delivery",
+            items: suppliedItems,
+          });
+        } else {
+          manifest = resolveArtifactDeliveryManifest(repoRoot, ref);
+          if (opts.title !== undefined) {
+            manifest = writeArtifactDeliveryManifest(repoRoot, ref, {
+              title: opts.title,
+              items: manifest.items,
+            });
+          }
+        }
+        emit.text(renderArtifactDeliveryCard(repoRoot, ref, manifest).markdown);
+      });
+    });
+
   root
     .command("renew <ref>")
     .description("Set a new retention window. Renewal does not mark the artifact active.")
-    .requiredOption("--days <n>", "Days from now")
+    .option("--days <n>", "Days from now; choose either --days or --minutes")
+    .option("--minutes <n>", "Minutes from now; choose either --days or --minutes")
     .requiredOption("--reason <text>", "Why the extra retention is needed")
-    .action((ref: string, opts: { days: string; reason: string }) => {
+    .action((ref: string, opts: { days?: string; minutes?: string; reason: string }) => {
       run(emit, () => {
         const repoRoot = requireRepoRoot(context);
-        const manifest = renewArtifact(repoRoot, ref, parseDays(opts.days), opts.reason, {
+        if ((opts.days === undefined) === (opts.minutes === undefined))
+          throw new Error("choose exactly one of --days or --minutes");
+        const duration =
+          opts.minutes === undefined
+            ? parseDays(opts.days!)
+            : { minutes: parseMinutes(opts.minutes) };
+        const manifest = renewArtifact(repoRoot, ref, duration, opts.reason, {
           actor: currentActor(repoRoot),
         });
         emit.data(manifest);
@@ -152,7 +227,27 @@ export function registerArtifactsCommand(
     .action((ref: string) => {
       run(emit, () => {
         const repoRoot = requireRepoRoot(context);
-        emit.data(releaseArtifact(repoRoot, ref, { actor: currentActor(repoRoot) }));
+        const manifest = releaseArtifact(repoRoot, ref, { actor: currentActor(repoRoot) });
+        emit.data({
+          ...manifest,
+          after_review: artifactReviewGuidance(repoRoot, manifest.artifact_id),
+        });
+      });
+    });
+
+  root
+    .command("discard <ref>")
+    .description("Retire reviewed, disposable files after a grace period; deletes nothing now.")
+    .option("--minutes <n>", "Grace period in minutes; never extends an earlier expiry", "60")
+    .requiredOption("--reason <text>", "Why these reviewed files are no longer needed")
+    .action((ref: string, opts: { minutes: string; reason: string }) => {
+      run(emit, () => {
+        const repoRoot = requireRepoRoot(context);
+        const manifest = discardArtifact(repoRoot, ref, opts.reason, {
+          minutes: parseMinutes(opts.minutes),
+          actor: currentActor(repoRoot),
+        });
+        emit.data({ manifest, entry: showArtifact(repoRoot, ref).entry, deleted: false });
       });
     });
 
@@ -170,6 +265,17 @@ export function registerArtifactsCommand(
       run(emit, () => emit.data({ rows: migrateArtifacts(requireRepoRoot(context), opts) })),
     );
 
+  root
+    .command("repair-activity")
+    .description("Preview retention corrections for unchanged, preimage-backed v1 migrations.")
+    .option(
+      "--yes",
+      "Record verified activity corrections with preimage receipts; deletes no files",
+    )
+    .action((opts: { yes?: boolean }) =>
+      run(emit, () => emit.data({ rows: repairArtifactActivity(requireRepoRoot(context), opts) })),
+    );
+
   root
     .command("hold <ref>")
     .description("Protect an artifact from cleanup until its owner removes this exact hold.")
@@ -214,7 +320,14 @@ export function registerArtifactsCommand(
           yes: opts.yes,
           freshnessSeconds: coordFreshnessSeconds(repoRoot),
         });
-        emit.data({ rows, meta: summarize(rows) });
+        const reviewPacks = reviewPackAutoCleanEnabled(repoRoot)
+          ? deleteExpiredPacks({ roots: [artifactsRoot(repoRoot)], dryRun: !opts.yes })
+          : undefined;
+        emit.data({
+          rows,
+          meta: summarize(rows),
+          ...(reviewPacks ? { review_packs: reviewPacks } : {}),
+        });
       });
     });
 }
@@ -250,6 +363,17 @@ function parseDays(value: string): number {
   return parsed;
 }
 
+function parseMinutes(value: string): number {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 5256000)
+    throw new Error("--minutes must be between 1 and 5256000");
+  return parsed;
+}
+
+function collect(value: string, previous: string[]): string[] {
+  return [...previous, value];
+}
+
 function summarize(
   rows: { classification: string; action: string; bytes?: number | null }[],
 ): Record<string, unknown> {