@@ -327,7 +327,15 @@ pick back here to render through this plugin's own templates:
 ```
 │  ◈ Forgot to provide: Greeter | Database
 │  ⚡ Jev: .pipe(Effect.provide(AppLive))
-│     ↳ layer AppLive 0.99 · where here 0.60
+│     ↳ this expression is the program boundary · 0.99
+```
+
+A `Layer` missing its own `RIn` gets `Layer.provide(X) inside this layer`.
+A channel that is only `unknown` has no service to name, so the "annotate
+the effect to find where R widened" line becomes the place itself:
+
+```
+│  ⚡ Jev: annotate steps (src/jobs.ts:145), where R widened
 ```
 
 It also replaces the TS2769 overload heuristic when Jev is confident about
@@ -369,14 +377,18 @@ require("effect-error-pretty.parse").parse(message, { effect = true })
 -- Seams for an external judge (this is what jury.nvim registers into).
 -- The resolver runs inside vim.diagnostic's formatter: synchronous, fast.
 pretty.set_hint_resolver(function(parsed, family, names, diagnostic)
-  -- family is "services" or "errors"; return nil for the generic hint, or
-  -- { label = "Jev", line = "...", detail = "..." } to replace it, or
-  -- { lean = "..." } to keep it and add a line underneath.
+  -- family is "services", "errors" or "widened"; return nil for the generic
+  -- hint, or { label = "Jev", line = "...", detail = "..." } to replace it,
+  -- or { lean = "..." } to keep it and add a line underneath.
+  -- "services" with parsed.tag == "layer" is a Layer's missing RIn.
+  -- "widened": names[1] is the channel label (R, RIn or E) that is only
+  -- unknown/any; the job is to say which definition lost its type.
 end)
 pretty.set_overload_picker(function(msg, candidates) return index_or_nil end)
-pretty.hint_family(parsed)                 -- "services"|"errors"|nil, names
+pretty.hint_family(parsed)                 -- "services"|"errors"|"widened"|nil, names
 pretty.templates.provide(layer, names, where)
 pretty.templates.unhandled(fix, names, target)
