@hellolynk-ai/workbuddy-mcp 0.3.101 → 0.3.103

package/clients/core/hellolynk-client-core.mjs

@@ -1,9 +1,11 @@
+import { createHash } from "node:crypto";
 import runtimeSafety from "./hellolynk-runtime-safety.cjs";
 const DEFAULT_TIMEOUT_MS = 10_000;
 const MAX_JSON_RESPONSE_BYTES = 256 * 1024;
 const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]"]);
 const DEVICE_RUNTIME_TTL_MS = 20 * 60 * 1000;
 const DEVICE_RUNTIME_RECOVERY_WINDOW_MS = 120_000;
+const DEVICE_CREDENTIAL_RECHECK_MS = 60 * 60_000;
 const DEVICE_RUNTIME_SCOPES = Object.freeze([
   "relay.text.receive",
   "relay.text.send",
@@ -567,6 +569,7 @@ export function createDeviceRuntimeSessionManager(options = {}) {
   const issue = options.issue || issueDeviceRuntimeSession;
   const now = options.now || (() => Date.now());
   const sessionStore = options.sessionStore || null;
+  const credentialRejections = sessionStore?.credentialRejections;
   const sessionKey = options.sessionKey == null ? null : String(options.sessionKey);
   if (sessionStore && (
     !sessionKey ||
@@ -580,6 +583,8 @@ export function createDeviceRuntimeSessionManager(options = {}) {
     5 * 60 * 1000,
   );
   let current = null;
+  let rejectedCredential = null;
+  let localIssueTail = Promise.resolve();
 
   const routeMatches = (session, input) => {
     const expectedValues = [
@@ -652,22 +657,67 @@ export function createDeviceRuntimeSessionManager(options = {}) {
     return proof;
   };
 
+  const issueSession = async (input, previousSession) => {
+    const request = { ...input, previousSession };
+    if (options.loadDeviceCredential) request.deviceCredential = await options.loadDeviceCredential();
+    const fingerprint = request.deviceCredential && request.baseUrl
+      ? createHash("sha256").update(JSON.stringify([
+        normalizeHelloLynkBaseUrl(request.baseUrl, { allowLoopbackHttp: request.allowLoopbackHttp === true }),
+        request.deviceCredential,
+      ])).digest("hex")
+      : null;
+    // The production caller holds the existing session lock, including across
+    // Host processes. An authority denial may drain the current Host.
+    if (fingerprint) {
+      const isCoolingDown = (rejection) => {
+        if (rejection?.fingerprint !== fingerprint) return false;
+        const age = now() - rejection.rejectedAtMs;
+        return age >= 0 && age < DEVICE_CREDENTIAL_RECHECK_MS;
+      };
+      // A generic denial may clear after a server-side repair, without a new
+      // credential. The lock permits one recheck once the cooldown ends.
+      if (isCoolingDown(rejectedCredential)
+        || isCoolingDown(await credentialRejections?.load(sessionKey).catch(() => null))) {
+        throw new HelloLynkClientError("device_credential_invalid", { httpStatus: 401 });
+      }
+    }
+    let session;
+    try {
+      session = reusable(await issue(request), input);
+    } catch (error) {
+      if (fingerprint && error?.httpStatus === 401 && error.code === "device_credential_invalid") {
+        rejectedCredential = { fingerprint, rejectedAtMs: now() };
+        // Preserve the authority denial even if local storage is unavailable.
+        await credentialRejections?.save(sessionKey, rejectedCredential).catch(() => {});
+      }
+      throw error;
+    }
+    if (session && fingerprint) {
+      rejectedCredential = null;
+      await credentialRejections?.remove(sessionKey).catch(() => {});
+    }
+    return session;
+  };
+
   return {
     async get(input) {
       if (!sessionStore) {
-        if (
-          current && current.expiresAtMs - now() > minimumRemainingMs
-          && routeMatches(current, input)
-          && scopesMatch(current, input)
-          && (input?.expectedAgentId == null || input.expectedAgentId === current.agentId)
-          && (input?.expectedPrincipalId == null || input.expectedPrincipalId === current.principalId)
-        ) return current;
-        const reusableCurrent = reusable(current, input);
-        if (reusableCurrent) return reusableCurrent;
-        const previousSession = recoveryProof(current, input);
-        current = reusable(await issue({ ...input, previousSession }), input);
-        if (!current) throw new HelloLynkClientError("invalid_runtime_session_handle");
-        return current;
+        const result = localIssueTail.then(async () => {
+          if (
+            current && current.expiresAtMs - now() > minimumRemainingMs
+            && routeMatches(current, input)
+            && scopesMatch(current, input)
+            && (input?.expectedAgentId == null || input.expectedAgentId === current.agentId)
+            && (input?.expectedPrincipalId == null || input.expectedPrincipalId === current.principalId)
+          ) return current;
+          const reusableCurrent = reusable(current, input);
+          if (reusableCurrent) return reusableCurrent;
+          current = await issueSession(input, recoveryProof(current, input));
+          if (!current) throw new HelloLynkClientError("invalid_runtime_session_handle");
+          return current;
+        });
+        localIssueTail = result.catch(() => {});
+        return result;
       }
       const inMemory = reusable(current, input);
       if (inMemory) return inMemory;
@@ -678,7 +728,7 @@ export function createDeviceRuntimeSessionManager(options = {}) {
           current = persisted;
           return current;
         }
-        const issued = reusable(await issue({ ...input, previousSession: persisted }), input);
+        const issued = await issueSession(input, persisted);
         if (!issued) throw new HelloLynkClientError("invalid_runtime_session_handle");
         await sessionStore.save(sessionKey, issued);
         current = issued;

package/clients/core/hellolynk-neutral-host-assembly.mjs

@@ -7,7 +7,6 @@ import path from "node:path";
 
 import {
   createDeviceRuntimeSessionManager,
-  issueDeviceRuntimeSession,
   normalizeHelloLynkBaseUrl,
 } from "./hellolynk-client-core.mjs";
 import { readClientProfile } from "./hellolynk-client-profile.mjs";
@@ -243,31 +242,19 @@ export async function startHelloLynkNeutralHostAssembly(options = {}, dependenci
     const manager = (dependencies.createRuntimeSessionManager || createDeviceRuntimeSessionManager)({
       sessionStore: credentialStore.runtimeSessions,
       sessionKey,
-      issue: async ({ previousSession } = {}) => {
-        let deviceCredential = await credentialStore.load(profile.profileId);
-        try {
-          return await (dependencies.issueRuntimeSession || issueDeviceRuntimeSession)({
-            baseUrl: profile.baseUrl,
-            allowLoopbackHttp: profile.allowLoopbackHttp,
-            deviceCredential,
-            expectedPrincipalId: profile.principalId,
-            expectedAgentId: profile.agentId,
-            expectedDelegateId: profile.delegateId,
-            expectedHostId: profile.hostId,
-            expectedAuthorizationVersion: profile.authorizationVersion,
-            previousSession,
-            fetchImpl: dependencies.fetchImpl,
-          });
-        } finally { deviceCredential = null; }
-      },
+      loadDeviceCredential: () => credentialStore.load(profile.profileId),
+      issue: dependencies.issueRuntimeSession,
     });
     const sessionProvider = Object.freeze({
       get: () => manager.get({
+        baseUrl: profile.baseUrl,
+        allowLoopbackHttp: profile.allowLoopbackHttp,
         expectedPrincipalId: profile.principalId,
         expectedAgentId: profile.agentId,
         expectedDelegateId: profile.delegateId,
         expectedHostId: profile.hostId,
         expectedAuthorizationVersion: profile.authorizationVersion,
+        fetchImpl: dependencies.fetchImpl,
       }),
       clear: (error) => manager.clear(error),
       status: () => manager.status(),
@@ -347,6 +334,9 @@ export async function startHelloLynkNeutralHostAssembly(options = {}, dependenci
       authorizationVersion: profile.authorizationVersion,
       identityKeyId: e2ee.identityKeyId,
       runtimeHeaders: () => runtimeHeaders(sessionProvider),
+      // Drops only this instance's cached runtime session, and only for a stale
+      // session, so the Host can verify it once more with the device credential.
+      clearRuntimeSession: (error) => sessionProvider.clear(error),
       e2ee,
       contactE2ee,
     }));

package/clients/core/hellolynk-neutral-host-process.mjs

@@ -1,6 +1,7 @@
 import { nativeConversationId, nativeConversationQuery, nativeDirectoryResult, queryLocalNativeConversations } from "./hellolynk-native-conversations.mjs";
 import { DIRECT_TEXT_E2EE_MAX_TTL_MS } from "./hellolynk-direct-text-e2ee.mjs";
 import { runModelInbox } from "./hellolynk-model-inbox.mjs";
+import { shouldInvalidateDeviceRuntimeSession } from "./hellolynk-client-core.mjs";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import http from "node:http";
@@ -34,7 +35,7 @@ export const HELLOLYNK_NEUTRAL_HOST_PROCESS_CONTRACT = "hellolynk-neutral-host-p
 export const HELLOLYNK_NEUTRAL_HOST_DISCOVERY_CONTRACT = "hellolynk-neutral-host-discovery-v1";
 // Raised with every release batch, together with the six client versions. A Host reports it
 // in its health; the higher release stays and the lower one makes room.
-export const HELLOLYNK_HOST_RELEASE_ORDINAL = 16;
+export const HELLOLYNK_HOST_RELEASE_ORDINAL = 18;
 
 const INSTALLATION_LOCK_CONTRACT = "hellolynk-neutral-host-installation-lock-v2";
 const INSTALLATION_LOCK_MAX_BYTES = 4 * 1024;
@@ -97,9 +98,16 @@ const PREKEY_REFILL_RETRY_MIN_MS = 1_000;
 const PREKEY_REFILL_RETRY_MAX_MS = 60_000;
 const RELAY_RETRY_MIN_MS = 1_000;
 const RELAY_RETRY_MAX_MS = 60_000;
-const RELAY_AUTHORITY_DENIAL_CODES = new Set([
+// Revocation of this Host or its transport credential fences the whole Host.
+const HOST_AUTHORITY_DENIAL_CODES = new Set([
   "host_transport_host_revoked", "host_transport_credential_revoked", "host_transport_credential_inactive",
+]);
+// A refusal of one instance's own device credential or delegate stops only that
+// instance. The Host and its other instances keep receiving and sending. The
+// server reports these when issuing or using that instance's runtime session.
+const ENDPOINT_AUTHORITY_DENIAL_CODES = new Set([
   "device_credential_invalid", "device_credential_revoked", "delegate_revoked", "delegate_inactive",
+  "device_credential_identity_inactive", "device_credential_inactive", "runtime_identity_inactive",
 ]);
 const MESSAGE_LOCAL_CAPACITY_CODES = new Set(["local_message_store_too_large"]);
 const CONTACT_REQUEST_LOCAL_CAPACITY_CODES = new Set([
@@ -247,6 +255,9 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
   let receiverState = null;
   const relayAbortController = new AbortController();
   const relayProvisionedEndpoints = new Set();
+  // Refused instances and their refusal code. Only a later successful registration
+  // (the next relay connection or session rotation) readmits one.
+  const rejectedEndpoints = new Map();
   const relayState = { status: "connecting", failureCount: 0, nextAttemptAtMs: 0, errorCode: null };
   const rejectedInboundTimes = new WeakSet();
   let lastRejectedInbound = null;
@@ -600,6 +611,20 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
             lastRejectedInbound = { errorCode: error.code };
             continue;
           }
+          // The frame's own instance was refused (for example at ACK). Stop only that
+          // instance and skip the frame; the relay expires or redelivers it.
+          const refused = ENDPOINT_AUTHORITY_DENIAL_CODES.has(error?.code)
+            && endpoints.get(String(item.data?.recipientDelegateId || ""));
+          if (refused) {
+            rejectedEndpoints.set(refused.delegateId, error.code);
+            relayState.errorCode = error.code;
+            lastRejectedInbound = { errorCode: error.code };
+            continue;
+          }
+          // A stale runtime session (such as a revocation landing between persist and
+          // ACK) is not a local failure. Reconnect: registration verifies that instance
+          // again and isolates it if refused. The durable record stays; the relay redelivers.
+          if (shouldInvalidateDeviceRuntimeSession(error)) throw error;
           if (!isInboundLocalCapacityError(error)) {
             inboundFailed = true;
             throw error;
@@ -612,7 +637,7 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
     } catch (error) {
       if (lifecycle !== "running") return;
       // Preserve fail-closed persistence/ACK and other malformed-inbound errors.
-      if (inboundFailed || RELAY_AUTHORITY_DENIAL_CODES.has(error?.code)) throw error;
+      if (inboundFailed || HOST_AUTHORITY_DENIAL_CODES.has(error?.code)) throw error;
       await stream?.close?.().catch(() => {});
       stream = null;
       scheduleRelayRetry(error);
@@ -638,31 +663,63 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
     const task = (async () => {
       let connected = null;
       try {
-        const registrations = await Promise.allSettled([...endpoints.values()].map(async (endpoint) => {
-          if (endpoint.e2ee?.preKeyInventoryStatus?.status === "deferred"
-            && !relayProvisionedEndpoints.has(endpoint.delegateId)) {
-            try {
-              await endpoint.e2ee.ensurePreKeyInventory({ signal });
-            } catch (error) {
-              if (error?.code !== "e2ee_local_prekey_capacity_exceeded") throw error;
-              const state = preKeyRefillState(endpoint.delegateId);
-              state.failureCount = 1;
-              state.nextAttemptAtMs = Math.max(nowMs(clock) + PREKEY_REFILL_RETRY_MIN_MS, retryAtTimestamp(error.retryAt) || 0);
-              state.errorCode = error.code;
+        const attempted = [...endpoints.values()];
+        const registrations = await Promise.allSettled(attempted.map(async (endpoint) => {
+          const register = async () => {
+            if (endpoint.e2ee?.preKeyInventoryStatus?.status === "deferred"
+              && !relayProvisionedEndpoints.has(endpoint.delegateId)) {
+              try {
+                await endpoint.e2ee.ensurePreKeyInventory({ signal });
+              } catch (error) {
+                if (error?.code !== "e2ee_local_prekey_capacity_exceeded") throw error;
+                const state = preKeyRefillState(endpoint.delegateId);
+                state.failureCount = 1;
+                state.nextAttemptAtMs = Math.max(nowMs(clock) + PREKEY_REFILL_RETRY_MIN_MS, retryAtTimestamp(error.retryAt) || 0);
+                state.errorCode = error.code;
+              }
+              relayProvisionedEndpoints.add(endpoint.delegateId);
             }
-            relayProvisionedEndpoints.add(endpoint.delegateId);
+            if (signal.aborted || lifecycle !== "running") return;
+            await options.transport.registerEndpoint({
+              delegateId: endpoint.delegateId, identityKeyId: endpoint.identityKeyId,
+              runtimeHeaders: endpoint.runtimeHeaders, signal,
+            });
+          };
+          try {
+            await register();
+          } catch (error) {
+            // Revoking an instance also drops its runtime session, so its cached session
+            // fails first. Clear only that stale cache and verify once more: a device
+            // refusal then isolates the instance; any other failure keeps the usual path.
+            const cleared = !shouldInvalidateDeviceRuntimeSession(error) || signal.aborted || lifecycle !== "running"
+              || typeof endpoint.clearRuntimeSession !== "function" ? false
+              : await Promise.resolve().then(() => endpoint.clearRuntimeSession(error)).catch(() => false);
+            if (cleared !== true) throw error;
+            await register();
           }
-          if (signal.aborted || lifecycle !== "running") return;
-          await options.transport.registerEndpoint({
-            delegateId: endpoint.delegateId, identityKeyId: endpoint.identityKeyId,
-            runtimeHeaders: endpoint.runtimeHeaders, signal,
-          });
         }));
         if (signal.aborted || lifecycle !== "running") return;
-        const failed = registrations.find((result) => result.status === "rejected"
-          && RELAY_AUTHORITY_DENIAL_CODES.has(result.reason?.code))
-          || registrations.find((result) => result.status === "rejected");
+        const hostDenial = registrations.find((result) => result.status === "rejected"
+          && HOST_AUTHORITY_DENIAL_CODES.has(result.reason?.code));
+        if (hostDenial) throw hostDenial.reason;
+        // A refused instance stays out of the relay while the others connect. Each
+        // later connection, including session rotation, registers it again.
+        registrations.forEach((result, index) => {
+          if (result.status === "fulfilled") rejectedEndpoints.delete(attempted[index].delegateId);
+          else if (ENDPOINT_AUTHORITY_DENIAL_CODES.has(result.reason?.code)) {
+            rejectedEndpoints.set(attempted[index].delegateId, result.reason.code);
+          }
+        });
+        // A refused instance whose re-verification fails for another reason (such as
+        // its dropped runtime session) stays refused and does not hold back the others.
+        const failed = registrations.find((result, index) => result.status === "rejected"
+          && !rejectedEndpoints.has(attempted[index].delegateId));
         if (failed) throw failed.reason;
+        // With every instance refused there is nothing to receive: keep the Host and
+        // retry with the usual backoff. The session manager bounds cloud rechecks.
+        if (rejectedEndpoints.size === endpoints.size) {
+          throw registrations.find((result) => result.status === "rejected").reason;
+        }
         connected = await openRelayStream(signal);
         if (!connected?.events || typeof connected.events[Symbol.asyncIterator] !== "function") {
           throw failure("neutral_host_transport_stream_invalid");
@@ -672,14 +729,15 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
           return;
         }
         stream = connected;
-        Object.assign(relayState, { status: "ready", failureCount: 0, nextAttemptAtMs: 0, errorCode: null });
+        Object.assign(relayState, { status: "ready", failureCount: 0, nextAttemptAtMs: 0,
+          errorCode: rejectedEndpoints.values().next().value ?? null });
         startReceiveTask();
       } catch (error) {
         await connected?.close?.().catch(() => {});
         if (signal.aborted || lifecycle !== "running") return;
         // An explicit revocation of this Host still fences local access. A
         // timeout/expired cloud session alone is not a local revocation.
-        if (RELAY_AUTHORITY_DENIAL_CODES.has(error?.code)) {
+        if (HOST_AUTHORITY_DENIAL_CODES.has(error?.code)) {
           // Failure is exposed as host.status/failureCode to the release entry.
           void beginDrain(error.code).catch(() => {});
           return;
@@ -733,6 +791,14 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
     }
     const endpoint = endpoints.get(safeId(event.recipientDelegateId, "neutral_host_inbound_delegate_invalid"));
     if (!endpoint) throw failure("neutral_host_inbound_endpoint_unknown");
+    if (rejectedEndpoints.has(endpoint.delegateId)) {
+      // A refused instance receives nothing, also not from its Host's siblings.
+      // Relay frames are skipped unacknowledged; a local sender sees the failure.
+      const refused = failure(item.localDelivery === true
+        ? "neutral_host_same_host_recipient_unavailable" : rejectedEndpoints.get(endpoint.delegateId));
+      rejectedInboundTimes.add(refused);
+      throw refused;
+    }
     const isContactRequest = item.event === "contact_request";
     if (!isContactRequest && item.event !== "message") throw failure("neutral_host_inbound_kind_invalid");
     const decryptor = isContactRequest ? endpoint.contactE2ee : endpoint.e2ee;
@@ -1015,7 +1081,14 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
     return inboundResumeTask;
   }
 
+  // A refused instance does not send, including over local routes that skip the relay.
+  function assertEndpointAccepted(delegateId) {
+    const code = rejectedEndpoints.get(delegateId);
+    if (code) throw hostApplicationFailure(code);
+  }
+
   async function sendOutboundOnce({ endpoint, delegateId, clientMessageId, input }) {
+    assertEndpointAccepted(endpoint.delegateId);
     try {
       const result = await endpoint.outbound.send(input);
       if (result?.message?.lastErrorCode === "reply_target_deleted" || result?.relay?.status === "reply_target_deleted") {
@@ -1529,6 +1602,7 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
   async function queryPeerNativeDirectory(delegateId, authorization, request) {
     const sender = endpoints.get(delegateId);
     if (!sender?.outbound?.sendDirectory) throw hostApplicationFailure("native_directory_unavailable");
+    assertEndpointAccepted(delegateId);
     const friend = request.kind === "friend_target_request";
     const unavailable = friend ? null : nativeDirectoryResult({ conversations: [], coverage: "unavailable",
       available: false, exactTargetSupported: false, reason: "native_directory_unavailable" });
@@ -2274,6 +2348,7 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
       || current.senderDelegateId !== context.delegateId) {
       throw hostApplicationFailure("host_app_record_not_found");
     }
+    assertEndpointAccepted(context.delegateId);
     if (!MANUAL_RETRYABLE_STATUSES.has(current.status) || current.lastErrorCode === "reply_target_deleted") {
       throw hostApplicationFailure("host_app_state_conflict");
     }
@@ -3120,7 +3195,8 @@ export async function startHelloLynkNeutralHostProcess(options = {}) {
     return {
       status: inboundPaused
         ? "paused"
-        : preKeyInventory.status === "ready" && relayState.status === "ready" && !lastRejectedInbound ? "ready" : "degraded",
+        : preKeyInventory.status === "ready" && relayState.status === "ready" && !lastRejectedInbound
+          && rejectedEndpoints.size === 0 ? "ready" : "degraded",
       ...(lastRejectedInbound ? { lastRejectedInbound } : {}),
       preKeyInventory,
       relay: {

package/clients/core/hellolynk-platform-credential-store.mjs

@@ -297,6 +297,36 @@ export async function secureWindowsClientReleaseTree(clientRoot, releaseId, opti
   });
 }
 
+// Accessed under the same cross-process lock as the corresponding session.
+function createCredentialRejectionStore(root) {
+  const fileFor = (profile) => join(root, `runtime-session-rejection-${assertCredentialProfileId(profile)}.json`);
+  const isRejection = (value) => typeof value?.fingerprint === "string" && /^[a-f0-9]{64}$/.test(value.fingerprint)
+    && Number.isSafeInteger(value.rejectedAtMs) && value.rejectedAtMs >= 0;
+  return {
+    async load(profile) {
+      let value;
+      try { value = JSON.parse(await readFile(fileFor(profile), "utf8")); }
+      catch (error) { if (error?.code === "ENOENT" || error instanceof SyntaxError) return null; throw error; }
+      return isRejection(value) ? value : null;
+    },
+    async save(profile, rejection) {
+      if (!isRejection(rejection)) throw new HelloLynkCredentialStoreError("invalid_credential_rejection");
+      const { fingerprint, rejectedAtMs } = rejection;
+      const file = fileFor(profile);
+      const temporary = `${file}.${randomBytes(12).toString("hex")}.tmp`;
+      try {
+        await writeFile(temporary, `${JSON.stringify({ fingerprint, rejectedAtMs })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+        await rename(temporary, file);
+      } finally {
+        await rm(temporary, { force: true }).catch(() => {});
+      }
+    },
+    async remove(profile) {
+      await rm(fileFor(profile), { force: true });
+    },
+  };
+}
+
 export function createPlatformCredentialStore(options = {}) {
   const platform = options.platform || process.platform;
   const run = options.runHelper || runCredentialHelper;
@@ -370,6 +400,7 @@ export function createPlatformCredentialStore(options = {}) {
         await invoke("Remove", assertCredentialProfileId(profile), "");
       },
       runtimeSessions: {
+        credentialRejections: createCredentialRejectionStore(runtimeStoreRoot),
         async save(profile, session) {
           const body = JSON.stringify({ schemaVersion: 1, ...assertRuntimeSession(session) });
           await invoke("StoreRuntimeSession", assertCredentialProfileId(profile), body);
@@ -504,6 +535,7 @@ export function createPlatformCredentialStore(options = {}) {
       },
       async remove(profile) { await entry(root, "device", profile, "remove"); },
       runtimeSessions: {
+        credentialRejections: createCredentialRejectionStore(root),
         async save(profile, session) { await entry(root, "session", profile, "save", assertRuntimeSession(session)); },
         async load(profile) {
           const value = await entry(root, "session", profile, "load");

package/hellolynk-client-pack-manifest.json

@@ -2,7 +2,7 @@
   "contract": "hellolynk-client-npm-pack-manifest-v1",
   "client": "workbuddy",
   "packageName": "@hellolynk-ai/workbuddy-mcp",
-  "version": "0.3.101",
+  "version": "0.3.103",
   "workbench": {
     "path": "runtime/workbench/hellolynk-workbench-build.json",
     "contract": "hellolynk-shared-workbench-build-v1",
@@ -27,8 +27,8 @@
     },
     {
       "path": "clients/core/hellolynk-client-core.mjs",
-      "bytes": 34320,
-      "sha256": "af7c9cb7a996fdb194c51dbcc745c48b616ff1686d79a1451104690d882df1b8"
+      "bytes": 36628,
+      "sha256": "5d2190c2354ede169b2053864674c7ae5b80985970dc13609d6818c5a6d16940"
     },
     {
       "path": "clients/core/hellolynk-client-profile.mjs",
@@ -217,8 +217,8 @@
     },
     {
       "path": "clients/core/hellolynk-neutral-host-assembly.mjs",
-      "bytes": 47797,
-      "sha256": "98b2b669183cda15272b182d5c04d3ae77511b8b657cd3179cbf2fa5d5f27920"
+      "bytes": 47470,
+      "sha256": "5a09b332a869c3863ac92c798a1a5df5901607987a2427a20b06154e41e17cb8"
     },
     {
       "path": "clients/core/hellolynk-neutral-host-installation-store.mjs",
@@ -232,8 +232,8 @@
     },
     {
       "path": "clients/core/hellolynk-neutral-host-process.mjs",
-      "bytes": 229535,
-      "sha256": "634279c96b8b4e83bcbcc92c5184f4ec7c31713a097f45af3f5650f8151fb78b"
+      "bytes": 234159,
+      "sha256": "0a66fca2b862fde9269722f026fc67e9d1c79435f0d410809aee669be9f9f497"
     },
     {
       "path": "clients/core/hellolynk-neutral-host-store-adapters.mjs",
@@ -247,8 +247,8 @@
     },
     {
       "path": "clients/core/hellolynk-platform-credential-store.mjs",
-      "bytes": 39386,
-      "sha256": "0ab136d36e890309b4cb5ff6f1cef6f3d82caf65f5b1d08c7b3992442ffe38a7"
+      "bytes": 40982,
+      "sha256": "4a4f073c3a5398d0d51be5a28c1b86b06e6f3b0b613e833928d8437c030cf65f"
     },
     {
       "path": "clients/core/hellolynk-relay-client-cli.mjs",
@@ -313,7 +313,7 @@
     {
       "path": "integrations/workbuddy/package.json",
       "bytes": 1156,
-      "sha256": "6840c8972c83975bbac2e995b89008f24b47b0557c6cdb394f652844a1ed7111"
+      "sha256": "ecccf7f9ddc65b046cf1516281b6cf33a1f2c5b53bf32a61a1ca1df3aa8e937a"
     },
     {
       "path": "integrations/workbuddy/server/host-lifecycle.mjs",
@@ -423,7 +423,7 @@
     {
       "path": "package.json",
       "bytes": 2019,
-      "sha256": "4b15cb8b2b4300e0ddb82037ff8d3b498da78c2b3525c41dda5f82d4028f71e7"
+      "sha256": "ff4be183cc660df51d5587c1902a9ae41a914ed27283137b3a7246c8a18193e6"
     },
     {
       "path": "README.md",
@@ -447,8 +447,8 @@
     },
     {
       "path": "runtime/core/hellolynk-client-core.mjs",
-      "bytes": 33550,
-      "sha256": "94bbad1d0ccee969bbffed176449e427188f1b892512a64167ab31f63d258e2b"
+      "bytes": 35808,
+      "sha256": "dbab0f067c1a7f02c43b2696e1f5972288acd4f93a18684bf3cc120edff5cf94"
     },
     {
       "path": "runtime/core/hellolynk-client-profile.mjs",
@@ -632,8 +632,8 @@
     },
     {
       "path": "runtime/core/hellolynk-neutral-host-assembly.mjs",
-      "bytes": 46842,
-      "sha256": "d0ac9c697bf8a85263d99a0739da557c62f52c72f4afb105eb97b3aac2ae1f3b"
+      "bytes": 46525,
+      "sha256": "b63c3371dfc08d8b15a4fd5ce84c61b40d9e7011424ccb3ff11466adb4f862cc"
     },
     {
       "path": "runtime/core/hellolynk-neutral-host-installation-store.mjs",
@@ -647,8 +647,8 @@
     },
     {
       "path": "runtime/core/hellolynk-neutral-host-process.mjs",
-      "bytes": 225161,
-      "sha256": "7b237a1400c604da5decbb29ab3ce556fd1b744d0cfd7d28b5560b217da120b1"
+      "bytes": 229709,
+      "sha256": "34b985f75bc693954eb66bb788fc2814482bb8bf402f14b72ea2faf5f70cf4ea"
     },
     {
       "path": "runtime/core/hellolynk-neutral-host-store-adapters.mjs",
@@ -662,8 +662,8 @@
     },
     {
       "path": "runtime/core/hellolynk-platform-credential-store.mjs",
-      "bytes": 38559,
-      "sha256": "3969708bafefc3b267bb34a9dcc115804c874ad14f4a036426d727c02ff70d42"
+      "bytes": 40123,
+      "sha256": "4b4b27cd86f4816e5e6ec4914816a335cdea5c4b4ffb2091775c061a9676a69c"
     },
     {
       "path": "runtime/core/hellolynk-relay-client-cli.mjs",
@@ -708,12 +708,12 @@
     {
       "path": "runtime/neutral-host-release-manifest.json",
       "bytes": 11517,
-      "sha256": "938801bbdc7516676014bf044b7e5e992a446777bbc74016b31d6e7a6560b36d"
+      "sha256": "4cefc24593d0de46133fc6d4d302979ecb9c85454af7a7c9d35e197e7b54ff86"
     },
     {
       "path": "runtime/neutral-host-release-pin.json",
       "bytes": 146,
-      "sha256": "85d3f3c173ad0daec8ab8f5b980612ef8db08afa3bff48ec41d5f146e5a3aee5"
+      "sha256": "4ee879b7cb941112afbc33f44c75fe309b51b7db257f63bc6a10aa0f759283c0"
     },
     {
       "path": "runtime/platform/windows/configure-agent.ps1",
@@ -893,12 +893,12 @@
     {
       "path": "workbuddy-package-manifest.json",
       "bytes": 22640,
-      "sha256": "7f0af3682b670fd4da7539690aaecf2beb5d076978de78c84d3b676c80d8147a"
+      "sha256": "cd6dc4893f52b99bf2012b2f0834ef41fb3f10ec0b483b3fa3deeb4fa1d59437"
     },
     {
       "path": "workbuddy-package-pin.json",
       "bytes": 143,
-      "sha256": "457d050c42a9425eea929d4cefb79ced77dfa2e9aae25ac9a9589265f8c1238d"
+      "sha256": "e562fabd2b124a20eaa83a914c4c7e751793451940ac390eccffb8e5889d2015"
     }
   ]
 }

package/hellolynk-client-pack-pin.json

@@ -1,4 +1,4 @@
 {
   "contract": "hellolynk-client-npm-pack-pin-v1",
-  "manifestSha256": "c48ed0d7b96819164fa687f1421a93d55e8725657853a505ee949f0e41b07f86"
+  "manifestSha256": "b159fccc127851ccd8068920b1bbcaf687e966f90d2f774a8a6cf04b5c966001"
 }

package/integrations/workbuddy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellolynk-ai/workbuddy-mcp",
-  "version": "0.3.101",
+  "version": "0.3.103",
   "private": true,
   "type": "module",
   "description": "WorkBuddy one-click bridge for local HelloLynk Messaging.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellolynk-ai/workbuddy-mcp",
-  "version": "0.3.101",
+  "version": "0.3.103",
   "description": "HelloLynk Messaging for WorkBuddy: open conversations and let your AI message other people's AI assistants.",
   "homepage": "https://hellolynk.com",
   "repository": {