@halofy/agent-connect 0.13.0 → 0.13.1

package/README.md

@@ -1,6 +1,6 @@
 # Halofy agent lifecycle installer
 
-Status: source for `@halofy/agent-connect@0.13.0`; publication and deployment
+Status: source for `@halofy/agent-connect@0.13.1`; publication and deployment
 require separate verification. The production console supplies the command for
 the verified published package pinned by the deployment workflow. Host loading
 requires separate verification.
@@ -33,7 +33,7 @@ conversation coverage from the presence of `hooks.json`. This source adds an
 explicit refresh command for an existing installation:
 
 ```bash
-node "/absolute/path/to/runtime/0.13.0/bin/halofy-agent.mjs" sync --connection <installation-id>
+node "/absolute/path/to/runtime/0.13.1/bin/halofy-agent.mjs" sync --connection <installation-id>
 ```
 
 The installer prints `syncCommand` with the exact executable, argument array
@@ -93,11 +93,11 @@ runtimes or their managed copies.
 ## Browser sign-in
 
 Users assigned to a team can run the installer without a manually copied badge.
-Use the production console’s verified command. After 0.13.0 is published and
+Use the production console’s verified command. After 0.13.1 is published and
 verified, the command for this source version is:
 
 ```bash
-npx @halofy/agent-connect@0.13.0 install claude-code --server https://app.halofy.ai
+npx @halofy/agent-connect@0.13.1 install claude-code --server https://app.halofy.ai
 ```
 
 `login <client-kind> --server <origin>` is an alias for the same installation
@@ -111,11 +111,11 @@ pending key survives retries. Installation still requires the terminal's
 explicit CONNECT disclosure before changing host configuration.
 
 Browser sign-in requires the matching server enrollment endpoints. The example
-above does not establish that 0.13.0 is published or enabled in production. The
-manual claim path remains supported; after publication, its 0.13.0 form is:
+above does not establish that 0.13.1 is published or enabled in production. The
+manual claim path remains supported; after publication, its 0.13.1 form is:
 
 ```bash
-npx --yes @halofy/agent-connect@0.13.0 install <client-kind> \
+npx --yes @halofy/agent-connect@0.13.1 install <client-kind> \
   --server https://app.halofy.ai \
   --claim '<one-time-claim>'
 ```
