@agentchatme/agent-core 0.0.13 → 0.0.131

package/dist/daemon-entry.js

@@ -7,7 +7,7 @@ import {
   idle,
   log,
   resolveIdentity
-} from "./chunk-NEGTEBFK.js";
+} from "./chunk-XLRPNQ7G.js";
 
 // src/daemon/ws-client.ts
 import { WebSocket } from "ws";

package/dist/index.d.ts

@@ -216,6 +216,55 @@ declare function offerDeclined(home: string): boolean;
 /** Cleared when an identity is established, so a later logout asks again. */
 declare function clearOfferDeclined(home: string): void;
 
+declare const HEARTBEAT_FILE = "daemon.heartbeat";
+/** Record that the user wants always-on for this agent.
+ *
+ *  The file's MTIME is load-bearing: `alwaysOnState` uses it as the moment
+ *  registration happened, so a service that was just installed is not reported
+ *  as broken before its daemon has had time to draw breath. */
+declare function markAlwaysOnWanted(home: string): void;
+/** Forget the intent (user chose session-only, or uninstalled). */
+declare function clearAlwaysOnWanted(home: string): void;
+declare function alwaysOnWanted(home: string): boolean;
+/** Remember that the user switched always-on off. Survives re-install. */
+declare function markAlwaysOnOptOut(home: string): void;
+/** Cleared only by an explicit `daemon install` — never implicitly. */
+declare function clearAlwaysOnOptOut(home: string): void;
+declare function alwaysOnOptedOut(home: string): boolean;
+/** Touch the liveness beacon. Called by the running daemon. */
+declare function beat(home: string): void;
+/** Clear the beacon. The daemon calls this whenever it is resident but NOT
+ *  connected, so "idle" is never mistaken for "beating". */
+declare function idle(home: string): void;
+/**
+ * Always-on has THREE states, not two.
+ *
+ * It used to be a boolean pair, which could not tell "idle because nobody is
+ * signed in" apart from "installed and broken" — so a signed-out user would be
+ * nagged every session about a daemon that was behaving exactly as intended.
+ *
+ *   off       — the service is not installed (or was explicitly disabled).
+ *   idle      — installed and resident, but there is no identity to serve.
+ *               Correct and quiet: the daemon is waiting for a sign-in.
+ *   starting  — registered moments ago and not beating yet. Also quiet: the
+ *               service manager has not finished bringing it up.
+ *   connected — holding the wire; the beacon is fresh.
+ *   down      — there IS an identity and the service is installed, but nothing
+ *               is beating. The only state worth telling a session about.
+ *
+ * Pure reads, no subprocess, never throws.
+ */
+type AlwaysOnState = 'off' | 'idle' | 'starting' | 'connected' | 'down';
+declare function alwaysOnState(home: string): AlwaysOnState;
+/**
+ * Back-compatible view for callers that only need "should I warn?".
+ * `healthy` is false ONLY in the `down` state — an idle daemon is healthy.
+ */
+declare function alwaysOnHealth(home: string): {
+    wanted: boolean;
+    healthy: boolean;
+};
+
 declare function formatSessionStart(handle: string | null, rows: SyncRow[]): string;
 declare function formatStopPickup(handle: string | null, rows: SyncRow[]): string;
 /**
@@ -242,7 +291,24 @@ interface HostCopy {
     /** Human label for the host, e.g. `Codex` or `Claude Code`. */
     label: string;
 }
-declare function formatRegistrationOffer(copy: HostCopy): string;
+/**
+ * What a session is told when the integration is installed but has no identity.
+ *
+ * Two things this must NOT do, both learned from the first real install:
+ *
+ *  • It must not read like a runbook. The earlier version was a numbered list
+ *    of CLI invocations, and agents did the natural thing with a numbered list
+ *    of CLI invocations: they pasted it at the user. Someone who just installed
+ *    a plugin got a wall of `--email`/`--code` syntax instead of "want a handle
+ *    other agents can message you at?". The commands are the AGENT'S to run;
+ *    that has to be said outright, because the format alone implies otherwise.
+ *
+ *  • It must not assert always-on is running. That line used to be
+ *    unconditional, so a session whose registration had just FAILED was told
+ *    always-on was already up — the one moment the user needed to know it was
+ *    not.
+ */
+declare function formatRegistrationOffer(copy: HostCopy, alwaysOn?: AlwaysOnState): string;
 /**
  * "You have AgentChat but no handle — offer to set one up."
  *
@@ -458,49 +524,6 @@ declare function renderManual(copy: ManualCopy, opts?: {
     frontMatter?: boolean;
 }): string;
 
-declare const HEARTBEAT_FILE = "daemon.heartbeat";
-/** Record that the user wants always-on for this agent. */
-declare function markAlwaysOnWanted(home: string): void;
-/** Forget the intent (user chose session-only, or uninstalled). */
-declare function clearAlwaysOnWanted(home: string): void;
-declare function alwaysOnWanted(home: string): boolean;
-/** Remember that the user switched always-on off. Survives re-install. */
-declare function markAlwaysOnOptOut(home: string): void;
-/** Cleared only by an explicit `daemon install` — never implicitly. */
-declare function clearAlwaysOnOptOut(home: string): void;
-declare function alwaysOnOptedOut(home: string): boolean;
-/** Touch the liveness beacon. Called by the running daemon. */
-declare function beat(home: string): void;
-/** Clear the beacon. The daemon calls this whenever it is resident but NOT
- *  connected, so "idle" is never mistaken for "beating". */
-declare function idle(home: string): void;
-/**
- * Always-on has THREE states, not two.
- *
- * It used to be a boolean pair, which could not tell "idle because nobody is
- * signed in" apart from "installed and broken" — so a signed-out user would be
- * nagged every session about a daemon that was behaving exactly as intended.
- *
- *   off       — the service is not installed (or was explicitly disabled).
- *   idle      — installed and resident, but there is no identity to serve.
- *               Correct and quiet: the daemon is waiting for a sign-in.
- *   connected — holding the wire; the beacon is fresh.
- *   down      — there IS an identity and the service is installed, but nothing
- *               is beating. The only state worth telling a session about.
- *
- * Pure reads, no subprocess, never throws.
- */
-type AlwaysOnState = 'off' | 'idle' | 'connected' | 'down';
-declare function alwaysOnState(home: string): AlwaysOnState;
-/**
- * Back-compatible view for callers that only need "should I warn?".
- * `healthy` is false ONLY in the `down` state — an idle daemon is healthy.
- */
-declare function alwaysOnHealth(home: string): {
-    wanted: boolean;
-    healthy: boolean;
-};
-
 interface LockHandle {
     release(): void;
 }

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   syncPeek,
   writeCredentials,
   writePending
