@slock-ai/daemon 0.57.5 → 0.57.6

package/dist/cli/index.js

@@ -166,6 +166,8 @@ function routeFamilyForPath(pathname) {
   if (normalized === "/internal/agent-api/tasks" || normalized.startsWith("/internal/agent-api/tasks/")) {
     return "tasks";
   }
+  if (/^\/internal\/agent-api\/attachments\/[^/]+\/comments/.test(normalized)) return "agent-api/attachments/comments";
+  if (/^\/api\/attachments\/[^/]+\/comments/.test(normalized)) return "agent-api/attachments/comments";
   if (normalized.startsWith("/internal/agent-api/attachments/")) return "agent-api/attachments";
   if (normalized.startsWith("/api/attachments/")) return "attachments/download";
   if (/^\/internal\/agent-api\/messages\/[^/]+\/reactions$/.test(normalized)) return "agent-api/messages/reactions";
@@ -1046,6 +1048,12 @@ var DEVICE_CODE_OPTION = {
   flags: "--device-code <code>",
   description: "The device_code returned by `slock agent login start`"
 };
+function mergeParentLoginOpts(options, command) {
+  if (command && typeof command.optsWithGlobals === "function") {
+    return { ...command.optsWithGlobals(), ...options };
+  }
+  return options;
+}
 var agentLoginCommand = defineCommand(
   {
     name: "login",
@@ -1084,7 +1092,8 @@ var agentLoginStartCommand = defineCommand(
     description: "Begin device-code login and print the browser handoff, then exit (does not wait for approval).",
     options: [SERVER_OPTION, AGENT_OPTION, CLIENT_NAME_OPTION, PROFILE_SLUG_OPTION, PROFILE_DIR_OPTION]
   },
-  async (ctx, options) => {
+  async (ctx, rawOptions, command) => {
+    const options = mergeParentLoginOpts(rawOptions, command);
     validateServerAgent(options);
     const paths = resolveProfilePaths(options);
     let authorization;
@@ -1105,7 +1114,8 @@ var agentLoginWaitCommand = defineCommand(
     description: "Wait for the user to approve a `login start` request, then mint and save the credential.",
     options: [SERVER_OPTION, AGENT_OPTION, DEVICE_CODE_OPTION, PROFILE_SLUG_OPTION, PROFILE_DIR_OPTION]
   },
-  async (ctx, options) => {
+  async (ctx, rawOptions, command) => {
+    const options = mergeParentLoginOpts(rawOptions, command);
     validateServerAgent(options);
     if (!options.deviceCode?.trim()) {
       throw cliError("INVALID_ARG", "--device-code is required (the value printed by `slock agent login start`).");
@@ -1131,7 +1141,8 @@ var agentLoginStatusCommand = defineCommand(
     description: "Report whether the local profile credential is usable, expired, or needs re-login.",
     options: [SERVER_OPTION, AGENT_OPTION, PROFILE_SLUG_OPTION, PROFILE_DIR_OPTION]
   },
-  async (ctx, options) => {
+  async (ctx, rawOptions, command) => {
+    const options = mergeParentLoginOpts(rawOptions, command);
     validateServerAgent(options);
     const paths = resolveProfilePaths(options);
     if (!await profileFileExists(paths.credentialPath)) {
@@ -1264,7 +1275,8 @@ async function mintAndPersist(ctx, options, accessToken, paths) {
   ctx.io.stdout.write(
     `state: authorized
 Logged in as '${minted.agentName}' on ${options.server}. Credential saved to ${paths.credentialPath}.
-Next: run \`slock manual get slock-cli-overview\` to learn the Slock CLI, then use \`slock --profile ${paths.profileSlug} \u2026\` for all commands.
+Next (if you are the human operator): start your agent with SLOCK_PROFILE=${paths.profileSlug} in its environment, and let the agent run \`slock manual get slock-cli-overview\` to learn the Slock CLI.
+Next (if you are the agent): run \`slock manual get slock-cli-overview\`, then use \`slock --profile ${paths.profileSlug} \u2026\` for all commands.
 `
   );
 }
@@ -2337,10 +2349,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2723,11 +2735,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path8);
     return iss;
   });
 }
@@ -2909,8 +2921,8 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
   return fieldErrors;
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
-  const result = { errors: [] };
-  const processError = (error49, path7 = []) => {
+  const result2 = { errors: [] };
+  const processError = (error49, path8 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -2920,12 +2932,12 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
-          result.errors.push(mapper(issue2));
+          result2.errors.push(mapper(issue2));
           continue;
         }
-        let curr = result;
+        let curr = result2;
         let i = 0;
         while (i < fullpath.length) {
           const el = fullpath[i];
@@ -2948,12 +2960,12 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
     }
   };
   processError(error48);
-  return result;
+  return result2;
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path8) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -2982,52 +2994,52 @@ function prettifyError(error48) {
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/parse.js
 var _parse = (_Err) => (schema, value, _ctx, _params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
+  const result2 = schema._zod.run({ value, issues: [] }, ctx);
+  if (result2 instanceof Promise) {
     throw new $ZodAsyncError();
   }
-  if (result.issues.length) {
-    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+  if (result2.issues.length) {
+    const e = new (_params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
     captureStackTrace(e, _params?.callee);
     throw e;
   }
-  return result.value;
+  return result2.value;
 };
 var parse = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise)
-    result = await result;
-  if (result.issues.length) {
-    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+  let result2 = schema._zod.run({ value, issues: [] }, ctx);
+  if (result2 instanceof Promise)
+    result2 = await result2;
+  if (result2.issues.length) {
+    const e = new (params?.Err ?? _Err)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())));
     captureStackTrace(e, params?.callee);
     throw e;
   }
-  return result.value;
+  return result2.value;
 };
 var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
 var _safeParse = (_Err) => (schema, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
+  const result2 = schema._zod.run({ value, issues: [] }, ctx);
+  if (result2 instanceof Promise) {
     throw new $ZodAsyncError();
   }
-  return result.issues.length ? {
+  return result2.issues.length ? {
     success: false,
-    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result.value };
+    error: new (_Err ?? $ZodError)(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result2.value };
 };
 var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
 var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise)
-    result = await result;
-  return result.issues.length ? {
+  let result2 = schema._zod.run({ value, issues: [] }, ctx);
+  if (result2 instanceof Promise)
+    result2 = await result2;
+  return result2.issues.length ? {
     success: false,
-    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result.value };
+    error: new _Err(result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result2.value };
 };
 var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
 var _encode = (_Err) => (schema, value, _ctx) => {
@@ -3728,22 +3740,22 @@ var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst,
     });
   };
 });
-function handleCheckPropertyResult(result, payload, property) {
-  if (result.issues.length) {
-    payload.issues.push(...prefixIssues(property, result.issues));
+function handleCheckPropertyResult(result2, payload, property) {
+  if (result2.issues.length) {
+    payload.issues.push(...prefixIssues(property, result2.issues));
   }
 }
 var $ZodCheckProperty = /* @__PURE__ */ $constructor("$ZodCheckProperty", (inst, def) => {
   $ZodCheck.init(inst, def);
   inst._zod.check = (payload) => {
-    const result = def.schema._zod.run({
+    const result2 = def.schema._zod.run({
       value: payload.value[def.property],
       issues: []
     }, {});
-    if (result instanceof Promise) {
-      return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property));
+    if (result2 instanceof Promise) {
+      return result2.then((result3) => handleCheckPropertyResult(result3, payload, def.property));
     }
-    handleCheckPropertyResult(result, payload, def.property);
+    handleCheckPropertyResult(result2, payload, def.property);
     return;
   };
 });
@@ -3903,13 +3915,13 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
         }
         return handleCanaryResult(canary, payload, ctx);
       }
-      const result = inst._zod.parse(payload, ctx);
-      if (result instanceof Promise) {
+      const result2 = inst._zod.parse(payload, ctx);
+      if (result2 instanceof Promise) {
         if (ctx.async === false)
           throw new $ZodAsyncError();
-        return result.then((result2) => runChecks(result2, checks, ctx));
+        return result2.then((result3) => runChecks(result3, checks, ctx));
       }
-      return runChecks(result, checks, ctx);
+      return runChecks(result2, checks, ctx);
     };
   }
   defineLazy(inst, "~standard", () => ({
@@ -4418,11 +4430,11 @@ var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
     return payload;
   };
 });
-function handleArrayResult(result, final, index) {
-  if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+function handleArrayResult(result2, final, index) {
+  if (result2.issues.length) {
+    final.issues.push(...prefixIssues(index, result2.issues));
   }
-  final.value[index] = result.value;
+  final.value[index] = result2.value;
 }
 var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
@@ -4441,14 +4453,14 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     const proms = [];
     for (let i = 0; i < input.length; i++) {
       const item = input[i];
-      const result = def.element._zod.run({
+      const result2 = def.element._zod.run({
         value: item,
         issues: []
       }, ctx);
-      if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+      if (result2 instanceof Promise) {
+        proms.push(result2.then((result3) => handleArrayResult(result3, payload, i)));
       } else {
-        handleArrayResult(result, payload, i);
+        handleArrayResult(result2, payload, i);
       }
     }
     if (proms.length) {
@@ -4457,19 +4469,19 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key, input, isOptionalOut) {
-  if (result.issues.length) {
+function handlePropertyResult(result2, final, key, input, isOptionalOut) {
+  if (result2.issues.length) {
     if (isOptionalOut && !(key in input)) {
       return;
     }
-    final.issues.push(...prefixIssues(key, result.issues));
+    final.issues.push(...prefixIssues(key, result2.issues));
   }
-  if (result.value === void 0) {
+  if (result2.value === void 0) {
     if (key in input) {
       final.value[key] = void 0;
     }
   } else {
-    final.value[key] = result.value;
+    final.value[key] = result2.value;
   }
 }
 function normalizeDef(def) {
@@ -4685,9 +4697,9 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   };
 });
 function handleUnionResults(results, final, inst, ctx) {
-  for (const result of results) {
-    if (result.issues.length === 0) {
-      final.value = result.value;
+  for (const result2 of results) {
+    if (result2.issues.length === 0) {
+      final.value = result2.value;
       return final;
     }
   }
@@ -4700,7 +4712,7 @@ function handleUnionResults(results, final, inst, ctx) {
     code: "invalid_union",
     input: final.value,
     inst,
-    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
   });
   return final;
 }
@@ -4730,17 +4742,17 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
     let async = false;
     const results = [];
     for (const option of def.options) {
-      const result = option._zod.run({
+      const result2 = option._zod.run({
         value: payload.value,
         issues: []
       }, ctx);
-      if (result instanceof Promise) {
-        results.push(result);
+      if (result2 instanceof Promise) {
+        results.push(result2);
         async = true;
       } else {
-        if (result.issues.length === 0)
-          return result;
-        results.push(result);
+        if (result2.issues.length === 0)
+          return result2;
+        results.push(result2);
       }
     }
     if (!async)
@@ -4761,7 +4773,7 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
       code: "invalid_union",
       input: final.value,
       inst,
-      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+      errors: results.map((result2) => result2.issues.map((iss) => finalizeIssue(iss, ctx, config())))
     });
   } else {
     final.issues.push({
@@ -4786,15 +4798,15 @@ var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
     let async = false;
     const results = [];
     for (const option of def.options) {
-      const result = option._zod.run({
+      const result2 = option._zod.run({
         value: payload.value,
         issues: []
       }, ctx);
-      if (result instanceof Promise) {
-        results.push(result);
+      if (result2 instanceof Promise) {
+        results.push(result2);
         async = true;
       } else {
-        results.push(result);
+        results.push(result2);
       }
     }
     if (!async)
@@ -4929,7 +4941,7 @@ function mergeValues(a, b) {
   }
   return { valid: false, mergeErrorPath: [] };
 }
-function handleIntersectionResults(result, left, right) {
+function handleIntersectionResults(result2, left, right) {
   const unrecKeys = /* @__PURE__ */ new Map();
   let unrecIssue;
   for (const iss of left.issues) {
@@ -4941,7 +4953,7 @@ function handleIntersectionResults(result, left, right) {
         unrecKeys.get(k).l = true;
       }
     } else {
-      result.issues.push(iss);
+      result2.issues.push(iss);
     }
   }
   for (const iss of right.issues) {
@@ -4952,21 +4964,21 @@ function handleIntersectionResults(result, left, right) {
         unrecKeys.get(k).r = true;
       }
     } else {
-      result.issues.push(iss);
+      result2.issues.push(iss);
     }
   }
   const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
   if (bothKeys.length && unrecIssue) {
-    result.issues.push({ ...unrecIssue, keys: bothKeys });
+    result2.issues.push({ ...unrecIssue, keys: bothKeys });
   }
-  if (aborted(result))
-    return result;
+  if (aborted(result2))
+    return result2;
   const merged = mergeValues(left.value, right.value);
   if (!merged.valid) {
     throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
   }
-  result.value = merged.data;
-  return result;
+  result2.value = merged.data;
+  return result2;
 }
 var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
   $ZodType.init(inst, def);
@@ -5006,28 +5018,28 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
         if (i >= optStart)
           continue;
       }
-      const result = item._zod.run({
+      const result2 = item._zod.run({
         value: input[i],
         issues: []
       }, ctx);
-      if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+      if (result2 instanceof Promise) {
+        proms.push(result2.then((result3) => handleTupleResult(result3, payload, i)));
       } else {
-        handleTupleResult(result, payload, i);
+        handleTupleResult(result2, payload, i);
       }
     }
     if (def.rest) {
       const rest = input.slice(items.length);
       for (const el of rest) {
         i++;
-        const result = def.rest._zod.run({
+        const result2 = def.rest._zod.run({
           value: el,
           issues: []
         }, ctx);
-        if (result instanceof Promise) {
-          proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+        if (result2 instanceof Promise) {
+          proms.push(result2.then((result3) => handleTupleResult(result3, payload, i)));
         } else {
-          handleTupleResult(result, payload, i);
+          handleTupleResult(result2, payload, i);
         }
       }
     }
@@ -5036,11 +5048,11 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     return payload;
   };
 });
-function handleTupleResult(result, final, index) {
-  if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+function handleTupleResult(result2, final, index) {
+  if (result2.issues.length) {
+    final.issues.push(...prefixIssues(index, result2.issues));
   }
-  final.value[index] = result.value;
+  final.value[index] = result2.value;
 }
 var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
@@ -5063,19 +5075,19 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       for (const key of values) {
         if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
           recordKeys.add(typeof key === "number" ? key.toString() : key);
-          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
-          if (result instanceof Promise) {
-            proms.push(result.then((result2) => {
-              if (result2.issues.length) {
-                payload.issues.push(...prefixIssues(key, result2.issues));
+          const result2 = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result2 instanceof Promise) {
+            proms.push(result2.then((result3) => {
+              if (result3.issues.length) {
+                payload.issues.push(...prefixIssues(key, result3.issues));
               }
-              payload.value[key] = result2.value;
+              payload.value[key] = result3.value;
             }));
           } else {
-            if (result.issues.length) {
-              payload.issues.push(...prefixIssues(key, result.issues));
+            if (result2.issues.length) {
+              payload.issues.push(...prefixIssues(key, result2.issues));
             }
-            payload.value[key] = result.value;
+            payload.value[key] = result2.value;
           }
         }
       }
@@ -5128,19 +5140,19 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
           }
           continue;
         }
-        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
-        if (result instanceof Promise) {
-          proms.push(result.then((result2) => {
-            if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key, result2.issues));
+        const result2 = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        if (result2 instanceof Promise) {
+          proms.push(result2.then((result3) => {
+            if (result3.issues.length) {
+              payload.issues.push(...prefixIssues(key, result3.issues));
             }
-            payload.value[keyResult.value] = result2.value;
+            payload.value[keyResult.value] = result3.value;
           }));
         } else {
-          if (result.issues.length) {
-            payload.issues.push(...prefixIssues(key, result.issues));
+          if (result2.issues.length) {
+            payload.issues.push(...prefixIssues(key, result2.issues));
           }
-          payload.value[keyResult.value] = result.value;
+          payload.value[keyResult.value] = result2.value;
         }
       }
     }
@@ -5227,22 +5239,22 @@ var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
     const proms = [];
     payload.value = /* @__PURE__ */ new Set();
     for (const item of input) {
-      const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
-      if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleSetResult(result2, payload)));
+      const result2 = def.valueType._zod.run({ value: item, issues: [] }, ctx);
+      if (result2 instanceof Promise) {
+        proms.push(result2.then((result3) => handleSetResult(result3, payload)));
       } else
-        handleSetResult(result, payload);
+        handleSetResult(result2, payload);
     }
     if (proms.length)
       return Promise.all(proms).then(() => payload);
     return payload;
   };
 });
-function handleSetResult(result, final) {
-  if (result.issues.length) {
-    final.issues.push(...result.issues);
+function handleSetResult(result2, final) {
+  if (result2.issues.length) {
+    final.issues.push(...result2.issues);
   }
-  final.value.add(result.value);
+  final.value.add(result2.value);
 }
 var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   $ZodType.init(inst, def);
@@ -5322,11 +5334,11 @@ var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) =>
     return payload;
   };
 });
-function handleOptionalResult(result, input) {
-  if (result.issues.length && input === void 0) {
+function handleOptionalResult(result2, input) {
+  if (result2.issues.length && input === void 0) {
     return { issues: [], value: void 0 };
   }
-  return result;
+  return result2;
 }
 var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
   $ZodType.init(inst, def);
@@ -5341,10 +5353,10 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
   });
   inst._zod.parse = (payload, ctx) => {
     if (def.innerType._zod.optin === "optional") {
-      const result = def.innerType._zod.run(payload, ctx);
-      if (result instanceof Promise)
-        return result.then((r) => handleOptionalResult(r, payload.value));
-      return handleOptionalResult(result, payload.value);
+      const result2 = def.innerType._zod.run(payload, ctx);
+      if (result2 instanceof Promise)
+        return result2.then((r) => handleOptionalResult(r, payload.value));
+      return handleOptionalResult(result2, payload.value);
     }
     if (payload.value === void 0) {
       return payload;
@@ -5389,11 +5401,11 @@ var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
       payload.value = def.defaultValue;
       return payload;
     }
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => handleDefaultResult(result2, def));
+    const result2 = def.innerType._zod.run(payload, ctx);
+    if (result2 instanceof Promise) {
+      return result2.then((result3) => handleDefaultResult(result3, def));
     }
-    return handleDefaultResult(result, def);
+    return handleDefaultResult(result2, def);
   };
 });
 function handleDefaultResult(payload, def) {
@@ -5423,11 +5435,11 @@ var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def
     return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
   });
   inst._zod.parse = (payload, ctx) => {
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => handleNonOptionalResult(result2, inst));
+    const result2 = def.innerType._zod.run(payload, ctx);
+    if (result2 instanceof Promise) {
+      return result2.then((result3) => handleNonOptionalResult(result3, inst));
     }
-    return handleNonOptionalResult(result, inst);
+    return handleNonOptionalResult(result2, inst);
   };
 });
 function handleNonOptionalResult(payload, inst) {
@@ -5447,14 +5459,14 @@ var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
     if (ctx.direction === "backward") {
       throw new $ZodEncodeError("ZodSuccess");
     }
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => {
-        payload.value = result2.issues.length === 0;
+    const result2 = def.innerType._zod.run(payload, ctx);
+    if (result2 instanceof Promise) {
+      return result2.then((result3) => {
+        payload.value = result3.issues.length === 0;
         return payload;
       });
     }
-    payload.value = result.issues.length === 0;
+    payload.value = result2.issues.length === 0;
     return payload;
   };
 });
