harnery 0.40.0 → 0.42.0

package/src/core/agents/session-name-display.ts

@@ -9,8 +9,17 @@ export interface SessionNameDisplayState {
   suggested_session_name?: string;
   session_name_seen_for?: string;
   session_name_display_requested_for?: string;
+  session_name_display_reminders?: number;
 }
 
+/**
+ * How many times PostToolUse may re-attach the display instruction after the
+ * mint-time one, per requested title. Two covers the observed miss (the model
+ * narrates, calls a tool, and forgets) without turning an unreadable
+ * transcript into a reminder on every tool for the rest of the session.
+ */
+export const SESSION_NAME_DISPLAY_REMINDER_LIMIT = 2;
+
 export const SESSION_NAME_DISPLAY_NOTE =
   "Next, before any prose or another tool call, send suggested_session_name verbatim by itself in a fenced code block.";
 
@@ -76,6 +85,45 @@ export function sessionNameDisplayInstruction(name: string): string {
   ].join("\n");
 }
 
+/**
+ * Whether an ordinary tool result should carry a bounded reminder.
+ *
+ * Only after the mint-time instruction has gone out (`requested_for` is set
+ * for the pending title), and only while the counter is under the cap. The
+ * transcript is deliberately not consulted: PreToolUse already stamped a
+ * readable sighting, and an unreadable one is exactly the case the reminder
+ * exists for.
+ */
+export function sessionNameDisplayReminderDue(
+  row: SessionNameDisplayState | null | undefined,
+): string | null {
+  const pending = sessionNameDisplayPending(row);
+  if (!pending || row?.session_name_display_requested_for !== pending) return null;
+  return (row.session_name_display_reminders ?? 0) < SESSION_NAME_DISPLAY_REMINDER_LIMIT
+    ? pending
+    : null;
+}
+
+/**
+ * The follow-up nudge for a title still pending after an ordinary tool.
+ *
+ * Worded so the model can answer it from its own memory: the desktop transcript
+ * sometimes drops a text row that the operator did see, so Harnery cannot tell
+ * a skipped block from an unrecorded one. A model that already showed the block
+ * is told to do nothing, which is what keeps the reminder from producing
+ * duplicate blocks in the chat.
+ */
+export function sessionNameDisplayReminder(name: string): string {
+  return [
+    "Session name still pending.",
+    "If you have not already shown it this turn, send this exact fenced block as your next assistant text, before any prose or another tool call:",
+    "",
+    sessionNameDisplayBlock(name),
+    "",
+    "If you already showed that block, do nothing; Harnery could not read the transcript row and is asking once more.",
+  ].join("\n");
+}
+
 export function sessionNameDisplayRecoveryInstruction(name: string, binName: string): string {
   return [
     sessionNameDisplayInstruction(name),

package/src/core/agents/state/heartbeat-reader.ts

@@ -40,6 +40,13 @@ export interface Heartbeat {
    * counts so that drift cannot strand the latch.
    */
   session_name_display_requested_for?: string;
+  /**
+   * How many bounded PostToolUse reminders have gone out for
+   * `session_name_display_requested_for`. Reset whenever a different title is
+   * requested. Caps the nudge so an unreadable transcript never turns into an
+   * endless stream of "show the block" context.
+   */
+  session_name_display_reminders?: number;
   last_status_at?: string;
   current_turn_id?: string;
   parent_instance_id?: string;

package/src/core/agents/state/heartbeat-writer.ts

@@ -194,12 +194,34 @@ export function stampSessionNameRequested(
   coordRoot: string,
   instanceId: string,
   name: string,
+): Heartbeat | null {
+  if (!name) return null;
+  return mutate(coordRoot, instanceId, (hb) => {
+    if (hb.session_name_display_requested_for === name) return hb;
+    const { session_name_display_reminders: _reset, ...rest } = hb;
+    return { ...rest, session_name_display_requested_for: name };
+  });
+}
+
+/**
+ * Count one bounded PostToolUse reminder for the title currently requested.
+ *
+ * The mint-time instruction is the only thing that used to make the block
+ * appear; a model that went straight to another tool was never asked again,
+ * because the fail-open gate writes its reason to stderr, which the model
+ * cannot read. The counter lets the hook re-attach the instruction a fixed
+ * number of times and then stop, whatever the transcript can or cannot prove.
+ */
+export function stampSessionNameReminded(
+  coordRoot: string,
+  instanceId: string,
+  name: string,
 ): Heartbeat | null {
   if (!name) return null;
   return mutate(coordRoot, instanceId, (hb) =>
     hb.session_name_display_requested_for === name
-      ? hb
-      : { ...hb, session_name_display_requested_for: name },
+      ? { ...hb, session_name_display_reminders: (hb.session_name_display_reminders ?? 0) + 1 }
+      : hb,
   );
 }
 

package/src/core/agents/state/live-coordination-view.ts

@@ -198,6 +198,7 @@ export function projectHeartbeatV3(
     session_name_seen_at: cache?.session_name_seen_at,
     session_name_seen_for: cache?.session_name_seen_for,
     session_name_display_requested_for: cache?.session_name_display_requested_for,
+    session_name_display_reminders: cache?.session_name_display_reminders,
     workflow_run_id: generation.run_id,
     workflow_agent_id: generation.workflow_agent_id,
     parent_instance_id: parent ? nativeInstanceIdV3(parent.instance_id) : undefined,
@@ -225,3 +226,76 @@ function observedModel(generation: CoordinationGenerationViewV3): string | undef
 function isLifecycleState(value: string | undefined): value is "active" | "blocked" | "done" {
   return value === "active" || value === "blocked" || value === "done";
 }
+
+/** Why a still-live V3 generation has lost coordination authority. */
+export interface LiveAuthorityBlockV3 {
+  generation_id: string;
+  scope: "generation" | "ledger";
+  diagnostics: { code: string; event_id?: string }[];
+}
+
+/**
+ * Explain an authority refusal for a generation that is still live. Callers
+ * reach this after a lookup came back empty; without it the caller sees only
+ * "missing", which reads like an ended session and points at a reopen that
+ * cannot apply. Returns null when no live generation exists or nothing blocks.
+ */
+export function liveAuthorityBlockV3(
+  coordRoot: string,
+  nativeInstanceId: string,
+): LiveAuthorityBlockV3 | null {
+  let view: CoordinationViewV3;
+  try {
+    if (observeLiveEventLedgerRouteV3(coordRoot).state === "blocked") return null;
+    view = readCoordinationViewV3(coordRoot);
+  } catch {
+    return null;
+  }
+  const generation = view.instances[liveInstanceIdV3(nativeInstanceId)];
+  if (generation?.phase !== "live" || generation.authority_eligible) return null;
+  const own = (view.diagnostics_by_generation[generation.generation_id] ?? []).filter(
+    (diagnostic) => diagnostic.authority_blocking,
+  );
+  const blocking = own.length
+    ? own
+    : view.global_diagnostics.filter((diagnostic) => diagnostic.authority_blocking);
+  if (!blocking.length) return null;
+  return {
+    generation_id: generation.generation_id,
+    scope: own.length ? "generation" : "ledger",
+    diagnostics: blocking.map((diagnostic) => ({
+      code: diagnostic.source_code
+        ? `${diagnostic.code}:${diagnostic.source_code}`
+        : diagnostic.code,
+      ...(diagnostic.event_id ? { event_id: diagnostic.event_id } : {}),
+    })),
+  };
+}
+
+/** One-line description of a live authority block, naming codes and events. */
+export function describeLiveAuthorityBlockV3(block: LiveAuthorityBlockV3): string {
+  const byCode = new Map<string, string[]>();
+  for (const { code, event_id } of block.diagnostics) {
+    const events = byCode.get(code) ?? [];
+    if (event_id) events.push(event_id);
+    byCode.set(code, events);
+  }
+  const parts = [...byCode].map(([code, events]) => {
+    const shown = events.slice(0, 2).join(", ");
+    const more = events.length > 2 ? `, +${events.length - 2} more` : "";
+    return events.length ? `${code} ×${events.length} (${shown}${more})` : code;
+  });
+  const where =
+    block.scope === "generation"
+      ? `the event ledger holds ${block.diagnostics.length} authority-blocking diagnostic(s) for it`
+      : "the event ledger holds authority-blocking diagnostics that block every generation";
+  return `generation ${block.generation_id} is still live, but ${where}: ${parts.join("; ")}`;
+}
+
+/** Recovery pointer for a live authority block, in place of the reopen hint. */
+export function liveAuthorityBlockHintV3(binName: string): string {
+  return (
+    `\`${binName} agents lifecycle active\` cannot help because it only reopens an ended ` +
+    `generation; \`${binName} agents health\` lists the diagnostics`
+  );
+}

package/src/core/agents/state/live-coordination-writer.ts

@@ -112,6 +112,9 @@ function materializeLiveCoordinationHeartbeat(
                 session_name_display_requested_for: current.session_name_display_requested_for,
               }
             : {}),
+          ...(typeof current.session_name_display_reminders === "number"
+            ? { session_name_display_reminders: current.session_name_display_reminders }
+            : {}),
         }
       : {};
   const materialized: V3HeartbeatMaterialization = {

package/src/core/agents/state/stale-sweep.ts

@@ -13,18 +13,11 @@
 import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { coordFreshnessSeconds } from "../../config.ts";
-import type { EventAdapterIdV3 } from "../../events/v3/adapter-id.ts";
+import { type EventAdapterIdV3, eventAdapterIdV3FromPlatform } from "../../events/v3/adapter-id.ts";
 import { writeProducerDiagnosticV3 } from "../../events/v3/producers/intake.ts";
 import { recordLiveSweepObservationV3 } from "../live-lifecycle-v3.ts";
 
 /** platform → adapter, for the swept-event envelope (mirrors heartbeat-writer's adapterOf). */
-function adapterFromPlatform(platform: unknown): EventAdapterIdV3 {
-  if (platform === "cursor") return "cursor";
-  if (platform === "codex") return "codex";
-  if (platform === "openclaw") return "openclaw";
-  return "claude-code";
-}
-
 /**
  * Record the sweep before deleting disposable cache state.
  *
@@ -150,7 +143,7 @@ export function staleSweep(coordRoot: string): {
       }
 
       const instanceId = parsed.instance_id ?? idFromFile;
-      const adapter = adapterFromPlatform(parsed.platform);
+      const adapter = eventAdapterIdV3FromPlatform(parsed.platform, { context: "stale-sweep" });
       const sessionId = parsed.session_id ?? instanceId;
       const ts = parsed.last_heartbeat
         ? Math.floor(Date.parse(parsed.last_heartbeat) / 1000)

package/src/core/agents/turn-changes.ts

@@ -0,0 +1,97 @@
+import type { EventV3 } from "../events/v3/contract.ts";
+import { liveInstanceIdV3 } from "../events/v3/live-routing.ts";
+import { readLedgerV3 } from "../events/v3/reader.ts";
+import type { LineChanges } from "../events/v3/tool-line-changes.ts";
+
+export interface TurnChanges extends LineChanges {
+  measured_tools: number;
+  unmeasured_tools: number;
+}
+
+/** Sum edit activity, not a net workspace diff. Commits cannot erase it. */
+export function resolveTurnChanges(
+  events: readonly EventV3[],
+  instanceId: string,
+  now = Date.now(),
+): TurnChanges | null {
+  const owner = liveInstanceIdV3(instanceId);
+  const own = events.filter(
+    (event) => event.scope.instance_id === owner && Date.parse(event.time.observed_at) <= now,
+  );
+  const starts = own.filter((event) => event.event_type === "turn.started");
+  const newest = starts.at(-1);
+  if (!newest || !("generation_id" in newest.scope)) return null;
+  const generation = newest.scope.generation_id;
+  let index = starts.length - 1;
+  let restarts = 0;
+  while (
+    index > 0 &&
+    restarts < 8 &&
+    starts[index]?.event_type === "turn.started" &&
+    starts[index]?.payload.stop_remediation === true
+  ) {
+    const previous = starts[index - 1]!;
+    if (!("generation_id" in previous.scope) || previous.scope.generation_id !== generation) break;
+    index--;
+    restarts++;
+  }
+  const selected = starts.slice(index);
+  const ids = new Set(
+    selected.map((event) => ("turn_id" in event.scope ? event.scope.turn_id : undefined)),
+  );
+  const from = Date.parse(selected[0]!.time.observed_at);
+  const tools = own.filter(
+    (event) =>
+      "generation_id" in event.scope &&
+      event.scope.generation_id === generation &&
+      "turn_id" in event.scope &&
+      ids.has(event.scope.turn_id) &&
+      Date.parse(event.time.observed_at) >= from,
+  );
+  const result: TurnChanges = { added: 0, removed: 0, measured_tools: 0, unmeasured_tools: 0 };
+  const completed = new Set<string>();
+  for (const event of tools) {
+    if (event.event_type !== "tool.completed") continue;
+    const span = event.payload.span.span_id;
+    if (completed.has(span)) continue;
+    completed.add(span);
+    const changes = event.payload.line_changes;
+    if (event.payload.outcome === "succeeded" && changes?.state === "observed") {
+      result.added += changes.value.added;
+      result.removed += changes.value.removed;
+      result.measured_tools++;
+    } else result.unmeasured_tools++;
+  }
+  for (const event of tools) {
+    const span = (event.links as { span_id?: string }).span_id;
+    if (event.event_type === "tool.requested" && span && !completed.has(span)) {
+      completed.add(span);
+      result.unmeasured_tools++;
+    }
+  }
+  // No delivered tool evidence cannot prove no file changes occurred.
+  return result.measured_tools + result.unmeasured_tools > 0 ? result : null;
+}
+
+export function formatTurnChanges(changes: TurnChanges | null): string {
+  if (!changes || changes.measured_tools === 0) return "unavailable (no measured edits)";
+  return `+${changes.added} / -${changes.removed} lines${changes.unmeasured_tools > 0 ? " (partial; unmeasured tools)" : " (recorded edits)"}`;
+}
+
+export function turnChangesStatusRow(target: { coordRoot: string; instanceId: string }): {
+  value: string;
+  changes: TurnChanges | null;
+} {
+  let changes: TurnChanges | null = null;
+  try {
+    const ledger = readLedgerV3(target.coordRoot);
+    if (ledger.complete)
+      changes = resolveTurnChanges(
+        ledger.events.map((item) => item.event),
+        target.instanceId,
+      );
+  } catch {
+    /* Status remains available when evidence is missing. */
+  }
+  return { value: formatTurnChanges(changes), changes };
+}

package/src/core/artifacts/delivery-card.ts

@@ -12,8 +12,9 @@ import {
 } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { encodeLinkSafeComponent } from "../../lib/local-file-url.ts";
-import { findLiveTunnelForOrigin } from "../../lib/tunnel/state.ts";
+import { findLiveTunnelForOrigin, tunnelServesPaths } from "../../lib/tunnel/state.ts";
 import { resolveWebPort } from "../config.ts";
+import { stateFileMode } from "../storage/modes.ts";
 import { ARTIFACT_MANIFEST } from "./constants.ts";
 import { resolveArtifactRef, showArtifact } from "./index.ts";
 
@@ -71,7 +72,7 @@ export function writeArtifactDeliveryManifest(
   try {
     writeFileSync(tmp, `${JSON.stringify(manifest, null, 2)}\n`, {
       encoding: "utf8",
-      mode: 0o600,
+      mode: stateFileMode(),
       flag: "wx",
     });
     renameSync(tmp, target);
@@ -325,9 +326,17 @@ function deliveryLinkBase(repoRoot: string, environment: DisplayEnvironment): st
   // dashboard's own origin will answer them. A tunnel sharing this upstream
   // port under another Host serves a different site and would 400 on /browse
   // and /files, so fall back to the local URL rather than publish that host.
+  // The same holds for a dashboard tunnel whose path scope leaves out either
+  // route: its gate would refuse every link on the card.
+  const tunnel =
+    environment.tunnelUrl === undefined
+      ? findLiveTunnelForOrigin(webPort, `localhost:${webPort}`, repoRoot)
+      : null;
   const tunnelUrl =
     environment.tunnelUrl === undefined
-      ? findLiveTunnelForOrigin(webPort, `localhost:${webPort}`, repoRoot)?.url
+      ? tunnel && tunnelServesPaths(tunnel, ["/browse", "/files"])
+        ? tunnel.url
+        : undefined
       : environment.tunnelUrl;
   return (tunnelUrl ?? `http://localhost:${webPort}`).replace(/\/+$/, "");
 }