diff --git a/apps/web/e2e/home.spec.ts b/apps/web/e2e/home.spec.ts
index 0dd7970..793224e 100644
--- a/apps/web/e2e/home.spec.ts
+++ b/apps/web/e2e/home.spec.ts
@@ -1,3 +1,5 @@
+import type { Page } from '@playwright/test';
+
 import { home } from './demo';
 import { expect, test } from './fixtures';
 
@@ -25,6 +27,35 @@ test('the Home leaves out This week when its answer has no week', async ({ page
   await expect(page.locator('main section').last()).toContainText('Your apps');
 });
 
+// The colour --ink-muted gives text in the page's theme.
+function inkMuted(page: Page) {
+  return page.evaluate(() => {
+    const probe = document.body.appendChild(document.createElement('span'));
+    probe.style.color = 'var(--ink-muted)';
+    const { color } = getComputedStyle(probe);
+    probe.remove();
+    return color;
+  });
+}
+
+test("the Home says the hours are unavailable when home couldn't get the week", async ({ page }, testInfo) => {
+  await page.route('/api/home', (route) =>
+    route.fulfill({ json: { ...home, week: undefined, weekState: 'unavailable' } })
+  );
+  await page.goto('/');
+
+  const week = page.locator('main section').last();
+  await expect(week.getByRole('heading', { level: 2 })).toHaveText('This week');
+  await expect(week.getByRole('link', { name: 'Day report' })).toHaveAttribute('href', '/time');
+  // In place of the hours, in their type and muted, without the label or the bar (decision 187).
+  const hours = week.getByText('Hours unavailable');
+  await expect(hours).toHaveCSS('font-size', testInfo.project.name === 'phone' ? '24px' : '28px');
+  await expect(hours).toHaveCSS('font-weight', '500');
+  await expect(hours).toHaveCSS('color', await inkMuted(page));
+  await expect(week.getByText('Logged on Jira')).toHaveCount(0);
+  await expect(week.locator('.track')).toHaveCount(0);
+});
+
 test('without a session, every page shows the Signed out screen', async ({ page }) => {
   await page.route('/api/home', (route) => route.fulfill({ status: 401 }));
   await page.goto('/');
diff --git a/apps/web/src/home/HomePage.svelte b/apps/web/src/home/HomePage.svelte
index 70c1885..c09020b 100644
--- a/apps/web/src/home/HomePage.svelte
+++ b/apps/web/src/home/HomePage.svelte
@@ -5,7 +5,8 @@ import NeedsYou from './NeedsYou.svelte';
 import ThisWeek from './ThisWeek.svelte';
 import YourApps from './YourApps.svelte';
 
-// Until the Home first loads, only the greeting and the apps show; the week, only when the Home has one.
+// Until the Home first loads, only the greeting and the apps show; the week, when the Home has one, and its
+// head with "Hours unavailable" when home couldn't get it from the time service (decision 187).
 let { now, home }: { now: Date; home?: Home } = $props();
 </script>
 
@@ -16,4 +17,6 @@ let { now, home }: { now: Date; home?: Home } = $props();
 <YourApps items={home?.items} />
 {#if home?.week}
   <ThisWeek week={home.week} />
+{:else if home?.weekState === 'unavailable'}
+  <ThisWeek />
 {/if}
diff --git a/apps/web/src/home/HomePage.test.ts b/apps/web/src/home/HomePage.test.ts
index 7031b10..26a7a2c 100644
--- a/apps/web/src/home/HomePage.test.ts
+++ b/apps/web/src/home/HomePage.test.ts
@@ -14,6 +14,9 @@ const withoutWeek: Home = {
 
 const withWeek: Home = { ...withoutWeek, week: { loggedHours: 31.5, targetHours: 40 } };
 
+// home asked the time service for the week, and couldn't get it.
+const unavailable: Home = { ...withoutWeek, weekState: 'unavailable' };
+
 // The week's head, its link and its hours; null for each that doesn't show.
 function weekParts(): (HTMLElement | null)[] {
   return [
@@ -74,3 +77,52 @@ test('shows no week before the Home first loads', () => {
   expect(weekParts()).toEqual([null, null, null]);
   expect(screen.getByRole('heading', { level: 2, name: 'Your apps' })).toBeInTheDocument();
 });
+
+test("says the hours are unavailable when home couldn't get the week, under its head and link, after the apps", () => {
+  render(HomePage, { props: { now, home: unavailable } });
+
+  const [head, link, hours] = weekParts();
+  expect(head).toBeInTheDocument();
+  expect(link).toHaveAttribute('href', '/time');
+  expect(hours).toBeNull();
+  expect(screen.getByText('Hours unavailable')).toBeInTheDocument();
+  const heads = screen.getAllByRole('heading', { level: 2 }).map((heading) => heading.textContent);
+  expect(heads).toEqual(['Needs you today', 'Your apps', 'This week']);
+});
+
+test('shows the week when the Home has one, whatever its state says', () => {
+  render(HomePage, { props: { now, home: { ...withWeek, weekState: 'unavailable' } } });
+
+  expect(weekParts()).not.toContain(null);
+  expect(screen.queryByText('Hours unavailable')).not.toBeInTheDocument();
+});
+
+test('leaves out the week when the time service had none to give, as without Jira', () => {
+  render(HomePage, { props: { now, home: { ...withoutWeek, weekState: 'ok' } } });
+
+  expect(weekParts()).toEqual([null, null, null]);
+  expect(screen.queryByText('Hours unavailable')).not.toBeInTheDocument();
+});
+
+test('follows each later Home: from the hours to unavailable, to no week, and back', async () => {
+  const { rerender } = render(HomePage, { props: { now, home: withWeek } });
+
+  await rerender({ home: unavailable });
+
+  expect(screen.getByText('Hours unavailable')).toBeInTheDocument();
+  expect(screen.queryByText('31h 30m / 40h')).not.toBeInTheDocument();
+
+  await rerender({ home: withoutWeek });
+
+  expect(weekParts()).toEqual([null, null, null]);
+  expect(screen.queryByText('Hours unavailable')).not.toBeInTheDocument();
+
+  await rerender({ home: unavailable });
+
+  expect(screen.getByText('Hours unavailable')).toBeInTheDocument();
+
+  await rerender({ home: withWeek });
+
+  expect(weekParts()).not.toContain(null);
+  expect(screen.queryByText('Hours unavailable')).not.toBeInTheDocument();
+});
diff --git a/apps/web/src/home/ThisWeek.svelte b/apps/web/src/home/ThisWeek.svelte
index 2013b1b..ab919c4 100644
--- a/apps/web/src/home/ThisWeek.svelte
+++ b/apps/web/src/home/ThisWeek.svelte
@@ -4,7 +4,7 @@ import Section from '../shell/Section.svelte';
 import WeekCard from '../time/WeekCard.svelte';
 import type { Week } from '../time/week';
 
-let { week }: { week: Week } = $props();
+let { week }: { week?: Week } = $props();
 </script>
 
 <Section title="This" accent="week" link={{ href: appHref('time'), label: 'Day report' }}>
diff --git a/apps/web/src/home/ThisWeek.test.ts b/apps/web/src/home/ThisWeek.test.ts
index ba3ffd2..541dce7 100644
--- a/apps/web/src/home/ThisWeek.test.ts
+++ b/apps/web/src/home/ThisWeek.test.ts
@@ -10,3 +10,11 @@ test("shows the week's card under its head, which links to the day report", () =
   expect(screen.getByRole('link', { name: 'Day report' })).toHaveAttribute('href', '/time');
   expect(screen.getByText('30h / 40h')).toBeInTheDocument();
 });
+
+test('without a week, keeps its head and link, and its card says the hours are unavailable', () => {
+  render(ThisWeek);
+
+  expect(screen.getByRole('heading', { level: 2, name: 'This week' })).toBeInTheDocument();
+  expect(screen.getByRole('link', { name: 'Day report' })).toHaveAttribute('href', '/time');
+  expect(screen.getByText('Hours unavailable')).toBeInTheDocument();
+});
diff --git a/apps/web/src/home/api.ts b/apps/web/src/home/api.ts
index 8364c55..ff442eb 100644
--- a/apps/web/src/home/api.ts
+++ b/apps/web/src/home/api.ts
@@ -18,9 +18,12 @@ export interface Item {
   late: boolean;
 }
 
+/** How home's asking went: the peer answered, or it failed or didn't answer in time. */
+type State = 'ok' | 'unavailable';
+
 /** How asking one of home's sources went, with only the field the app reads so far. */
 interface SourceStatus {
-  state: 'ok' | 'unavailable';
+  state: State;
 }
 
 /** The Home screen's data from GET /api/home, with only the fields the app reads so far. */
@@ -29,8 +32,10 @@ export interface Home {
   items: Item[];
   /** One per source home asks; absent from the answer of a home older than the field. */
   sources?: SourceStatus[];
-  /** Absent when home has no week, such as before the time service logs hours. */
+  /** Absent when home has no week: the time service has none, as without Jira, couldn't give one, or isn't there. */
   week?: Week;
+  /** How asking the time service for the week went; absent without one to ask, or from a home older than the field. */
+  weekState?: State;
 }
 
 /** The error fetchHome fails with when the gateway answers 401: the user has no session. */
diff --git a/apps/web/src/time/WeekCard.svelte b/apps/web/src/time/WeekCard.svelte
index 6f0e122..f6f64dc 100644
--- a/apps/web/src/time/WeekCard.svelte
+++ b/apps/web/src/time/WeekCard.svelte
@@ -1,18 +1,24 @@
 <script lang="ts">
 import { hoursLabel, type Week, weekPercent } from './week';
 
-let { week }: { week: Week } = $props();
+// Without a week, the card says the hours are unavailable in their place, with no label or bar: an empty bar
+// would read as nothing logged (decision 187).
+let { week }: { week?: Week } = $props();
 </script>
 
 <div class="card">
-  <p class="hours">
-    <span class="value">{hoursLabel(week)}</span>
-    <span class="unit">Logged on Jira</span>
-  </p>
-  <!-- The hours above say the same in words. The % sits inside the braces, so Svelte adds no `?? ''` fallback. -->
-  <div class="track" aria-hidden="true">
-    <div class="fill" style:width={`${weekPercent(week)}%`}></div>
-  </div>
+  {#if week}
+    <p class="hours">
+      <span class="value">{hoursLabel(week)}</span>
+      <span class="unit">Logged on Jira</span>
+    </p>
+    <!-- The hours above say the same in words. The % sits inside the braces, so Svelte adds no `?? ''` fallback. -->
+    <div class="track" aria-hidden="true">
+      <div class="fill" style:width={`${weekPercent(week)}%`}></div>
+    </div>
+  {:else}
+    <p class="hours"><span class="value unavailable">Hours unavailable</span></p>
+  {/if}
 </div>
 
 <style>
@@ -38,6 +44,10 @@ let { week }: { week: Week } = $props();
   line-height: 1.2;
 }
 
+.unavailable {
+  color: var(--ink-muted);
+}
+
 .unit {
   color: var(--ink-muted);
   font: 400 11px / 1.6 var(--font-mono);
diff --git a/apps/web/src/time/WeekCard.test.ts b/apps/web/src/time/WeekCard.test.ts
index 8a6ad1f..e9303ef 100644
--- a/apps/web/src/time/WeekCard.test.ts
+++ b/apps/web/src/time/WeekCard.test.ts
@@ -11,3 +11,11 @@ test('shows the hours logged against the target, and fills the bar as far', () =
   expect(container.querySelector('.track')).toHaveAttribute('aria-hidden', 'true');
   expect(container.querySelector('.fill')).toHaveStyle({ width: '75%' });
 });
+
+test('without a week, says the hours are unavailable in their place, with no label or bar', () => {
+  const { container } = render(WeekCard);
+
+  expect(screen.getByText('Hours unavailable')).toBeInTheDocument();
+  expect(screen.queryByText('Logged on Jira')).not.toBeInTheDocument();
+  expect(container.querySelector('.track')).not.toBeInTheDocument();
+});
diff --git a/docs/plan.md b/docs/plan.md
index 57c8fc3..abdf6c0 100644
--- a/docs/plan.md
+++ b/docs/plan.md
@@ -169,6 +169,7 @@ The v1.2 design in §4 to §6 stays as reference. A piece of it is built only wh
 | `time-page` | The Time page, at `/time`, shows the time report: this week's hours against the target on the Home's week card, then the last 7 days, a row each with the date, the weekday or "Today" and the hours logged, a Missing chip on each weekday before today without hours, and the missing days' count as the section's note. It loads the report each time it shows, says why the last search failed and when its hours are from, and says when Jira isn't set up or the report couldn't load. The eighth of `time-tracking`'s thirteen steps (decision 184) | Done (#153) |
 | `time-week` | The second contract between services, `bakhyard.time.v1`, whose `TimeService.GetWeek` answers this week's hours against the week's target, for the Home's "This week". The time service answers it from the latest read of my worklogs to succeed: with no week when Jira isn't set up, and with `UNAVAILABLE` while no read has succeeded. The ninth of `time-tracking`'s thirteen steps (decision 185) | Done (#154) |
 | `home-time-week` | The Home's "This week" shows my real week: home asks the time service for it over the time contract, at the same time as it asks its peers for their items and with the same 1.5 s, and answers it as the Home's `week`, beside a new `weekState` that says how asking went, `ok` or `unavailable`. A week that time couldn't give still leaves "This week" out, until `week-unavailable` shows "Hours unavailable". The tenth of `time-tracking`'s fourteen steps (decision 186) | Done (#155) |
+| `week-unavailable` | The Home's "This week" says "Hours unavailable" when home couldn't get the week from the time service, its `weekState` being `unavailable`: the head and its "Day report" link stay, and the card says so in place of the hours, in their type and in `--ink-muted`, without the "Logged on Jira" label and the bar. With `ok` and no week, as without Jira, or with neither member, the section stays out (decision 161). The eleventh of `time-tracking`'s fourteen steps (decision 187) | Done (#156) |
 | `nudge-merge` | Nudge, the user's phone-questions tool for agents (`codedogapp/nudge`), moves into Bakhyard: one app, not two (decision 157). The nudge session does the work, one small PR per step, from its plan, [`bakhyard-merge.md`](https://github.com/codedogapp/nudge/blob/main/docs/bakhyard-merge.md); this session doesn't stop its own steps for it | In review |
 
 After these: the product phases (§8.2), each split into steps.
@@ -589,7 +590,7 @@ process-compose runs the services on the Mac only, for development; the laptop r
   - Any other failure marks the source `UNAVAILABLE` with a message, is logged, and the rest still renders. Never a blank screen.
 - Item ids are `<app>/<id>`; `late = due is set && due < now`.
 - Sort order (`cmp.Or`): late first, then earliest due (no due date last), then title, then id.
-- The week comes from `TimeService.GetWeek` on peer `time` (decision 186). It's unset when time has no week, as without Jira; when time fails, doesn't answer in 1.5 s, or answers hours that aren't finite, which JSON can't encode, each logged as `get the week` unless the request has ended; and when home has no peer named `time`. `weekState` tells the first, `ok`, from the second, `unavailable`, and is left out in the third. Without a week, the Home leaves out "This week" (decision 161).
+- The week comes from `TimeService.GetWeek` on peer `time` (decision 186). It's unset when time has no week, as without Jira; when time fails, doesn't answer in 1.5 s, or answers hours that aren't finite, which JSON can't encode, each logged as `get the week` unless the request has ended; and when home has no peer named `time`. `weekState` tells the first, `ok`, from the second, `unavailable`, and is left out in the third. Without a week, the Home leaves out "This week" (decision 161), unless `weekState` is `unavailable`: then the section stays, and its card says "Hours unavailable" (decision 187).
 - The name comes from `BAKHYARD_NAME`, without surrounding whitespace and with invalid UTF-8 replaced by U+FFFD; unset or blank, it falls back to "there". A name is personal, so it's set in the shell or in the gitignored `mise.local.toml` (`[env]`), never in git.
 - `WatchHome` sends immediately, again after each `bakhyard.attention.changed.*` event (250 ms debounce), and every 60 s.
 
@@ -998,8 +999,8 @@ Cards are solid `--surface`, so they sit on the grain like paper on a desk. Thes
 
 **"This week"**: the section head's text link, "Day report", goes to the Time page. Below it, a card holds the hours logged against the target as a big number, "31h 30m / 40h" (decision 51), with a mono "Logged on Jira" label beside it, which wraps under it when it doesn't fit. 16 px below them is a bar 8 px tall with square ends: an `--ink` fill on an `--fill` track, filled to the share of the target logged, full once the target is met and empty without a target. The bar is hidden from screen readers, since the hours say the same.
 
-- Until the first load succeeds there is no week; offline, the last week stays.
-- Without a week, as until the time service exists (§4.11), the Home leaves out "This week" whole, its head, its link and its card, and ends with "Your apps" (decision 161). Once the time service exists, a week missing because it's down will have the card say "Hours unavailable" in `--ink-muted` instead; that state comes with the time service, when home can tell the app which of the two it is.
+- Until the first load succeeds there is no week; offline, the last week stays, or the last "Hours unavailable".
+- Without a week, as without Jira or without a time service to ask (§4.11), the Home leaves out "This week" whole, its head, its link and its card, and ends with "Your apps" (decision 161). When home couldn't get the week from the time service, its `weekState` being `unavailable` (§4.11), the section keeps its head and its link, and the card says "Hours unavailable" in place of the hours, in their type and in `--ink-muted`, with no label and no bar, since an empty bar would read as nothing logged (decision 187). Each later Home decides afresh, so the hours come back with the next week home gets.
 
 **Button**: mono 12 px with padding 14 by 22 px (ref), at least 44 px tall, and a 1 px `--ink` border. Primary: an ink fill with `--paper` text, inverted on hover. Secondary: `--surface` with `--ink` text, `--fill` on hover.
 
@@ -1200,7 +1201,7 @@ Every item is pending unless it says done. The service an item lands in is in br
   - `pulls-reminders`: at 10:00 and 15:00 on weekdays, pulls pushes one reminder that lists my PRs under their required approvals (decision 177). Done (#144).
   - `homelab-pulls-notify`: done (codedogapp/homelab#40). In the homelab repo, pulls' `BAKHYARD_PEERS` names notify, `TZ` gives it the user's zone, and a NetworkPolicy lets pulls reach notify.
   - Later, with a database for pulls: snooze (2 h / tomorrow / until updated) and mark as nudged, from the PRs page.
-- `time-tracking` [time]. Needs `todos-jira`. Reads and writes standard Jira worklogs (§2, decision 46), with no timers: Clockwork already has them inside Jira. Fourteen steps (decisions 180, 181, 183 and 186):
+- `time-tracking` [time]. Needs `todos-jira`. Reads and writes standard Jira worklogs (§2, decision 46), with no timers: Clockwork already has them inside Jira. Fourteen steps (decisions 180, 181, 183, 186 and 187):
   - `shared-jira`: todos' Jira client moves to the root `internal/jira`, with the code that reads its settings and token, for the `time` service; todos' poller of my tickets moves to a package of its own, `tickets`. Nothing changes in behaviour. Done (#147).
   - `jira-worklogs`: the client reads my worklogs in a span of days: my account from `/myself`, the tickets I logged on from a `worklogAuthor` search, and each ticket's worklogs. Done (#148).
   - `time-report`: a package of the `time` service, `report`, works out the time report from my worklogs: the hours I logged on each of the last 7 days, with every weekday before today that has none marked as missing, plus this week's total against the target. Done (#149).
@@ -1211,7 +1212,7 @@ Every item is pending unless it says done. The service an item lands in is in br
   - `time-page`: the Time page shows the time report: this week's card, then the last 7 days with the missing ones marked (decision 184). Done (#153).
   - `time-week`: `time` answers `TimeService/GetWeek` (§4.5) with this week's hours against the target, from the latest read of the worklogs to succeed: no week when Jira isn't set up, and `UNAVAILABLE` until a read succeeds (decision 185). Done (#154).
   - `home-time-week`: home asks `time` for the week, and answers it with how asking went, `weekState`, so the Home's "This week" shows my real week (decision 186). Done (#155).
-  - `week-unavailable`: the Home's "This week" says "Hours unavailable" when home couldn't get the week from `time` (§7).
+  - `week-unavailable`: the Home's "This week" says "Hours unavailable" when home couldn't get the week from `time` (§7, decision 187). Done (#156).
   - `time-attention`: `time` answers the attention contract with today's hours until they're logged, and each missing weekday.
   - `worklog-add`: the client adds a worklog, and `time` takes one at `POST /time/worklogs`.
   - `fill-day`: the Time page fills a missing day: pick one of my open tickets (assigned to me, not done) and the hours; Bakhyard shows the worklog it will add, starting at 09:00 local time, and writes it only after I confirm.
@@ -1586,6 +1587,13 @@ Made on 2026-10-23:
      - **Any failure is unavailable**, `Unimplemented` included: a time service that doesn't answer the time contract doesn't work, whereas a peer without the attention contract has no items to list (decision 167).
      - **Code**: a new package, `services/home/internal/week` (`Asker`, `New`, `Ask`), beside `feed`; `api.Register` takes both asks in an `api.Peers`, since a fifth parameter would break the four-parameter gate.
      - **Rejected**: the state inside `week`, which an app still in a phone's cache would read as a week without hours; a `null` week for "unavailable", which the app reads as no week; a `weekUnavailable` boolean, where a state has a type of its own, as the sources' does; counting the week in `sources`, or in the top bar's count of missing items; asking for the week after the items, which would make the worst wait 3 s; a setting of its own for time's address.
+187. **"Hours unavailable"** (`week-unavailable`): the lead's choices (2026-10-29), for the user to review. The app reads the Home's `weekState` (decision 186), so a week that home couldn't get from the time service no longer looks like Jira isn't set up.
+     - **When it shows**: "This week" shows when the Home has a week, as before, and now also when its `weekState` is `unavailable`. With `ok` and no week, as without Jira, or with neither member, as from a home without a time peer or one older than the field, it stays out (decision 161). A week wins over the state: home never sends both, and the hours are what the card is for.
+     - **The head**: unchanged, "This *week*" with its "Day report" link to the Time page, which says why when its report fails (decision 184).
+     - **The card**: the week card's box, with "Hours unavailable" in place of the hours, in their type (28 px, 24 px on phones, weight 500) and in `--ink-muted`, as a zero count on the apps' cards is muted (§7). No "Logged on Jira" label, since nothing logged is shown, and no bar, since an empty bar reads as nothing logged, the reason decision 185 rejected a zero week. The card is shorter by the bar and its gap.
+     - **Changes**: each later Home decides afresh: the hours, "Hours unavailable", or no section. Offline, the last Home's state stays, as its week does. Nothing is announced when it changes, as nothing is when the hours change.
+     - **Code**: `WeekCard`'s `week` becomes optional, and without one the card says "Hours unavailable"; `ThisWeek` passes it on, and `HomePage` gives it the week or, when the state is `unavailable`, none. The Time page shows the card only with a week, so it doesn't change. `home/api.ts` names the state type, `State`, shared by the sources and `weekState`.
+     - **Rejected**: leaving the section out, as before, which reads as Jira not set up; a sentence in body text, such as "Couldn't load this week's hours.", which reads as the page failing and breaks the card's rhythm; keeping the label, "Hours unavailable · Logged on Jira", which contradicts itself; an empty or striped bar; an "Unavailable" chip; a card of the Home's own beside `WeekCard`, which would copy the card's style a fourteenth time (§0's ideas); an `unavailable` prop on `WeekCard` beside `week`, two props that could disagree.
 
 ## 10. Risks