@@ -5467,15 +5479,15 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
     if (ctx.direction === "backward") {
       return def.innerType._zod.run(payload, ctx);
     }
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => {
-        payload.value = result2.value;
-        if (result2.issues.length) {
+    const result2 = def.innerType._zod.run(payload, ctx);
+    if (result2 instanceof Promise) {
+      return result2.then((result3) => {
+        payload.value = result3.value;
+        if (result3.issues.length) {
           payload.value = def.catchValue({
             ...payload,
             error: {
-              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+              issues: result3.issues.map((iss) => finalizeIssue(iss, ctx, config()))
             },
             input: payload.value
           });
@@ -5484,12 +5496,12 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
         return payload;
       });
     }
-    payload.value = result.value;
-    if (result.issues.length) {
+    payload.value = result2.value;
+    if (result2.issues.length) {
       payload.value = def.catchValue({
         ...payload,
         error: {
-          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+          issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
         },
         input: payload.value
       });
@@ -5564,24 +5576,24 @@ var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
     }
   };
 });
-function handleCodecAResult(result, def, ctx) {
-  if (result.issues.length) {
-    result.aborted = true;
-    return result;
+function handleCodecAResult(result2, def, ctx) {
+  if (result2.issues.length) {
+    result2.aborted = true;
+    return result2;
   }
   const direction = ctx.direction || "forward";
   if (direction === "forward") {
-    const transformed = def.transform(result.value, result);
+    const transformed = def.transform(result2.value, result2);
     if (transformed instanceof Promise) {
-      return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
+      return transformed.then((value) => handleCodecTxResult(result2, value, def.out, ctx));
     }
-    return handleCodecTxResult(result, transformed, def.out, ctx);
+    return handleCodecTxResult(result2, transformed, def.out, ctx);
   } else {
-    const transformed = def.reverseTransform(result.value, result);
+    const transformed = def.reverseTransform(result2.value, result2);
     if (transformed instanceof Promise) {
-      return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
+      return transformed.then((value) => handleCodecTxResult(result2, value, def.in, ctx));
     }
-    return handleCodecTxResult(result, transformed, def.in, ctx);
+    return handleCodecTxResult(result2, transformed, def.in, ctx);
   }
 }
 function handleCodecTxResult(left, value, nextSchema, ctx) {
@@ -5601,11 +5613,11 @@ var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
     if (ctx.direction === "backward") {
       return def.innerType._zod.run(payload, ctx);
     }
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then(handleReadonlyResult);
+    const result2 = def.innerType._zod.run(payload, ctx);
+    if (result2 instanceof Promise) {
+      return result2.then(handleReadonlyResult);
     }
-    return handleReadonlyResult(result);
+    return handleReadonlyResult(result2);
   };
 });
 function handleReadonlyResult(payload) {
@@ -5667,11 +5679,11 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
     }
     return function(...args) {
       const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
-      const result = Reflect.apply(func, this, parsedArgs);
+      const result2 = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return parse(inst._def.output, result);
+        return parse(inst._def.output, result2);
       }
-      return result;
+      return result2;
     };
   };
   inst.implementAsync = (func) => {
@@ -5680,11 +5692,11 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
     }
     return async function(...args) {
       const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
-      const result = await Reflect.apply(func, this, parsedArgs);
+      const result2 = await Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return await parseAsync(inst._def.output, result);
+        return await parseAsync(inst._def.output, result2);
       }