@@ -193,13 +193,49 @@ npm test
 npm run check
 ```
 
-Content-free local queue/version evidence is available without decrypting or
-printing any pending event body:
+Content-free local queue/version evidence is available without printing any
+pending event body or proof key:
 
 ```bash
 node kernel/integrations/agent-runtime/bin/halofy-agent.mjs diagnostics
 ```
 
+Pass `--connection <installation-id>` to inspect a specific installation.
+Diagnostics shows installed and running runtime versions, local hook/pause
+health, frozen capture capabilities, queue depth, oldest pending time and expired
+batch count. It makes no server request, and neither active local hooks nor an
+empty queue proves that a particular conversation reached the archive.
+
+## Conversation return reliability (0.13.1 source)
+
+Append acknowledgement is now mandatory and bounded to the submitted batch.
+An empty, non-JSON or malformed success response cannot discard queued events.
+Only explicitly accepted or duplicate events advance the cursor; a server
+sequence ahead of an event conflict cannot acknowledge the rejected local body.
+An unchanged transcript retries its already durable queue, including after a
+lost append response, without requiring another user message. Hook messages
+without a native event id receive an id per invocation, so multiple prompts in
+one Cline task and repeated identical prompts remain separate events. Queue
+retries preserve that id; native event ids still deduplicate host retries.
+
+Retries run at supported hooks, explicit runtime replay and the existing MCP
+proxy's 60-second health tick. Each background tick attempts at most one pending
+batch, with the proxy's five-second request timeout and cancellation on exit.
+Heartbeat reporting continues when replay fails. Paused or replaced installations
+skip background replay; resume permits queued work to retry. The pause result
+reports an incomplete flush while any unacknowledged batch remains. No new monitoring
+process is installed. Abrupt host shutdown can leave pending data until the next
+proxy start or supported hook, subject to the existing seven-day queue limit.
+This release does not widen host capabilities or add assistant
+responses to the partial adapters listed above. Hosts without native event ids
+cannot distinguish two host invocations from a duplicated host callback.
+
+The npm `0.12.1` tarball was downloaded and matched the deployment workflow's
+SHA-256 pin on 2026-09-17. These `0.13.1` fixes require a new reviewed publication,
+server pin promotion and a recipient-confirmed reinstall. Existing runtimes do
+not auto-upgrade. Public health responses and package integrity do not verify
+authenticated production conversation capture.
+
 Version 0.8.0 additionally refreshes authorized organization and team policy and
 knowledge-base references at installation and SessionStart for the seven pre-Hermes hosts
 above. Hermes does not support this managed delivery. Each installation gets a private `halofy-context-*` skill folder containing
@@ -425,7 +461,7 @@ in status receipts. Existing policy/knowledge/skill operations and runtime queue
 files are not changed by instruction sync.
 
 
-## Hermes pinned adapter (0.13.0 source)
+## Hermes pinned adapter (since 0.13.0)
 
 This source supports [Hermes Agent v2026.9.14](https://github.com/NousResearch/hermes-agent/releases/tag/v2026.9.14),
 package version `0.21.3`, upstream commit

package/bin/halofy-agent.mjs

@@ -8,8 +8,9 @@ import { runClaudeLifecycleHook } from "../src/claude-hook.mjs";
 import { HOST_HOOK_EVENTS, runHostLifecycleHook } from "../src/host-hook.mjs";
 import { HERMES_HOOK_EVENTS, runHermesLifecycleHook } from "../src/hermes-hook.mjs";
 import { LifecycleRuntime } from "../src/runtime.mjs";
-import { setCapturePaused } from "../src/health.mjs";
+import { inspectCaptureHealth, setCapturePaused } from "../src/health.mjs";
 import { refreshManagedConfiguration } from "../src/delivery-sync.mjs";
+import { RUNTIME_VERSION } from "../src/version.mjs";
 import { join, resolve } from "node:path";
 import { realpath } from "node:fs/promises";
 import { readJson, safeDirectory } from "../src/storage.mjs";
@@ -113,19 +114,28 @@ if (!["mcp", "hermes-mcp", "diagnostics", "hook", "hermes-hook", "pause", "resum
         process.exit(0);
       }
     } else {
-      const queue = new BoundedEncryptedQueue(join(defaultRuntimeDirectory(), connection.installationId));
+      const root = defaultRuntimeDirectory();
+      const queue = new BoundedEncryptedQueue(join(root, connection.installationId));
       process.stdout.write(`${JSON.stringify({
         installationId: connection.installationId,
         clientKind: connection.clientKind,
         protocolVersion: connection.protocolVersion,
         pluginVersion: connection.pluginVersion,
+        runtimeVersion: RUNTIME_VERSION,
         proofStorage: connection.proofStorage,
+        health: await inspectCaptureHealth(connection, root),
+        declaredCapabilities: Object.fromEntries([
+          "userMessages", "assistantMessages", "toolInputs", "toolOutputs", "toolFailures",
+          "sessionEnd", "tokenUsage", "sessionMetadata", "images", "artifactBodies",
+        ].map((name) => [name, connection.capabilities?.[name] === true])),
+        serverCheck: "not_performed",
         queue: await queue.diagnostics(),
       }, null, 2)}\n`);
     }
   } catch (error) {
     if (hookEvent === "PreToolUse") process.stdout.write(`${JSON.stringify(skillInvocationDenial())}\n`);
-    process.stderr.write(`${error?.message || "Halofy MCP proxy unavailable"}\n`);
+    process.stderr.write(`${command === "diagnostics" ? "Halofy diagnostics unavailable" :
+      error?.message || "Halofy MCP proxy unavailable"}\n`);
     process.exitCode = hookEvent === "PreToolUse" ? 0 : 1;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halofy/agent-connect",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "type": "module",
   "description": "Halofy lifecycle installer and runtime for supported agents; runtime requests are signed with a per-installation Ed25519 key",
   "bin": {

package/src/health.mjs

@@ -140,8 +140,8 @@ export async function setCapturePaused(runtime, root, paused, { flushTimeoutMs =
           fetchImpl: runtime.transport.fetch, signal: controller.signal, timeoutMs: flushTimeoutMs,
         }),
       });
-      await flushRuntime.replay();
-      flushed = true;
+      const replay = await flushRuntime.replay();
+      flushed = replay.depth === 0;
     } catch { flushed = false; }
     finally { clearTimeout(timer); }
   }
@@ -160,8 +160,15 @@ export function startHealthHeartbeat(runtime, {
   let pending = null;
   const tick = () => {
     if (stopped || pending) return pending;
-    pending = Promise.resolve().then(() => runtime.heartbeat(runtime.connection.capabilities || {}))
-      .catch(() => {}).finally(() => { pending = null; });
+    pending = Promise.resolve().then(async () => {
+      // Report health independently: a failed append must not hide a running
+      // installation. The existing proxy transport bounds each request to 5s
+      // and aborts on exit; one batch needs at most one open and one append.
+      try { await runtime.heartbeat(runtime.connection.capabilities || {}); } catch { /* next tick retries */ }
+      if (!stopped) {
+        try { await runtime.replay?.({ maxBatches: 1, onlyWhileActive: true }); } catch { /* keep the durable queue */ }
+      }
+    }).finally(() => { pending = null; });
     return pending;
   };
   void tick();

package/src/host-hook.mjs

@@ -1,7 +1,6 @@
 import { captureStateSnapshot } from "./health.mjs";
-import { createHash } from "node:crypto";
 import { basename } from "node:path";
-import { LifecycleRuntime } from "./runtime.mjs";
+import { LifecycleRuntime, newLocalEventId } from "./runtime.mjs";
 import {
   normalizeClaudeHookEvent,
   normalizeHostMessageEvent,
@@ -29,10 +28,6 @@ export const HOST_HOOK_EVENTS = Object.freeze(new Set([
   ...SUBAGENT_START_EVENTS, ...SUBAGENT_STOP_EVENTS,
 ]));
 
-function digest(value) {
-  return createHash("sha256").update(String(value)).digest("hex");
-}
-
 function hostSession(input) {
   return String(input.session_id || input.conversation_id || input.taskId || input.task_id ||
     input.sessionKey || input.session_key || input.extra?.session_id || "");
@@ -46,8 +41,11 @@ function childSession(input, parent) {
 
 function eventEvidenceId(eventName, input) {
   const native = input.event_id || input.generation_id || input.turn_id || input.tool_call_id ||
-    input.taskId || input.task_id || input.extra?.turn_id || input.extra?.tool_call_id;
-  return native ? `${eventName}:${String(native)}` : `${eventName}:${digest(JSON.stringify(input))}`;
+    input.extra?.turn_id || input.extra?.tool_call_id;
+  // A task id identifies a session, and identical text can be a new turn.
+  // Without native event identity, assign one id per hook invocation. The
+  // encrypted queue retains that id across all transport retries.
+  return native ? `${eventName}:${String(native)}` : `${eventName}:${newLocalEventId()}`;
 }
 
 function promptText(input) {

package/src/runtime.mjs

@@ -11,6 +11,21 @@ import { readJson, withFileLock, writePrivateFile } from "./storage.mjs";
 import { capturePaused, captureStateSnapshot, captureAdmission, inspectCaptureHealth } from "./health.mjs";
 import { syncAgentInstructions } from "./instructions.mjs";
 import { RUNTIME_VERSION } from "./version.mjs";
+import { isActiveInstallation } from "./active.mjs";
+
+function acknowledgedPrefix(response, batchLength) {
+  const accepted = response?.acceptedCount !== undefined ? response.acceptedCount
+    : response?.acceptedPrefix !== undefined ? response.acceptedPrefix : response?.accepted;
+  const duplicates = response?.acceptedCount === undefined && response?.acceptedPrefix === undefined
+    ? (response?.duplicates ?? 0) : 0;
+  if (!Number.isSafeInteger(accepted) || accepted < 0 ||
+      !Number.isSafeInteger(duplicates) || duplicates < 0 || accepted + duplicates > batchLength) {
+    const error = new Error("append response did not acknowledge a valid event prefix");
+    error.code = "invalid_append_acknowledgement";
+    throw error;
+  }
+  return accepted + duplicates;
+}
 
 export class LifecycleRuntime {
   constructor(connection, {
@@ -177,7 +192,8 @@ export class LifecycleRuntime {
       if (usageGaps > 0) await this.cursors.bumpUsageGaps(usageGaps);
       return result;
     });
-    if (queued.queued === 0) return { queued: 0, acknowledged: 0 };
+    // A previous hook may have persisted this entire suffix before its append
+    // failed. Retry that durable queue even when there are no new host records.
     const replay = await this.replay();
     return { queued: queued.queued, acknowledged: replay.acknowledged };
   }
@@ -228,13 +244,20 @@ export class LifecycleRuntime {
     await this.cursors.rememberEventKeys(sessionHash, unseenEvents.map((event) => event.eventKey));
   }
 
-  async replay() {
-    return withFileLock(this.operationLockPath, () => this.#replayUnlocked());
+  async replay({ maxBatches = Number.MAX_SAFE_INTEGER, onlyWhileActive = false } = {}) {
+    if (!Number.isSafeInteger(maxBatches) || maxBatches < 1) throw new Error("invalid replay batch limit");
+    return withFileLock(this.operationLockPath, async () => {
+      if (onlyWhileActive && (await capturePaused(this.root, this.connection.installationId) ||
+          !await isActiveInstallation(this.connection, this.root))) {
+        return { acknowledged: 0, ...(await this.queue.diagnostics()) };
+      }
+      return this.#replayUnlocked(maxBatches);
+    });
   }
 
-  async #replayUnlocked() {
+  async #replayUnlocked(maxBatches = Number.MAX_SAFE_INTEGER) {
     let acknowledged = 0;
-    while (true) {
+    for (let batch = 0; batch < maxBatches; batch += 1) {
       const head = await this.queue.peek();
       if (!head) break;
       const sessionId = await this.resolveSessionByHash(head.sessionHash);
@@ -244,23 +267,11 @@ export class LifecycleRuntime {
         payloadSha256,
         ...event
       }) => ({ ...event, eventId: eventKey })));
-      const accepted = Math.max(0, Math.min(
-        head.events.length,
-        Number(response?.acceptedCount ?? response?.acceptedPrefix ??
-          (response?.accepted === undefined ? head.events.length : Number(response.accepted) + Number(response.duplicates ?? 0))),
-      ));
-      if (accepted === 0) {
-        if (Number.isSafeInteger(response?.nextExpectedSequence)) {
-          const expected = response.nextExpectedSequence;
-          const firstExpected = head.events.findIndex((event) => event.sequence >= expected);
-          if (firstExpected > 0) {
-            await this.#acknowledge(head, firstExpected);
-            acknowledged += firstExpected;
-            continue;
-          }
-        }
-        break;
-      }
+      // A success HTTP status or an advanced server cursor is insufficient:
+      // the prefix must be explicitly accepted or confirmed as duplicates.
+      // In particular, event_conflict must retain the rejected local bodies.
+      const accepted = acknowledgedPrefix(response, head.events.length);
+      if (accepted === 0) break;
       await this.#acknowledge(head, accepted);
       acknowledged += accepted;
     }

package/src/version.mjs

@@ -1,4 +1,4 @@
 export const PACKAGE_NAME = "@halofy/agent-connect";
-export const INSTALLER_VERSION = "0.13.0";
-export const RUNTIME_VERSION = "0.13.0";
+export const INSTALLER_VERSION = "0.13.1";
+export const RUNTIME_VERSION = "0.13.1";
 export const DISCLOSURE_VERSION = "halofy-agent-lifecycle-2026-09-17.1";