-} from "./chunk-NEGTEBFK.js";
+} from "./chunk-XLRPNQ7G.js";
 
 // src/identity/state.ts
 var SESSION_TTL_MS = 48 * 60 * 60 * 1e3;
@@ -359,29 +359,45 @@ function formatStopPickup(handle, rows) {
 function formatAlwaysOnDown(copy) {
   return `\u26A0 Always-on is down \u2014 while you are away I won\u2019t be able to answer messages (they queue for your next session, nothing is lost). Turn it back on: \`${copy.invoke} daemon install\``;
 }
-function formatRegistrationOffer(copy) {
+function formatRegistrationOffer(copy, alwaysOn = "off") {
   const { invoke, label } = copy;
   return [
-    `The AgentChat plugin is installed but this ${label} agent has no AgentChat identity yet.`,
+    `This ${label} agent is on AgentChat but has no handle yet \u2014 no address other agents can reach it at.`,
     "",
-    "AgentChat gives you (the agent) a handle other agents can DM. If the user would like that, offer to set it up \u2014 and FIRST ask whether they already have an AgentChat account (e.g. from another machine, or a Hermes / OpenClaw agent), so you sign them in instead of creating a duplicate:",
-    `This ${label} agent gets its OWN handle \u2014 separate from any other coding agent on this machine, which is exactly what lets them DM each other. Use an email not already tied to another agent.`,
+    "If the moment is right, offer it in ONE plain sentence and let them answer. Do not paste this block,",
+    "do not list the commands, do not walk them through steps. You run the commands; they just talk to you.",
     "",
-    "NEW to AgentChat (most people):",
-    "  1. Ask for their email + a desired handle (3\u201330 chars, lowercase letters/digits/hyphens, must start with a letter).",
-    `  2. Run: ${invoke} register --email <email> --handle <handle>`,
-    `  3. A 6-digit code lands in their email; ask for it, then run: ${invoke} register --code <code>`,
-    "",
-    "ALREADY have an AgentChat agent \u2014 sign in, do NOT register a second one:",
-    `  \u2022 They have its API key (ac_\u2026):  ${invoke} login --api-key <ac_\u2026>`,
-    `  \u2022 They lost the key:  ${invoke} recover --email <email>, then relay the emailed 6-digit code: ${invoke} recover --code <code>`,
+    "All you need from them is an email and a handle they like (3\u201330 characters, lowercase letters, digits",
+    "and hyphens, starting with a letter). Ask first whether they already have an AgentChat account \u2014 from",
+    "another machine, or a Hermes or OpenClaw agent \u2014 so you sign that one in instead of creating a second.",
+    `Either way this ${label} agent ends up with its own handle, separate from any other coding agent here,`,
+    "which is what lets them message each other.",
     "",
+    "Commands \u2014 yours to run, not to show:",
+    `  new account    ${invoke} register --email <email> --handle <handle>`,
+    `                 then, with the 6-digit code they were emailed: ${invoke} register --code <code>`,
+    `  has an API key ${invoke} login --api-key <ac_\u2026>`,
+    `  lost the key   ${invoke} recover --email <email>, then ${invoke} recover --code <code>`,
     "",
-    "Always-on is already running \u2014 this agent answers DMs even when no session is open. There is nothing to switch on, so do not offer to.",
+    alwaysOnNote(alwaysOn, invoke),
     "",
-    "Do not push the offer \u2014 one short ask is plenty. If declined, drop the topic for the rest of the session."
+    `One ask is plenty. If they decline or change the subject, drop it \u2014 and \`${invoke} register --not-now\``,
+    "stops it being raised in future sessions too."
   ].join("\n");
 }
+function alwaysOnNote(state, invoke) {
+  switch (state) {
+    case "connected":
+      return "Always-on is running: this agent answers DMs even with no session open. Nothing to switch on.";
+    case "idle":
+    case "starting":
+      return "Always-on is set up and will start answering DMs on its own as soon as there is a handle. Nothing to switch on.";
+    case "off":
+      return "Always-on is not set up here, so DMs are only seen during a session.";
+    case "down":
+      return `Always-on is registered but not running \u2014 \`${invoke} daemon status\` says why. DMs are only seen during a session until it recovers.`;
+  }
+}
 function renderUnregisteredBlock(copy) {
   const { invoke, label } = copy;
   return [
@@ -469,7 +485,7 @@ async function sessionStart(ctx, input) {
     if (identity === null) {
       if (shouldOfferRegistration(ctx.home)) {
         recordRegistrationOffer(ctx.home);
-        return { context: formatRegistrationOffer(ctx.copy) };
+        return { context: formatRegistrationOffer(ctx.copy, alwaysOnState(ctx.home)) };
       }
       return none;
     }