-      return result;
+      return result2;
     };
   };
   inst._zod.parse = (payload, _ctx) => {
@@ -5768,8 +5780,8 @@ var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
     return;
   };
 });
-function handleRefineResult(result, payload, input, inst) {
-  if (!result) {
+function handleRefineResult(result2, payload, input, inst) {
+  if (!result2) {
     const _iss = {
       code: "custom",
       input,
@@ -8887,12 +8899,12 @@ var error26 = () => {
     }
   };
   function getSizing(origin, unitType, inclusive, targetShouldBe) {
-    const result = Sizable[origin] ?? null;
-    if (result === null)
-      return result;
+    const result2 = Sizable[origin] ?? null;
+    if (result2 === null)
+      return result2;
     return {
-      unit: result.unit[unitType],
-      verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
+      unit: result2.unit[unitType],
+      verb: result2.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
     };
   }
   const FormatDictionary = {
@@ -12486,11 +12498,11 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     }
     return seen.schema;
   }
-  const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-  ctx.seen.set(schema, result);
+  const result2 = { schema: {}, count: 1, cycle: void 0, path: _params.path };
+  ctx.seen.set(schema, result2);
   const overrideSchema = schema._zod.toJSONSchema?.();
   if (overrideSchema) {
-    result.schema = overrideSchema;
+    result2.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
@@ -12498,9 +12510,9 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
       path: _params.path
     };
     if (schema._zod.processJSONSchema) {
-      schema._zod.processJSONSchema(ctx, result.schema, params);
+      schema._zod.processJSONSchema(ctx, result2.schema, params);
     } else {
-      const _json = result.schema;
+      const _json = result2.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
@@ -12509,22 +12521,22 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     }
     const parent = schema._zod.parent;
     if (parent) {
-      if (!result.ref)
-        result.ref = parent;
+      if (!result2.ref)
+        result2.ref = parent;
       process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
   const meta3 = ctx.metadataRegistry.get(schema);
   if (meta3)
-    Object.assign(result.schema, meta3);
+    Object.assign(result2.schema, meta3);
   if (ctx.io === "input" && isTransforming(schema)) {
-    delete result.schema.examples;
-    delete result.schema.default;
+    delete result2.schema.examples;
+    delete result2.schema.default;
   }
-  if (ctx.io === "input" && result.schema._prefault)
-    (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
-  delete result.schema._prefault;
+  if (ctx.io === "input" && result2.schema._prefault)
+    (_a2 = result2.schema).default ?? (_a2.default = result2.schema._prefault);
+  delete result2.schema._prefault;
   const _result = ctx.seen.get(schema);
   return _result.schema;
 }
@@ -12687,13 +12699,13 @@ function finalize(ctx, schema) {
   for (const entry of [...ctx.seen.entries()].reverse()) {
     flattenRef(entry[0]);
   }
-  const result = {};
+  const result2 = {};
   if (ctx.target === "draft-2020-12") {
-    result.$schema = "https://json-schema.org/draft/2020-12/schema";
+    result2.$schema = "https://json-schema.org/draft/2020-12/schema";
   } else if (ctx.target === "draft-07") {
-    result.$schema = "http://json-schema.org/draft-07/schema#";
+    result2.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
-    result.$schema = "http://json-schema.org/draft-04/schema#";
+    result2.$schema = "http://json-schema.org/draft-04/schema#";
   } else if (ctx.target === "openapi-3.0") {
   } else {
   }
@@ -12701,9 +12713,9 @@ function finalize(ctx, schema) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
-    result.$id = ctx.external.uri(id);
+    result2.$id = ctx.external.uri(id);
   }
-  Object.assign(result, root.def ?? root.schema);
+  Object.assign(result2, root.def ?? root.schema);
   const defs = ctx.external?.defs ?? {};
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
@@ -12715,14 +12727,14 @@ function finalize(ctx, schema) {
   } else {
     if (Object.keys(defs).length > 0) {
       if (ctx.target === "draft-2020-12") {
-        result.$defs = defs;
+        result2.$defs = defs;
       } else {
-        result.definitions = defs;
+        result2.definitions = defs;
       }
     }
   }
   try {
-    const finalized = JSON.parse(JSON.stringify(result));
+    const finalized = JSON.parse(JSON.stringify(result2));
     Object.defineProperty(finalized, "~standard", {
       value: {
         ...schema["~standard"],
@@ -13424,8 +13436,8 @@ var JSONSchemaGenerator = class {
         this.ctx.external = _params.external;
     }
     extractDefs(this.ctx, schema);
-    const result = finalize(this.ctx, schema);
-    const { "~standard": _, ...plainResult } = result;
+    const result2 = finalize(this.ctx, schema);
+    const { "~standard": _, ...plainResult } = result2;
     return plainResult;
   }
 };
@@ -14930,13 +14942,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path8 = ref.slice(1).split("/").filter(Boolean);
+  if (path8.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path8[0] === defsKey) {
+    const key = path8[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15161,11 +15173,11 @@ function convertBaseSchema(schema, ctx) {
         } else if (schemasToIntersect.length === 1) {
           zodSchema = schemasToIntersect[0];
         } else {
-          let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result2 = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z.intersection(result, schemasToIntersect[i]);
+            result2 = z.intersection(result2, schemasToIntersect[i]);
           }
-          zodSchema = result;
+          zodSchema = result2;
         }
         break;
       }
@@ -15256,12 +15268,12 @@ function convertSchema(schema, ctx) {
     if (schema.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      let result2 = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result2 = z.intersection(result2, convertSchema(schema.allOf[i], ctx));
       }
-      baseSchema = result;
+      baseSchema = result2;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
@@ -15815,6 +15827,14 @@ var DISPLAY_PLAN_CONFIG = {
 // src/agentCommsCore/bridge.ts
 var AGENT_COMMS_PROTOCOL_VERSION = "agent-comms-core.v1";
 var AGENT_PROOF_SCHEMA_VERSION = "agent-proof.v1";
+var AgentCommsBridgeLockError = class extends Error {
+  constructor(lockPath, owner) {
+    super("slock agent bridge is already running for this profile/agent/adapter state.");
+    this.lockPath = lockPath;
+    this.owner = owner;
+  }
+  code = "BRIDGE_ALREADY_RUNNING";
+};
 function resolveAgentCommsBridgeStateDir(input) {
   if (input.stateDir) return input.stateDir;
   const env = input.env ?? process.env;
@@ -15834,7 +15854,9 @@ function createFileAgentCommsBridgeStore(input) {
     rootDir,
     sessionFile: path4.join(rootDir, "session.json"),
     wakeHintsFile: path4.join(rootDir, "wake-hints.jsonl"),
-    proofFile: path4.join(rootDir, "proofs.jsonl")
+    proofFile: path4.join(rootDir, "proofs.jsonl"),
+    lockFile: path4.join(rootDir, "bridge.lock"),
+    logFile: path4.join(rootDir, "bridge.log")
   };
   fs2.mkdirSync(rootDir, { recursive: true, mode: 448 });
   return {
@@ -15867,9 +15889,40 @@ function createFileAgentCommsBridgeStore(input) {
     },
     appendProof(proof2) {
       appendJsonl(paths.proofFile, proof2);
+    },
+    appendLog(event) {
+      try {
+        rotateBridgeLogIfNeeded(paths.logFile);
+        appendJsonl(paths.logFile, { ts: (/* @__PURE__ */ new Date()).toISOString(), ...event });
+      } catch {
+      }
+    },
+    removeWakeHint(hint) {
+      const key = wakeHintKey(hint);
+      const pending = readJsonl(paths.wakeHintsFile);
+      const remaining = pending.filter((candidate) => wakeHintKey(candidate) !== key);
+      if (remaining.length === pending.length) return;
+      fs2.writeFileSync(
+        paths.wakeHintsFile,
+        remaining.map((entry) => JSON.stringify(entry)).join("\n") + (remaining.length > 0 ? "\n" : ""),
+        { mode: 384 }
+      );
     }
   };
 }
+function acquireAgentCommsBridgeLock(input) {
+  const store = createFileAgentCommsBridgeStore(input);
+  const ownerId = input.ownerId ?? `owner_${randomUUID()}`;
+  const owner = {
+    ownerId,
+    pid: process.pid,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    profileSlug: requireProfileSlug(input.agentContext),
+    agentId: input.agentContext.agentId,
+    adapterInstance: input.adapterInstance ?? "default"
+  };
+  return acquireLockFile(store.paths.lockFile, ownerId, owner, false);
+}
 async function runAgentCommsBridgeOnce(input) {
   if (input.agentContext.clientMode !== "self-hosted-runner") {
     throw new Error("slock agent bridge requires a self-hosted profile credential; run with `slock --profile <slug> agent bridge`.");
@@ -15909,7 +15962,8 @@ async function runAgentCommsBridgeOnce(input) {
           runtimeSession: input.runtimeSession ?? null,
           now,
           output,
-          store
+          store,
+          recentInjections: input.recentInjections
         });
       }
     }
@@ -15917,7 +15971,12 @@ async function runAgentCommsBridgeOnce(input) {
   const since = existingSession?.lastSeenHintSeq ?? "latest";
   const fetched = await input.source.fetchWakeHints({ since, limit: input.limit ?? 50 });
   let lastSeenHintSeq = existingSession?.lastSeenHintSeq;
+  let processedHintCount = 0;
   for (const hint of fetched.hints) {
+    const seq = wakeHintSeq(hint);
+    if (typeof seq === "number" && typeof lastSeenHintSeq === "number" && seq <= lastSeenHintSeq) {
+      continue;
+    }
     const attemptId = `attempt_${randomUUID()}`;
     const serverDelivered = proof(identity, hint, attemptId, "server_delivered", now);
     store.appendProof(serverDelivered);
@@ -15935,10 +15994,11 @@ async function runAgentCommsBridgeOnce(input) {
       runtimeSession: input.runtimeSession ?? null,
       now,
       output,
-      store
+      store,
+      recentInjections: input.recentInjections
     });
-    const seq = wakeHintSeq(hint);
     if (typeof seq === "number") lastSeenHintSeq = Math.max(lastSeenHintSeq ?? 0, seq);
+    processedHintCount += 1;
   }
   const fetchedLastSeq = typeof fetched.last_seen_hint_seq === "number" ? fetched.last_seen_hint_seq : typeof fetched.last_hint_seq === "number" ? fetched.last_hint_seq : void 0;
   if (typeof fetchedLastSeq === "number") lastSeenHintSeq = Math.max(lastSeenHintSeq ?? 0, fetchedLastSeq);
@@ -15946,9 +16006,76 @@ async function runAgentCommsBridgeOnce(input) {
     coreSessionId,
     ...typeof lastSeenHintSeq === "number" ? { lastSeenHintSeq } : {}
   });
-  output.push(lifecycle(identity, fetched.hints.length > 0 ? "handoff_pending" : "listening_idle", now));
+  output.push(lifecycle(identity, processedHintCount > 0 ? "handoff_pending" : "listening_idle", now));
   return output;
 }
+var BRIDGE_LOG_MAX_BYTES = 5 * 1024 * 1024;
+function rotateBridgeLogIfNeeded(logFile) {
+  try {
+    const stat2 = fs2.statSync(logFile);
+    if (stat2.size < BRIDGE_LOG_MAX_BYTES) return;
+    fs2.renameSync(logFile, `${logFile}.1`);
+  } catch {
+  }
+}
+async function runAgentCommsBridgeReconcile(input) {
+  const profileSlug = requireProfileSlug(input.agentContext);
+  const adapterInstance = input.adapterInstance ?? "default";
+  const store = createFileAgentCommsBridgeStore({
+    agentContext: input.agentContext,
+    env: input.env,
+    stateDir: input.stateDir,
+    adapterInstance
+  });
+  const existingSession = store.readSession();
+  const sessionBefore = existingSession ? { ...existingSession } : null;
+  const identity = {
+    agentId: input.agentContext.agentId,
+    profileSlug,
+    adapterInstance,
+    coreSessionId: input.coreSessionId ?? existingSession?.coreSessionId ?? `core_${randomUUID()}`
+  };
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const events = [];
+  const graceMs = input.graceMs ?? 3e4;
+  const recent = input.recentInjections;
+  const fetched = await input.source.fetchWakeHints({ since: 0, limit: input.limit ?? 50 });
+  let reinjected = 0;
+  let skippedRecent = 0;
+  for (const hint of fetched.hints) {
+    const key = wakeHintKey(hint);
+    const injectedAt = recent?.get(key);
+    if (typeof injectedAt === "number" && now().getTime() - injectedAt < graceMs) {
+      skippedRecent += 1;
+      continue;
+    }
+    const attemptId = `attempt_${randomUUID()}`;
+    store.appendWakeHintIfAbsent(hint);
+    events.push(handoff(identity, hint, attemptId, true, now));
+    await maybeRunWakeAdapter({
+      identity,
+      hint,
+      attemptId,
+      wakeAdapter: input.wakeAdapter,
+      runtimeSession: input.runtimeSession ?? null,
+      now,
+      output: events,
+      store,
+      recentInjections: recent
+    });
+    reinjected += 1;
+  }
+  const sessionAfter = store.readSession();
+  if (JSON.stringify(sessionAfter) !== JSON.stringify(sessionBefore)) {
+    throw new Error("bridge reconcile must not modify session state (cursor-orthogonality)");
+  }
+  return {
+    pendingCount: fetched.hints.length,
+    reinjectedCount: reinjected,
+    skippedRecentCount: skippedRecent,
+    events
+  };
+}
 async function maybeRunWakeAdapter(input) {
   if (!input.wakeAdapter) return;
   const wakeInput = wakeAttemptInput({
@@ -15961,6 +16088,18 @@ async function maybeRunWakeAdapter(input) {
   const event = await wakeAdapterEvent(input.wakeAdapter, wakeInput);
   input.store.appendProof(event);
   input.output.push(event);
+  if (event.proofLevel === "wake_injected") {
+    input.store.removeWakeHint(input.hint);
+    if (input.recentInjections) {
+      input.recentInjections.set(wakeHintKey(input.hint), input.now().getTime());
+      if (input.recentInjections.size > 1e3) {
+        const cutoff = input.now().getTime() - 6e5;
+        for (const [key, ts] of input.recentInjections) {
+          if (ts < cutoff) input.recentInjections.delete(key);
+        }
+      }
+    }
+  }
 }
 function wakeAttemptInput(input) {
   return {
@@ -16099,6 +16238,58 @@ function appendJsonl(filePath, value) {
   fs2.appendFileSync(filePath, `${JSON.stringify(value)}
 `, { mode: 384 });
 }
+function acquireLockFile(lockPath, ownerId, owner, retried) {
+  fs2.mkdirSync(path4.dirname(lockPath), { recursive: true, mode: 448 });
+  try {
+    const fd = fs2.openSync(lockPath, "wx", 384);
+    fs2.writeFileSync(fd, `${JSON.stringify(owner, null, 2)}
+`);
+    fs2.closeSync(fd);
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    const existing = readLockOwner(lockPath);
+    if (!retried && isStaleLockOwner(existing)) {
+      try {
+        fs2.unlinkSync(lockPath);
+      } catch {
+      }
+      return acquireLockFile(lockPath, ownerId, owner, true);
+    }
+    throw new AgentCommsBridgeLockError(lockPath, existing);
+  }
+  let released = false;
+  return {
+    path: lockPath,
+    ownerId,
+    release() {
+      if (released) return;
+      released = true;
+      const existing = readLockOwner(lockPath);
+      if (existing?.ownerId === ownerId) {
+        fs2.unlinkSync(lockPath);
+      }
+    }
+  };
+}
+function readLockOwner(lockPath) {
+  try {
+    return JSON.parse(fs2.readFileSync(lockPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isStaleLockOwner(owner) {
+  if (!owner || typeof owner !== "object") return false;
+  const pid = owner.pid;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (err) {
+    const code = err.code;
+    return code === "ESRCH";
+  }
+}
 function requireProfileSlug(agentContext) {
   if (!agentContext.profileSlug) {
     throw new Error("slock agent bridge requires SLOCK_PROFILE / --profile so state is profile-scoped.");
@@ -16300,10 +16491,13 @@ var agentBridgeCommand = defineCommand(
       { flags: "--state-dir <path>", description: "Override bridge state directory for tests/debugging." },
       { flags: "--adapter-instance <id>", description: "Wake adapter instance id for per-agent state partitioning." },
       { flags: "--limit <n>", description: "Maximum events to pull per iteration." },
-      { flags: "--wake-adapter <kind>", description: "Enable a wake adapter. Supported: claude-code-channels." },
-      { flags: "--claude-channel-endpoint <url>", description: "Localhost wake endpoint exposed by the Slock Claude Code channel plugin." },
-      { flags: "--claude-channel-token <token>", description: "Optional shared token for the Claude Code channel plugin wake endpoint." },
-      { flags: "--runtime-session <id>", description: "Optional runtime session id when the adapter endpoint does not return one." }
+      { flags: "--wake-adapter <kind>", description: "Enable a wake adapter. Supported: wake-endpoint (runtime-neutral; claude-code-channels is a compatible alias)." },
+      { flags: "--wake-endpoint <url>", description: "Localhost wake endpoint exposed by the runtime's Slock channel plugin (see docs/wake-endpoint-contract.md in raft-external-agents)." },
+      { flags: "--wake-endpoint-token <token>", description: "Optional shared token for the runtime wake endpoint (env: SLOCK_WAKE_ENDPOINT_TOKEN)." },
+      { flags: "--claude-channel-endpoint <url>", description: "Compatible alias of --wake-endpoint (historical Claude Code naming)." },
+      { flags: "--claude-channel-token <token>", description: "Compatible alias of --wake-endpoint-token (historical Claude Code naming)." },
+      { flags: "--runtime-session <id>", description: "Optional runtime session id when the adapter endpoint does not return one." },
+      { flags: "--reconcile-interval-ms <ms>", description: "Re-peek the full server-pending set every <ms> and re-wake hints that were injected but never consumed (0 disables; default 120000)." }
     ]
   },
   async (ctx, options) => {
@@ -16316,33 +16510,147 @@ var agentBridgeCommand = defineCommand(
       });
     }
     const pollIntervalMs = parsePositiveInt(options.pollIntervalMs, 5e3, "poll-interval-ms");
+    const reconcileIntervalMs = options.reconcileIntervalMs === "0" ? 0 : parsePositiveInt(options.reconcileIntervalMs, 12e4, "reconcile-interval-ms");
     const limit = parsePositiveInt(options.limit, 50, "limit");
-    const source = createAgentApiWakeHintSource(ctx.createApiClient(agentContext));
-    const wakeAdapter = createWakeAdapter(options);
+    const client = ctx.createApiClient(agentContext);
+    const pollSource = createAgentApiWakeHintSource(client);
+    const streamSource = options.once ? null : createAgentApiWakeHintStreamSource(client, ctx.env);
+    const wakeAdapter = createWakeAdapter(options, ctx.env);
+    let bridgeLock;
+    try {
+      bridgeLock = acquireAgentCommsBridgeLock({
+        agentContext,
+        env: ctx.env,
+        stateDir: options.stateDir,
+        adapterInstance: options.adapterInstance
+      });
+    } catch (err) {
+      if (err instanceof AgentCommsBridgeLockError) {
+        throw new CliError({
+          code: err.code,
+          message: "slock agent bridge is already running for this profile/agent/adapter state.",
+          suggestedNextAction: `Stop the existing bridge or use a different --adapter-instance. Lock: ${err.lockPath}`
+        });
+      }
+      throw err;
+    }
+    const logStore = createFileAgentCommsBridgeStore({
+      agentContext,
+      env: ctx.env,
+      stateDir: options.stateDir,
+      adapterInstance: options.adapterInstance
+    });
     const emit = (value) => {
+      logStore.appendLog(value);
       if (options.json) {
         writeText(ctx.io, `${JSON.stringify(value)}
 `);
       }
     };
-    let replayPending = true;
-    do {
-      const events = await runAgentCommsBridgeOnce({
-        agentContext,
-        source,
-        env: ctx.env,
-        stateDir: options.stateDir,
-        adapterInstance: options.adapterInstance,
-        limit,
-        replayPending,
-        wakeAdapter,
-        runtimeSession: options.runtimeSession ?? null
-      });
-      for (const event of events) emit(event);
-      replayPending = false;
-      if (options.once) break;
-      await sleep(pollIntervalMs);
-    } while (true);
+    try {
+      let replayPending = true;
+      let consecutiveFailures = 0;
+      let mode = streamSource ? "stream" : "poll";
+      let pollFallbackOnce = false;
+      const recentInjections = /* @__PURE__ */ new Map();
+      const reconcileGraceMs = Math.min(3e4, Math.max(1, Math.floor(reconcileIntervalMs / 2)) || 3e4);
+      let lastReconcileAt = Date.now();
+      emit({ type: "bridge_process_started", pid: process.pid, mode, pollIntervalMs, reconcileIntervalMs });
+      do {
+        const source = mode === "stream" && streamSource ? streamSource : pollSource;
+        try {
+          const events = await runAgentCommsBridgeOnce({
+            agentContext,
+            source,
+            env: ctx.env,
+            stateDir: options.stateDir,
+            adapterInstance: options.adapterInstance,
+            limit,
+            replayPending,
+            wakeAdapter,
+            runtimeSession: options.runtimeSession ?? null,
+            recentInjections
+          });
+          for (const event of events) emit(event);
+          if (consecutiveFailures > 0) {
+            emit({ type: "bridge_recovered", afterFailures: consecutiveFailures });
+            ctx.io.stderr.write(`bridge: recovered after ${consecutiveFailures} transient failure(s); bridge resumed.
+`);
+            consecutiveFailures = 0;
+          }
+          replayPending = false;
+        } catch (err) {
+          if (options.once || classifyBridgeLoopError(err) === "fatal") {
+            if (!(mode === "stream" && isWakeStreamUnavailable(err))) {
+              const errorCode3 = err instanceof CliError ? err.code : err?.name ?? "Error";
+              emit({ type: "bridge_fatal", errorCode: errorCode3, message: (err?.message ?? String(err)).slice(0, 200) });
+            }
+            if (mode === "stream" && isWakeStreamUnavailable(err)) {
+              mode = "poll";
+              emit({ type: "bridge_stream_unavailable", fallback: "poll", message: err.message });
+              ctx.io.stderr.write(`bridge: wake-hint stream unavailable; falling back to polling.
+`);
+              continue;
+            }
+            throw err;
+          }
+          replayPending = false;
+          consecutiveFailures += 1;
+          const delayMs = bridgeRetryDelayMs(consecutiveFailures, pollIntervalMs);
+          const errorCode2 = err instanceof CliError ? err.code : err?.name ?? "Error";
+          const message = (err?.message ?? String(err)).slice(0, 200);
+          emit({ type: "bridge_retry", consecutiveFailures, delayMs, errorCode: errorCode2, message });
+          ctx.io.stderr.write(
+            `bridge: transient failure (${errorCode2}: ${message}); retry #${consecutiveFailures} in ${Math.round(delayMs / 1e3)}s. Pending wakes are not lost; \`slock message check\` still works directly.
+`
+          );
+          await sleep(delayMs);
+          if (mode === "stream") {
+            pollFallbackOnce = true;
+            mode = "poll";
+          }
+          continue;
+        }
+        if (options.once) break;
+        if (reconcileIntervalMs > 0 && Date.now() - lastReconcileAt >= reconcileIntervalMs) {
+          lastReconcileAt = Date.now();
+          try {
+            const reconcile = await runAgentCommsBridgeReconcile({
+              agentContext,
+              source: pollSource,
+              env: ctx.env,
+              stateDir: options.stateDir,
+              adapterInstance: options.adapterInstance,
+              limit,
+              wakeAdapter,
+              runtimeSession: options.runtimeSession ?? null,
+              recentInjections,
+              graceMs: reconcileGraceMs
+            });
+            for (const event of reconcile.events) emit(event);
+            emit({
+              type: "reconcile_peek",
+              pendingCount: reconcile.pendingCount,
+              reinjectedCount: reconcile.reinjectedCount,
+              skippedRecentCount: reconcile.skippedRecentCount
+            });
+          } catch (err) {
+            const message = (err?.message ?? String(err)).slice(0, 200);
+            emit({ type: "reconcile_failed", message });
+          }
+        }
+        if (mode === "stream") continue;
+        if (pollFallbackOnce && streamSource) {
+          pollFallbackOnce = false;
+          mode = "stream";
+          continue;
+        }
+        await sleep(pollIntervalMs);
+      } while (true);
+    } finally {
+      await streamSource?.close();
+      bridgeLock.release();
+    }
   }
 );
 function registerAgentBridgeCommand(parent, runtimeOptions) {
@@ -16370,6 +16678,155 @@ function createAgentApiWakeHintSource(client) {
     }
   };
 }
+function createAgentApiWakeHintStreamSource(client, env = process.env) {
+  if (!client.requestRaw) return null;
+  let reader = null;
+  let bufferedText = "";
+  let pendingEvent = {};
+  const idleTimeoutMs = parseWakeStreamIdleTimeoutMs(env);
+  async function close() {
+    const current = reader;
+    reader = null;
+    bufferedText = "";
+    pendingEvent = {};
+    if (current) await current.cancel().catch(() => void 0);
+  }
+  async function ensureReader(since) {
+    if (reader) return reader;
+    const query = new URLSearchParams({ since: String(since) });
+    const response = await client.requestRaw("GET", `/internal/agent-api/wake-hints/stream?${query.toString()}`);
+    if (!response.ok) {
+      throw new CliError({
+        code: response.status === 404 || response.status === 405 || response.status === 501 ? "BRIDGE_WAKE_STREAM_UNAVAILABLE" : response.status >= 500 ? "SERVER_5XX" : "BRIDGE_WAKE_STREAM_FAILED",
+        message: response.error ?? `HTTP ${response.status}`
+      });
+    }
+    if (!response.response.body) {
+      throw new TypeError("wake-hint stream response has no body");
+    }
+    reader = response.response.body.getReader();
+    return reader;
+  }
+  async function nextEvent(since) {
+    const decoder = new TextDecoder();
+    while (true) {
+      try {
+        const buffered = drainSseEvents();
+        if (buffered) return buffered;
+      } catch (err) {
+        await close();
+        const message = err instanceof Error ? err.message : String(err);
+        throw new TypeError(`wake-hint stream parse failed: ${message}`);
+      }
+      const current = await ensureReader(since);
+      let chunk;
+      try {
+        chunk = await readWithIdleWatchdog(current, idleTimeoutMs);
+      } catch (err) {
+        await close();
+        throw err;
+      }
+      const { done, value } = chunk;
+      if (done) {
+        await close();
+        throw new TypeError("wake-hint stream ended");
+      }
+      bufferedText += decoder.decode(value, { stream: true });
+      let result2;
+      try {
+        result2 = drainSseEvents();
+      } catch (err) {
+        await close();
+        const message = err instanceof Error ? err.message : String(err);
+        throw new TypeError(`wake-hint stream parse failed: ${message}`);
+      }
+      if (result2) return result2;
+      return { hints: [], last_seen_hint_seq: null, has_more: false };
+    }
+  }
+  function drainSseEvents() {
+    while (true) {
+      const newline = bufferedText.indexOf("\n");
+      if (newline < 0) return null;
+      const rawLine = bufferedText.slice(0, newline);
+      bufferedText = bufferedText.slice(newline + 1);
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      if (line === "") {
+        const result2 = sseEventToWakeHints(pendingEvent);
+        pendingEvent = {};
+        if (result2) return result2;
+        continue;
+      }
+      if (line.startsWith(":")) continue;
+      const separator = line.indexOf(":");
+      const field = separator >= 0 ? line.slice(0, separator) : line;
+      const value = separator >= 0 ? line.slice(separator + (line[separator + 1] === " " ? 2 : 1)) : "";
+      if (field === "event") pendingEvent.event = value;
+      if (field === "id") pendingEvent.id = value;
+      if (field === "data") pendingEvent.data = pendingEvent.data === void 0 ? value : `${pendingEvent.data}
+${value}`;
+    }
+  }
+  return {
+    async fetchWakeHints(input) {
+      return nextEvent(input.since);
+    },
+    close
+  };
+}
+function sseEventToWakeHints(event) {
+  if (!event.data || event.event && event.event !== "wake-hint") return null;
+  const parsed = JSON.parse(event.data);
+  const eventSeq = Number(event.id);
+  const hint = {
+    ...parsed,
+    ...!Number.isNaN(eventSeq) && typeof parsed.seq !== "number" ? { seq: eventSeq } : {}
+  };
+  const seq = typeof hint.seq === "number" ? hint.seq : Number.isNaN(eventSeq) ? null : eventSeq;
+  return {
+    hints: [hint],
+    last_seen_hint_seq: seq,
+    has_more: false
+  };
+}
+function readWithIdleWatchdog(reader, idleTimeoutMs) {
+  let timeout = null;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeout = setTimeout(() => {
+      reject(new TypeError(`wake-hint stream idle timeout after ${idleTimeoutMs}ms`));
+    }, idleTimeoutMs);
+  });
+  return Promise.race([reader.read(), timeoutPromise]).finally(() => {
+    if (timeout) clearTimeout(timeout);
+  });
+}
+var BRIDGE_WAKE_STREAM_IDLE_TIMEOUT_MS = 6e4;
+function parseWakeStreamIdleTimeoutMs(env) {
+  const raw = env.SLOCK_BRIDGE_WAKE_STREAM_IDLE_TIMEOUT_MS;
+  if (raw === void 0) return BRIDGE_WAKE_STREAM_IDLE_TIMEOUT_MS;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : BRIDGE_WAKE_STREAM_IDLE_TIMEOUT_MS;
+}
+function isWakeStreamUnavailable(err) {
+  return err instanceof CliError && err.code === "BRIDGE_WAKE_STREAM_UNAVAILABLE";
+}
+function classifyBridgeLoopError(err) {
+  if (err instanceof CliError) {
+    return err.code === "SERVER_5XX" ? "retryable" : "fatal";
+  }
+  if (err instanceof Error) {
+    const text = `${err.name}: ${err.message} ${err.cause?.message ?? ""}`;
+    if (/wake-hint stream (ended|idle timeout|parse failed)|fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|EPIPE|socket|network|UND_ERR/i.test(text)) {
+      return "retryable";
+    }
+  }
+  return "fatal";
+}
+var BRIDGE_RETRY_MAX_DELAY_MS = 6e4;
+function bridgeRetryDelayMs(consecutiveFailures, pollIntervalMs) {
+  const exp = Math.min(consecutiveFailures - 1, 10);
+  return Math.min(pollIntervalMs * 2 ** exp, BRIDGE_RETRY_MAX_DELAY_MS);
+}
 function parsePositiveInt(raw, fallback, label) {
   if (raw === void 0) return fallback;
   const parsed = Number(raw);
@@ -16381,17 +16838,17 @@ function parsePositiveInt(raw, fallback, label) {
   }
   return parsed;
 }
-function createWakeAdapter(options) {
+function createWakeAdapter(options, env = process.env) {
   if (!options.wakeAdapter) return void 0;
-  if (options.wakeAdapter !== "claude-code-channels") {
+  if (options.wakeAdapter !== "wake-endpoint" && options.wakeAdapter !== "claude-code-channels") {
     throw new CliError({
       code: "INVALID_ARG",
-      message: "--wake-adapter must be `claude-code-channels`"
+      message: "--wake-adapter must be `wake-endpoint` (or the compatible alias `claude-code-channels`)"
     });
   }
   return createClaudeCodeChannelsWakeAdapter({
-    endpointUrl: options.claudeChannelEndpoint,
-    token: options.claudeChannelToken
+    endpointUrl: options.wakeEndpoint ?? options.claudeChannelEndpoint,
+    token: options.wakeEndpointToken ?? options.claudeChannelToken ?? env.SLOCK_WAKE_ENDPOINT_TOKEN ?? env.SLOCK_CLAUDE_CHANNEL_TOKEN
   });
 }
 function sleep(ms) {
@@ -16980,6 +17437,54 @@ function registerThreadUnfollowCommand(parent, runtimeOptions) {
   registerCliCommand(parent, threadUnfollowCommand, runtimeOptions);
 }
 
+// src/commands/message/_consumedSeqState.ts
+import fs3 from "fs";
+import os2 from "os";
+import path5 from "path";
+function stateFilePath(agentId) {
+  return path5.join(
+    process.env.SLOCK_CLI_CONSUMED_SEQ_STATE_DIR ?? os2.tmpdir(),
+    "slock-cli-consumed-seq",
+    agentId,
+    "consumed-seqs.json"
+  );
+}
+function readState(agentId) {
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(stateFilePath(agentId), "utf8"));
+    return typeof parsed === "object" && parsed ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function recordConsumedSeqs(agentId, entries) {
+  const updates = Object.entries(entries).filter(
+    ([target, seq]) => target.length > 0 && Number.isFinite(seq) && seq > 0
+  );
+  if (updates.length === 0) return;
+  const state = readState(agentId);
+  const targets = state.targets ?? {};
+  let changed = false;
+  for (const [target, seq] of updates) {
+    const prior = targets[target];
+    if (!Number.isFinite(prior) || seq > prior) {
+      targets[target] = seq;
+      changed = true;
+    }
+  }
+  if (!changed) return;
+  const filePath = stateFilePath(agentId);
+  try {
+    fs3.mkdirSync(path5.dirname(filePath), { recursive: true });
+    fs3.writeFileSync(filePath, JSON.stringify({ targets }), "utf8");
+  } catch {
+  }
+}
+function getConsumedSeq(agentId, target) {
+  const seq = readState(agentId).targets?.[target];
+  return Number.isFinite(seq) && seq > 0 ? seq : void 0;
+}
+
 // src/commands/message/_format.ts
 function toLocalTime(iso) {
   const d = new Date(iso);
@@ -17092,18 +17597,18 @@ Your last read position: seq ${data.last_read_seq}. Use slock message read --cha
 
 ${formatted}${footer}`;
 }
-function renderSearchSource(result) {
-  if (result.channelType === "thread") {
-    const shortId = typeof result.channelName === "string" && result.channelName.startsWith("thread-") ? result.channelName.slice(7) : typeof result.threadId === "string" && result.threadId ? result.threadId.slice(0, 8) : result.channelName;
-    if (result.parentChannelType === "dm") {
-      return `dm:${neutralizeSlockRefLiterals(result.parentChannelName ?? "unknown")}:${shortId}`;
+function renderSearchSource(result2) {
+  if (result2.channelType === "thread") {
+    const shortId = typeof result2.channelName === "string" && result2.channelName.startsWith("thread-") ? result2.channelName.slice(7) : typeof result2.threadId === "string" && result2.threadId ? result2.threadId.slice(0, 8) : result2.channelName;
+    if (result2.parentChannelType === "dm") {
+      return `dm:${neutralizeSlockRefLiterals(result2.parentChannelName ?? "unknown")}:${shortId}`;
     }
-    return `thread:${neutralizeSlockRefLiterals(result.parentChannelName ?? "unknown")}:${shortId}`;
+    return `thread:${neutralizeSlockRefLiterals(result2.parentChannelName ?? "unknown")}:${shortId}`;
   }
-  if (result.channelType === "dm") {
-    return `dm:${neutralizeSlockRefLiterals(result.channelName ?? "unknown")}`;
+  if (result2.channelType === "dm") {
+    return `dm:${neutralizeSlockRefLiterals(result2.channelName ?? "unknown")}`;
   }
-  return `channel:${neutralizeSlockRefLiterals(result.channelName ?? "unknown")}`;
+  return `channel:${neutralizeSlockRefLiterals(result2.channelName ?? "unknown")}`;
 }
 var PREVIEW_BEFORE_CHARS = 80;
 var PREVIEW_AFTER_CHARS = 120;
@@ -17209,16 +17714,16 @@ function renderSearchPreview(content, query) {
 }
 function formatSearchResults(query, data) {
   if (!data.results || data.results.length === 0) return "No search results.";
-  const formatted = data.results.map((result, index) => {
-    const ref = `msg:${result.id}`;
-    const content = result.content ?? result.snippet ?? "";
-    const sender = neutralizeSlockRefLiterals(result.senderName ?? "unknown");
-    const senderType = result.senderType ? ` (${result.senderType})` : "";
+  const formatted = data.results.map((result2, index) => {
+    const ref = `msg:${result2.id}`;
+    const content = result2.content ?? result2.snippet ?? "";
+    const sender = neutralizeSlockRefLiterals(result2.senderName ?? "unknown");
+    const senderType = result2.senderType ? ` (${result2.senderType})` : "";
     return [
       `<result ref="${ref}">`,
-      `Source: ${renderSearchSource(result)}`,
+      `Source: ${renderSearchSource(result2)}`,
       `Sender: ${sender}${senderType}`,
-      `Time: ${result.createdAt ? toLocalTime(result.createdAt) : "-"}`,
+      `Time: ${result2.createdAt ? toLocalTime(result2.createdAt) : "-"}`,
       "",
       "<preview>",
       renderSearchPreview(content, query),
@@ -17260,17 +17765,17 @@ ${opts.heldAction} Review the bounded context shown here, then choose one path.$
 }
 
 // src/commands/message/_continueDraftState.ts
-import fs3 from "fs";
-import os2 from "os";
-import path5 from "path";
+import fs4 from "fs";
+import os3 from "os";
+import path6 from "path";
 var DEFAULT_LOCAL_DRAFT_TTL_MS = 10 * 60 * 1e3;
-function stateFilePath(agentId) {
-  return path5.join(process.env.SLOCK_CLI_DRAFT_STATE_DIR ?? os2.tmpdir(), "slock-cli-attested-send", agentId, "continue-state.json");
+function stateFilePath2(agentId) {
+  return path6.join(process.env.SLOCK_CLI_DRAFT_STATE_DIR ?? os3.tmpdir(), "slock-cli-attested-send", agentId, "continue-state.json");
 }
-function readState(agentId) {
-  const filePath = stateFilePath(agentId);
+function readState2(agentId) {
+  const filePath = stateFilePath2(agentId);
   try {
-    const raw = fs3.readFileSync(filePath, "utf8");
+    const raw = fs4.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed === "object" && parsed ? parsed : {};
   } catch {
@@ -17278,12 +17783,12 @@ function readState(agentId) {
   }
 }
 function writeState(agentId, state) {
-  const filePath = stateFilePath(agentId);
-  fs3.mkdirSync(path5.dirname(filePath), { recursive: true });
-  fs3.writeFileSync(filePath, JSON.stringify(state), "utf8");
+  const filePath = stateFilePath2(agentId);
+  fs4.mkdirSync(path6.dirname(filePath), { recursive: true });
+  fs4.writeFileSync(filePath, JSON.stringify(state), "utf8");
 }
 function getSavedDraft(agentId, target) {
-  const state = readState(agentId);
+  const state = readState2(agentId);
   const draft = state.targets?.[target];
   if (!draft || typeof draft === "string") return null;
   if (typeof draft.content !== "string") return null;
@@ -17304,7 +17809,7 @@ function getSavedDraft(agentId, target) {
   };
 }
 function setSavedDraft(agentId, target, draft) {
-  const state = readState(agentId);
+  const state = readState2(agentId);
   const targets = state.targets ?? {};
   targets[target] = {
     content: draft.content,
@@ -17316,7 +17821,7 @@ function setSavedDraft(agentId, target, draft) {
   writeState(agentId, { targets });
 }
 function clearSavedDraft(agentId, target) {
-  const state = readState(agentId);
+  const state = readState2(agentId);
   if (!state.targets || !(target in state.targets)) return;
   delete state.targets[target];
   writeState(agentId, state);
@@ -17513,6 +18018,9 @@ var messageSendCommand = defineCommand(
       previousDraftReholdCount = previousDraft?.reholdCount ?? 0;
       seenUpToSeq = previousDraft?.seenUpToSeq;
     }
+    if (seenUpToSeq === void 0) {
+      seenUpToSeq = getConsumedSeq(agentContext.agentId, opts.target);
+    }
     const body = {
       target: opts.target,
       content: outgoingContent,
@@ -17541,6 +18049,9 @@ var messageSendCommand = defineCommand(
     }
     const data = res.data;
     if (data.state === "held") {
+      if (typeof data.seenUpToSeq === "number" && Number.isFinite(data.seenUpToSeq)) {
+        recordConsumedSeqs(agentContext.agentId, { [opts.target]: data.seenUpToSeq });
+      }
       setSavedDraft(agentContext.agentId, opts.target, {
         content: outgoingContent,
         attachmentIds: outgoingAttachmentIds,
@@ -17570,31 +18081,72 @@ function registerSendCommand(parent, runtimeOptions = {}) {
 }
 
 // src/commands/message/_inbox.ts
+var MAX_DRAIN_ROUNDS = 50;
+function sortedMessages(messages) {
+  return [...messages].sort((a, b) => {
+    const aSeq = Number.isInteger(a.seq) && a.seq > 0 ? a.seq : Number.MAX_SAFE_INTEGER;
+    const bSeq = Number.isInteger(b.seq) && b.seq > 0 ? b.seq : Number.MAX_SAFE_INTEGER;
+    return aSeq - bSeq;
+  });
+}
+function result(messages, opts = {}) {
+  return {
+    messages: sortedMessages(messages),
+    ...opts.ackFailure ? { ackFailure: opts.ackFailure } : {},
+    ...opts.drainedMore ? { drainedMore: true } : {},
+    ...opts.hasMore ? { hasMore: true } : {},
+    ...opts.drainComplete ? { drainComplete: true } : {}
+  };
+}
+function hasMoreField(data) {
+  if (!data) return false;
+  return Object.prototype.hasOwnProperty.call(data, "has_more") || Object.prototype.hasOwnProperty.call(data, "hasMore");
+}
 async function drainInbox(ctx, opts, client = new ApiClient(ctx)) {
   const agentPath = `/internal/agent/${encodeURIComponent(ctx.agentId)}`;
   const failCode = opts.block ? "WAIT_FAILED" : "CHECK_FAILED";
   const query = [];
   if (opts.block) query.push("block=true");
   if (opts.block && opts.timeoutMs !== void 0) query.push(`timeout=${opts.timeoutMs}`);
-  const path7 = query.length > 0 ? `${agentPath}/receive?${query.join("&")}` : `${agentPath}/receive`;
-  const res = await client.request("GET", path7);
-  if (!res.ok) {
-    throw new CliError({
-      code: res.status >= 500 ? "SERVER_5XX" : failCode,
-      message: res.error ?? `HTTP ${res.status}`
-    });
-  }
-  const messages = res.data?.messages ?? [];
-  if (ctx.clientMode === "managed-runner" || ctx.clientMode === "self-hosted-runner") {
-    return { messages };
+  const path8 = query.length > 0 ? `${agentPath}/receive?${query.join("&")}` : `${agentPath}/receive`;
+  const allMessages = [];
+  let sawHasMore = false;
+  for (let round = 0; round < MAX_DRAIN_ROUNDS; round += 1) {
+    const res = await client.request("GET", path8);
+    if (!res.ok) {
+      if (allMessages.length > 0) {
+        return result(allMessages, { drainedMore: sawHasMore, hasMore: true });
+      }
+      throw new CliError({
+        code: res.status >= 500 ? "SERVER_5XX" : failCode,
+        message: res.error ?? `HTTP ${res.status}`
+      });
+    }
+    const messages = res.data?.messages ?? [];
+    allMessages.push(...messages);
+    const hasMore = res.data?.has_more === true || res.data?.hasMore === true;
+    const hasExplicitHasMore = hasMoreField(res.data);
+    const drainComplete = hasExplicitHasMore && !hasMore && allMessages.length > 0;
+    sawHasMore = sawHasMore || hasMore;
+    if (ctx.clientMode === "managed-runner" || ctx.clientMode === "self-hosted-runner") {
+      if (hasMore && messages.length > 0) continue;
+      return result(allMessages, { drainedMore: sawHasMore, hasMore, drainComplete });
+    }
+    const seqs = messages.map((m) => m.seq).filter((s) => Number.isInteger(s) && s > 0);
+    if (seqs.length === 0) return result(allMessages, { drainedMore: sawHasMore, hasMore, drainComplete });
+    const ack = await client.request("POST", `${agentPath}/receive-ack`, { seqs });
+    if (!ack.ok) {
+      const ackCode = ack.status >= 500 ? "SERVER_5XX" : "ACK_FAILED";
+      const ackMessage = ack.error ?? `HTTP ${ack.status}`;
+      return result(allMessages, {
+        ackFailure: { code: ackCode, message: ackMessage },
+        drainedMore: sawHasMore,
+        hasMore
+      });
+    }
+    if (!hasMore) return result(allMessages, { drainedMore: sawHasMore, drainComplete });
   }
-  const seqs = messages.map((m) => m.seq).filter((s) => Number.isInteger(s) && s > 0);
-  if (seqs.length === 0) return { messages };
-  const ack = await client.request("POST", `${agentPath}/receive-ack`, { seqs });
-  if (ack.ok) return { messages };
-  const ackCode = ack.status >= 500 ? "SERVER_5XX" : "ACK_FAILED";
-  const ackMessage = ack.error ?? `HTTP ${ack.status}`;
-  return { messages, ackFailure: { code: ackCode, message: ackMessage } };
+  return result(allMessages, { drainedMore: sawHasMore, hasMore: true });
 }
 
 // src/commands/message/check.ts
@@ -17605,13 +18157,21 @@ var messageCheckCommand = defineCommand(
   },
   async (ctx) => {
     const agentContext = ctx.loadAgentContext();
-    const result = await drainInbox(
+    const result2 = await drainInbox(
       agentContext,
       { block: false },
       ctx.createApiClient(agentContext)
     );
-    writeText(ctx.io, `${formatMessages(result.messages)}
-`);
+    const drainStatus = result2.hasMore ? "\nMore messages are pending. Run `slock message check` again.\n" : result2.drainComplete ? "\nNo more new messages.\n" : "\n";
+    writeText(ctx.io, `${formatMessages(result2.messages)}${drainStatus}`);
+    const consumed = {};
+    for (const m of result2.messages) {
+      const seq = typeof m.seq === "number" && Number.isFinite(m.seq) ? m.seq : null;
+      if (seq === null) continue;
+      const target = formatTarget(m);
+      if (!consumed[target] || seq > consumed[target]) consumed[target] = seq;
+    }
+    recordConsumedSeqs(agentContext.agentId, consumed);
   }
 );
 function registerCheckCommand(parent, runtimeOptions) {
@@ -17716,6 +18276,12 @@ var messageReadCommand = defineCommand(
       })}
 `
     );
+    const rows = res.data.messages ?? [];
+    let maxSeq = 0;
+    for (const row of rows) {
+      if (typeof row.seq === "number" && Number.isFinite(row.seq) && row.seq > maxSeq) maxSeq = row.seq;
+    }
+    if (maxSeq > 0) recordConsumedSeqs(agentContext.agentId, { [readOpts.channel]: maxSeq });
   }
 );
 function registerReadCommand(parent, runtimeOptions) {
@@ -18187,6 +18753,76 @@ function registerAttachmentViewCommand(parent, runtimeOptions) {
   registerCliCommand(parent, attachmentViewCommand, runtimeOptions);
 }
 
+// src/commands/attachment/comments.ts
+function anchorSummary(anchor) {
+  if (anchor.type === "md-section") {
+    const title = anchor.data.headingTitle ?? anchor.data.headingId;
+    return typeof title === "string" && title ? `\xA7 ${title}` : "\xA7 section";
+  }
+  if (anchor.type === "lines" || anchor.type === "csv-rows") {
+    const start = Number(anchor.data.start);
+    const end = Number(anchor.data.end ?? start);
+    if (!Number.isFinite(start)) return anchor.type;
+    const prefix = anchor.type === "lines" ? "L" : "rows ";
+    return start === (Number.isFinite(end) ? end : start) ? `${prefix}${start}` : `${prefix}${start}\u2013${end}`;
+  }
+  if (anchor.type === "html-region") {
+    const quote = anchor.data.quote;
+    if (typeof quote === "string" && quote.trim().length > 0) {
+      const trimmed = quote.trim();
+      return trimmed.length > 60 ? `${trimmed.slice(0, 60)}\u2026` : trimmed;
+    }
+    return "HTML region";
+  }
+  return anchor.type;
+}
+var attachmentCommentsCommand = defineCommand(
+  {
+    name: "comments",
+    description: "List comments scoped to an attachment",
+    options: [
+      { flags: "--id <attachmentId>", description: "Attachment UUID" },
+      { flags: "--limit <n>", description: "Max comments to return (default 200)" }
+    ]
+  },
+  async (ctx, opts) => {
+    const id = opts.id?.trim();
+    if (!id) {
+      throw new CliError({ code: "INVALID_ARG", message: "--id is required" });
+    }
+    const agentContext = ctx.loadAgentContext();
+    const client = ctx.createApiClient(agentContext);
+    const limitParam = opts.limit && Number.isFinite(Number(opts.limit)) ? `?limit=${Number(opts.limit)}` : "";
+    const res = await client.request(
+      "GET",
+      `/api/attachments/${encodeURIComponent(id)}/comments${limitParam}`
+    );
+    if (!res.ok || !res.data) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "COMMENTS_FAILED";
+      throw new CliError({ code, message: res.error ?? `HTTP ${res.status}` });
+    }
+    const { comments, threadChannelId } = res.data;
+    if (comments.length === 0) {
+      writeText(ctx.io, `No comments on attachment ${id.slice(0, 8)}.
+`);
+      return;
+    }
+    const lines = [`## Comments on attachment ${id.slice(0, 8)} (${comments.length})`];
+    for (const c of comments) {
+      const check2 = c.reactions.some((r) => r.emoji === "\u2705") ? " \u2705" : "";
+      const anchor = c.anchor ? ` [anchor: ${anchorSummary(c.anchor)}]` : "";
+      lines.push(`[msg=${c.id.slice(0, 8)} time=${c.createdAt} type=${c.senderType}]${check2}${anchor} @${c.senderName}: ${c.content}`);
+    }
+    if (threadChannelId) {
+      lines.push(`(full conversation lives in thread channel ${threadChannelId})`);
+    }
+    writeText(ctx.io, lines.join("\n") + "\n");
+  }
+);
+function registerAttachmentCommentsCommand(parent, runtimeOptions) {
+  registerCliCommand(parent, attachmentCommentsCommand, runtimeOptions);
+}
+
 // src/commands/task/_format.ts
 function formatTaskList(channel, data, statusFilter) {
   if (!data.tasks || data.tasks.length === 0) {
@@ -19021,10 +19657,12 @@ function registerIntegrationLoginCommand(parent, runtimeOptions = {}) {
 }
 
 // src/commands/integration/manifest.ts
-import fs4 from "fs";
-import os3 from "os";
-import path6 from "path";
+import fs5 from "fs";
+import os4 from "os";
+import path7 from "path";
 var AGENT_MANIFEST_MAX_BYTES = 64 * 1024;
+var AGENT_MANIFEST_SCHEMA_V0 = "slock-agent-manifest.v0";
+var AGENT_MANIFEST_SCHEMA_V0_URL = "https://app.slock.ai/schemas/agent-manifest.v0.json";
 var AgentManifestFetchError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -19032,6 +19670,12 @@ var AgentManifestFetchError = class extends Error {
     this.name = "AgentManifestFetchError";
   }
 };
+var AgentManifestResponseFormatError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentManifestResponseFormatError";
+  }
+};
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -19065,8 +19709,8 @@ function requireCommand(value) {
 }
 function validateAgentManifestV0(value) {
   if (!isRecord(value)) throw new Error("manifest must be a JSON object");
-  if (value.schema !== "slock-agent-manifest.v0") {
-    throw new Error("manifest schema must be slock-agent-manifest.v0");
+  if (value.schema !== AGENT_MANIFEST_SCHEMA_V0 && value.schema !== AGENT_MANIFEST_SCHEMA_V0_URL) {
+    throw new Error(`manifest schema must be ${AGENT_MANIFEST_SCHEMA_V0}`);
   }
   const execution = value.execution;
   if (!isRecord(execution)) throw new Error("execution must be an object");
@@ -19086,7 +19730,7 @@ function validateAgentManifestV0(value) {
     throw new Error("context_check must be an object when present");
   }
   return {
-    schema: value.schema,
+    schema: AGENT_MANIFEST_SCHEMA_V0,
     service: typeof value.service === "string" && value.service.trim() ? value.service.trim() : void 0,
     docs_url: value.docs_url === void 0 ? void 0 : requireUrl(value.docs_url, "docs_url"),
     execution: {
@@ -19122,7 +19766,7 @@ async function fetchAgentManifest(url2) {
   }
   const contentType = response.headers.get("content-type") ?? "";
   if (contentType && !contentType.includes("application/json")) {
-    throw new Error("manifest response must be application/json");
+    throw new AgentManifestResponseFormatError("manifest response must be application/json");
   }
   const contentLength = Number(response.headers.get("content-length") ?? "");
   if (Number.isFinite(contentLength) && contentLength > AGENT_MANIFEST_MAX_BYTES) {
@@ -19137,7 +19781,7 @@ async function fetchAgentManifest(url2) {
   try {
     parsedJson = JSON.parse(raw);
   } catch (err) {
-    throw new Error(`manifest response is not valid JSON: ${err.message}`);
+    throw new AgentManifestResponseFormatError(`manifest response is not valid JSON: ${err.message}`);
   }
   return validateAgentManifestV0(parsedJson);
 }
@@ -19146,8 +19790,8 @@ function sanitizePathSegment(value) {
   return segment || "service";
 }
 function resolveSlockHome(env) {
-  if (env.SLOCK_HOME?.trim()) return path6.resolve(env.SLOCK_HOME);
-  return path6.join(env.HOME ?? os3.homedir(), ".slock");
+  if (env.SLOCK_HOME?.trim()) return path7.resolve(env.SLOCK_HOME);
+  return path7.join(env.HOME ?? os4.homedir(), ".slock");
 }
 function buildLocalCliProfileEnv(input) {
   if (input.manifest.execution.mode !== "local_cli" || !input.manifest.execution.command) {
@@ -19160,15 +19804,15 @@ function buildLocalCliProfileEnv(input) {
     throw new Error("manifest must set credential_boundary.forbid_user_home=true for local_cli isolation");
   }
   const root = resolveSlockHome(input.env ?? process.env);
-  const profileHome = path6.join(
+  const profileHome = path7.join(
     root,
     "integration-profiles",
     sanitizePathSegment(input.ctx.serverId ?? "server"),
     sanitizePathSegment(input.ctx.agentId),
     sanitizePathSegment(input.serviceId)
   );
-  fs4.mkdirSync(profileHome, { recursive: true, mode: 448 });
-  fs4.chmodSync(profileHome, 448);
+  fs5.mkdirSync(profileHome, { recursive: true, mode: 448 });
+  fs5.chmodSync(profileHome, 448);
   return {
     serviceId: input.serviceId,
     command: input.manifest.execution.command,
@@ -19177,10 +19821,10 @@ function buildLocalCliProfileEnv(input) {
       SLOCK_INTEGRATION_SERVICE: input.serviceId,
       SLOCK_INTEGRATION_PROFILE_HOME: profileHome,
       HOME: profileHome,
-      XDG_CONFIG_HOME: path6.join(profileHome, ".config"),
-      XDG_CACHE_HOME: path6.join(profileHome, ".cache"),
-      XDG_DATA_HOME: path6.join(profileHome, ".local", "share"),
-      XDG_STATE_HOME: path6.join(profileHome, ".local", "state")
+      XDG_CONFIG_HOME: path7.join(profileHome, ".config"),
+      XDG_CACHE_HOME: path7.join(profileHome, ".cache"),
+      XDG_DATA_HOME: path7.join(profileHome, ".local", "share"),
+      XDG_STATE_HOME: path7.join(profileHome, ".local", "state")
     }
   };
 }
@@ -19232,6 +19876,18 @@ function describeMissingManifest(input) {
   }
   return `${input.service.name} does not expose an agent behavior manifest; no local CLI env is required`;
 }
+function isInferredWellKnownManifest(service) {
+  return service.agentManifestUrlSource === "well_known";
+}
+function noLocalEnvForMissingManifest(service) {
+  return {
+    kind: "no-local-env",
+    service,
+    manifestUrl: service.agentManifestUrl,
+    manifest: null,
+    message: describeMissingManifest({ service, manifestUrl: service.agentManifestUrl })
+  };
+}
 var IntegrationEnvError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -19255,13 +19911,10 @@ async function resolveIntegrationEnv(input) {
     manifest = await fetchManifestImpl(input.service.agentManifestUrl);
   } catch (err) {
     if (err instanceof AgentManifestFetchError && (err.status === 404 || err.status === 410)) {
-      return {
-        kind: "no-local-env",
-        service: input.service,
-        manifestUrl: input.service.agentManifestUrl,
-        manifest: null,
-        message: describeMissingManifest({ service: input.service, manifestUrl: input.service.agentManifestUrl })
-      };
+      return noLocalEnvForMissingManifest(input.service);
+    }
+    if (isInferredWellKnownManifest(input.service) && err instanceof AgentManifestResponseFormatError) {
+      return noLocalEnvForMissingManifest(input.service);
     }
     throw new IntegrationEnvError("INTEGRATION_MANIFEST_INVALID", err.message);
   }
@@ -19809,6 +20462,7 @@ registerReactCommand(messageCmd);
 var attachmentCmd = program.command("attachment").description("Attachment operations");
 registerAttachmentUploadCommand(attachmentCmd);
 registerAttachmentViewCommand(attachmentCmd);
+registerAttachmentCommentsCommand(attachmentCmd);
 var taskCmd = program.command("task").description("Task board operations");
 registerTaskListCommand(taskCmd);
 registerTaskCreateCommand(taskCmd);