+pretty.templates.widened(label, name, file, line)
 ```
 
 ## Extending
 
@@ -10,25 +10,73 @@ local M = {}
 
 -- ── families ──────────────────────────────────────────────────────────────
 
+local function is_uninferred(name)
+  return name == "unknown" or name == "any"
+end
+
+--- True when a channel holds nothing but `unknown`/`any`: inference gave up
+--- upstream and there is no service or error to name.
+---@param names string[]|nil
+---@return boolean
+function M.all_uninferred(names)
+  if type(names) ~= "table" or #names == 0 then
+    return false
+  end
+  for _, n in ipairs(names) do
+    if not is_uninferred(n) then
+      return false
+    end
+  end
+  return true
+end
+
 --- Which hint family a parsed result belongs to, and the names involved.
 --- Only families with a concrete fix shape are returned. Scope-only results
---- are excluded on purpose: `Effect.scoped` needs no judgment.
+--- are excluded on purpose: `Effect.scoped` needs no judgment. A Layer's
+--- missing RIn is "services" too; `parsed.tag == "layer"` tells the
+--- resolver that the fix is Layer.provide inside the layer, not a pipe.
+--- A channel that is only `unknown`/`any` is "widened": `names` is then the
+--- channel label (R, RIn or E) and the resolver's job is to say where
+--- upstream the type was lost.
 ---@param parsed table  result of parse.parse
----@return "services"|"errors"|nil family, string[]|nil names
+---@return "services"|"errors"|"widened"|nil family, string[]|nil names
 function M.family(parsed)
   if type(parsed) ~= "table" then
     return nil
   end
   if parsed.kind == "effect_mismatch" then
-    if parsed.missing_services and #parsed.missing_services > 0 and not parsed.scope_required then
-      return "services", parsed.missing_services
+    -- Only the single-channel boxes carry a hint line; the tri-channel
+    -- view and the identical-signature box do not, so asking is waste.
+    if parsed.diff_count ~= 1 then
+      return nil
+    end
+    local labels = parsed.labels or { "A", "E", "R" }
+    if parsed.missing_services and #parsed.missing_services > 0 then
+      if M.all_uninferred(parsed.missing_services) then
+        return "widened", { labels[3] }
+      end
+      if not parsed.scope_required then
+        return "services", parsed.missing_services
+      end
+      return nil
     end
     if parsed.unhandled_errors and #parsed.unhandled_errors > 0 then
+      if M.all_uninferred(parsed.unhandled_errors) then
+        return "widened", { labels[2] }
+      end
       return "errors", parsed.unhandled_errors
     end
-  elseif parsed.kind == "missing_context" and parsed.tag == "effect" and not parsed.scope_required then
-    return "services", parsed.services
+  elseif parsed.kind == "missing_context" then
+    if M.all_uninferred(parsed.services) then
+      return "widened", { parsed.tag == "layer" and "RIn" or "R" }
+    end
+    if not parsed.scope_required then
+      return "services", parsed.services
+    end
   elseif parsed.kind == "missing_errors" then
+    if M.all_uninferred(parsed.errors) then
+      return "widened", { "E" }
+    end
     return "errors", parsed.errors
   end
   return nil
@@ -78,6 +126,17 @@ function M.templates.unhandled(fix, names, target)
   return nil
 end
 
+--- Concrete hint for a widened channel: name the definition to annotate.
+---@param label string        R, RIn or E
+---@param name string         the identifier that most likely lost its type
+---@param file string|nil
+---@param line integer|nil
+---@return string
+function M.templates.widened(label, name, file, line)
+  local where = file and (line and (" (%s:%d)"):format(file, line) or (" (%s)"):format(file)) or ""
+  return ("annotate %s%s, where %s widened"):format(name, where, label)
+end
+
 -- ── the seam ──────────────────────────────────────────────────────────────
 
 ---@class EffectErrorPretty.Hint
 
@@ -274,8 +274,9 @@ end
 M.is_uninferred = is_uninferred
 
 -- Why a channel came out `unknown`, and what to do about it.  Deliberately
--- names no service: there isn't one to name.
-local function uninferred_lines(name, label, found)
+-- names no service: there isn't one to name.  A resolver may name the
+-- definition that lost its type; that replaces the "go look" line.
+local function uninferred_lines(name, label, found, hint)
   local lines = {
     "╭─ ⚠ " .. name .. " — " .. label .. " Not Inferred",
     "│",
@@ -286,7 +287,12 @@ local function uninferred_lines(name, label, found)
     "│  ⚡ Hint: ",
     "something upstream is untyped — an `any`, a missing annotation, or a generic that never got inferred"
   )
-  push_prose(lines, "│  ⚡ Hint: ", "annotate the effect to find where " .. label .. " widened")
+  local generic = "annotate the effect to find where " .. label .. " widened"
+  if hint then
+    vim.list_extend(lines, hints.lines(hint, generic))
+  else
+    push_prose(lines, "│  ⚡ Hint: ", generic)
+  end
   return lines
 end
 
@@ -299,7 +305,7 @@ local function missing_services_lines(name, services, is_layer, only_scope, scop
 
   -- Nothing actionable in the channel: the whole box would be a lie.
   if #real == 0 and #unresolved > 0 then
-    return uninferred_lines(name, label, unresolved[1])
+    return uninferred_lines(name, label, unresolved[1], hint)
   end
 
   local title
@@ -321,7 +327,13 @@ local function missing_services_lines(name, services, is_layer, only_scope, scop
   if only_scope then
     push_prose(lines, "│  ⚡ Hint: ", "wrap in Effect.scoped(...) — Scope is required")
   elseif is_layer then
-    push_prose(lines, "│  ⚡ Hint: ", "compose with Layer.provide(...) or Layer.merge(...)")
+    -- Same seam as the effect branch: a resolver may name the layer to
+    -- compose in, or add a lean under the generic line.
+    if hint then
+      vim.list_extend(lines, hints.lines(hint, "compose with Layer.provide(...) or Layer.merge(...)"))
+    else
+      push_prose(lines, "│  ⚡ Hint: ", "compose with Layer.provide(...) or Layer.merge(...)")
+    end
   else
     -- A registered resolver may replace the generic provide hint with a
     -- concrete one, or add a lean under it. Everything else is unchanged.
@@ -342,7 +354,7 @@ end
 local function unhandled_errors_lines(name, errors, hint)
   local real, unresolved = partition_uninferred(errors)
   if #real == 0 and #unresolved > 0 then
-    return uninferred_lines(name, "E", unresolved[1])
+    return uninferred_lines(name, "E", unresolved[1], hint)
   end
 
   local lines = { "╭─ ⚠ " .. name .. " — Unhandled Errors", "│" }
 
@@ -11,6 +11,13 @@ local UNHANDLED = "Type 'Effect<string, NotFound, Database>' is not assignable t
 local LS_ERRORS = "Missing 'NotFound | Timeout' in the expected Effect errors."
 local LS_CTX = "This Effect requires a service that is missing from the expected Effect context: `Greeter`."
 local SCOPE = "Type 'Effect<string, never, Scope>' is not assignable to type 'Effect<string, never, never>'"
+local LAYER_RIN = "Type 'Layer<{ readonly get: (id: string) => Effect<User, DbError, never>; }, never, Database>' is not assignable to type 'Layer<{ readonly get: (id: string) => Effect<User, DbError, never>; }, never, never>'."
+local LS_LAYER = "Missing 'Database' in the expected Layer context."
+local WIDE_R = "Argument of type 'Effect<string, never, unknown>' is not assignable to parameter of type 'Effect<string, never, never>'" .. SUFFIX
+local WIDE_E = "Type 'Effect<string, unknown, never>' is not assignable to type 'Effect<string, never, never>'" .. SUFFIX
+local LS_WIDE_E = "Missing 'unknown' in the expected Effect errors."
+local LS_WIDE_RIN = "Missing 'any' in the expected Layer context."
+local MULTI = "Type 'Effect<string, NotFound, Database>' is not assignable to type 'Effect<number, never, never>'" .. SUFFIX
 
 local NO_OVERLOAD = table.concat({
   "No overload matches this call.",
@@ -44,6 +51,40 @@ describe("hints.family", function()
     assert.are.same({ "NotFound", "Timeout" }, names)
   end)
 
+  it("classifies a Layer's missing RIn as services and marks the tag", function()
+    local parsed = parse.parse(LAYER_RIN)
+    local f, names = hints.family(parsed)
+    assert.are.equal("services", f)
+    assert.are.same({ "Database" }, names)
+    assert.are.equal("layer", parsed.tag)
+    parsed = parse.parse(LS_LAYER)
+    f, names = hints.family(parsed)
+    assert.are.equal("services", f)
+    assert.are.same({ "Database" }, names)
+    assert.are.equal("layer", parsed.tag)
+  end)
+
+  it("classifies a channel that is only unknown/any as widened, named by its label", function()
+    local f, names = hints.family(parse.parse(WIDE_R))
+    assert.are.equal("widened", f)
+    assert.are.same({ "R" }, names)
+    f, names = hints.family(parse.parse(WIDE_E))
+    assert.are.equal("widened", f)
+    assert.are.same({ "E" }, names)
+    f, names = hints.family(parse.parse(LS_WIDE_E))
+    assert.are.equal("widened", f)
+    assert.are.same({ "E" }, names)
+    f, names = hints.family(parse.parse(LS_WIDE_RIN))
+    assert.are.equal("widened", f)
+    assert.are.same({ "RIn" }, names)
+  end)
+
+  it("asks nothing when more than one channel differs", function()
+    local parsed = parse.parse(MULTI)
+    assert.is_true(parsed.diff_count > 1)
+    assert.is_nil(hints.family(parsed))
+  end)
+
   it("leaves scope-only results alone", function()
     assert.is_nil(hints.family(parse.parse(SCOPE)))
     assert.is_nil(hints.family(nil))
@@ -95,6 +136,48 @@ describe("hints resolver seam", function()
     assert.is_falsy(box:find("SomeLayer", 1, true))
   end)
 
+  it("honors the resolver in the Layer RIn box, from a type diff and from the language service", function()
+    hints.set_resolver(function(parsed, family, names)
+      assert.are.equal("services", family)
+      assert.are.equal("layer", parsed.tag)
+      return { label = "Jev", line = hints.templates.provide("DatabaseLive", names, "layer"), detail = "layer DatabaseLive 0.93" }
+    end)
+    for _, case in ipairs({ { LAYER_RIN, "typescript" }, { LS_LAYER, "effect" } }) do
+      local box = render.artistic(diag(case[1], case[2]), { effect = true })
+      assert.is_truthy(box:find("Missing RIn", 1, true))
+      assert.is_truthy(box:find("⚡ Jev: Layer.provide(DatabaseLive) inside this layer", 1, true))
+      assert.is_truthy(box:find("↳ layer DatabaseLive 0.93", 1, true))
+      assert.is_falsy(box:find("Layer.merge", 1, true))
+    end
+    hints.set_resolver(function()
+      return { lean = "jev unsure: layer none 0.40" }
+    end)
+    local box = render.artistic(diag(LAYER_RIN), { effect = true })
+    assert.is_truthy(box:find("⚡ Hint: compose with Layer.provide(...) or Layer.merge(...)", 1, true))
+    assert.is_truthy(box:find("↳ jev unsure: layer none 0.40", 1, true))
+  end)
+
+  it("lets the resolver name where a widened channel lost its type", function()
+    hints.set_resolver(function(_, family, names)
+      assert.are.equal("widened", family)
+      return { label = "Jev", line = hints.templates.widened(names[1], "fromRegistry", "app.ts", 12), detail = "widened fromRegistry 0.81" }
+    end)
+    local box = render.artistic(diag(WIDE_R), { effect = true })
+    assert.is_truthy(box:find("R Not Inferred", 1, true))
+    assert.is_truthy(box:find("⚡ Jev: annotate fromRegistry (app.ts:12), where R widened", 1, true))
+    assert.is_truthy(box:find("↳ widened fromRegistry 0.81", 1, true))
+    assert.is_falsy(box:find("annotate the effect to find where", 1, true))
+    box = render.artistic(diag(LS_WIDE_E, "effect"), { effect = true })
+    assert.is_truthy(box:find("E Not Inferred", 1, true))
+    assert.is_truthy(box:find("where E widened", 1, true))
+    hints.set_resolver(function()
+      return { lean = "jev unsure: widened none 0.30" }
+    end)
+    box = render.artistic(diag(WIDE_E), { effect = true })
+    assert.is_truthy(box:find("⚡ Hint: annotate the effect to find where E widened", 1, true))
+    assert.is_truthy(box:find("↳ jev unsure: widened none 0.30", 1, true))
+  end)
+
   it("keeps the generic line and adds a lean when the resolver is unsure", function()
     hints.set_resolver(function()
       return { lean = "jev unsure: fix declare 0.47" }