diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
index 8c9271f..689d499 100644
--- a/.claude-plugin/plugin.json
+++ b/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "hermes-helmet",
   "displayName": "Hermes Helmet",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "First-officer skills for Hermes Helmet: setup, single-issue delivery, and dependent-issue coordination.",
   "author": {
     "name": "Machine Wisdom",
diff --git a/.codex-plugin/plugin.json b/.codex-plugin/plugin.json
index 81ca114..74ac5e7 100644
--- a/.codex-plugin/plugin.json
+++ b/.codex-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "hermes-helmet",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "First-officer skills for Hermes Helmet: setup, single-issue delivery, and dependent-issue coordination.",
   "author": {
     "name": "Machine Wisdom",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b2e951..53c6426 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,20 @@ All notable changes to Hermes Helmet are recorded here. The project follows
 
 ## Unreleased
 
+### 0.6.0
+
+- Captain’s Bridge can prepare an updated walkthrough in the background. The
+  panel captures the originating chat and a verifiable snapshot (delivery is
+  rejected if captured records changed or digests are inconsistent), asks the first
+  officer to dispatch one bounded read-only agent without waiting, and keeps the
+  current walkthrough visible. A timeout asks the first officer to stop the agent
+  and reports the stop as requested, not confirmed. Cancel, supersession, timeout, failure, duplicate
+  submission and late completion preserve the last useful view. Verified with
+  synthetic protocol and panel tests only; acceptance in an installed Codex host
+  is recorded separately in the pull request. Measured Codex limit: after the
+  parent turn finishes, a delivery reaches the server but the originating panel does
+  not render it, so the panel now says so instead of implying background success.
+
 ### 0.5.0
 
 - Captain’s Bridge Refresh records now rereads the exact bound chat directly
diff --git a/docs/first-officer-plugins.md b/docs/first-officer-plugins.md
index ff2f441..05fb721 100644
--- a/docs/first-officer-plugins.md
+++ b/docs/first-officer-plugins.md
@@ -29,8 +29,9 @@ path. Do not delete unrelated host skills. Canonical behavior stays in
 The Codex plugin also carries Captain’s Bridge: a read-only panel that
 explains one recorded piece of work in the invoking chat and opens its
 supporting records. It is Codex-only and starts no second server beyond the
-plugin's own MCP server. Background preparation and cancellation are not part of
-this release. See the
+plugin's own MCP server. From an open Bridge, “Update walkthrough” can ask the
+first officer to start one read-only background preparation, cancellable from the
+panel; see the lifecycle in the Bridge guide. See the
 [source and test guide](../mcp/captains-bridge/README.md). The Claude Code port
 is tracked in
 [issue #55](https://github.com/MachineWisdomAI/hermes-helmet/issues/55); the
diff --git a/mcp/captains-bridge/README.md b/mcp/captains-bridge/README.md
index e75299c..a069a8e 100644
--- a/mcp/captains-bridge/README.md
+++ b/mcp/captains-bridge/README.md
@@ -31,12 +31,71 @@ not load it.
   background work or project task), keeps the explanation with its original
   read time and flags it as older when the fingerprint changed. Failures,
   foreign or out-of-order responses and a partially written final record keep
-  the last view and report the limit. “Update walkthrough”
-  sends a request to the first officer. Delegated background preparation and
-  cancellation are not implemented.
+  the last view and report the limit. “Update walkthrough” rereads only; see
+  Background preparation below.
 - Show Me and Retro request separately installed skills and report if they are
   unavailable.
 
+## Background preparation lifecycle
+
+“Update walkthrough” (and its stale notice) runs this lifecycle. Opening the
+Bridge never starts it.
+
+1. Capture: the panel calls `request_walkthrough_update` with its portable view.
+   The server rereads that exact chat and returns a request: a random
+   `requestId`, the `threadId`, and a snapshot (source fingerprint, read time,
+   record count). No server-side state is kept, so nothing is process-local.
+2. Dispatch: the panel sends one `ui/message` asking the first officer to start
+   exactly one read-only subagent, not wait or poll, and not pause project work.
+   The subagent reads only `threadId` with `read_chat_work`, never its own chat.
+   It must not run project tasks or repair the viewer.
+3. Deliver: the subagent calls `deliver_walkthrough_update` once with the request
+   unchanged, or with `failure`. Citations are validated against the snapshot’s
+   records only; the result keeps the snapshot’s fingerprint and read time, so a
+   later chat change marks it older instead of fresh. The snapshot also carries a
+   digest of the exact captured records and a seal over every snapshot field. On
+   delivery the server rereads the chat and rejects the request if a captured
+   record has changed, if the digests are inconsistent, or if the chat names no
+   valid chat; records appended later are allowed and only mark the result older.
+   The seal is a consistency check, not authentication: the server keeps no
+   secret or state, so it does not stop a caller who can read the chat from
+   building a consistent snapshot. It also does not preserve the captured text;
+   it detects that the text changed.
+4. Settle: the panel owns the single active request. It accepts a delivery only
+   when `requestId` matches and the request is still active, and ignores every
+   other result. Delivery, failure, cancel, supersession or the 10-minute timeout
+   end the request; each preserves the last useful view, and a second delivery
+   for a settled request is dropped. The panel never retries.
+5. Cancel: “Cancel update” ends the request at once and asks the first officer to
+   interrupt the subagent. If the host cannot be told, the panel says so and still
+   discards any later result. The 10-minute timeout does the same: it invalidates
+   the request at once, then asks the first officer to interrupt the subagent. The
+   panel says the stop was requested, not confirmed, and says so plainly if the
+   host could not be told. Each async effect (acknowledgement failure, timeout
+   handoff) applies only to the request that owns it, so a late failure of a
+   cancelled request never clears a newer one. A substantive new instruction from the Captain
+   supersedes the request the same way unless the Captain says to keep it.
+
+Measured host limit (installed Codex, parent turn already finished): the preparation
+agent read the originating chat and `deliver_walkthrough_update` returned a validated
+walkthrough with the captured fingerprint, read time and request identity, so delivery
+to the server worked. The originating panel did not render it: it kept the old
+explanation and its progress notice until its own 10-minute timeout, and interrupting
+the agent reported it had already completed. This server keeps no state and cannot push
+to a panel, so rendering in the original panel after the parent finishes is unsupported
+by the host seam as measured; no background rendering is claimed. The panel therefore
+says a result may not be shown if the chat turn has finished, offers Cancel to stop
+waiting, and on timeout says a finished agent's result reached the server but cannot be
+shown. A failure result is subject to the same boundary. Foreground delivery while the
+parent turn is still active is unchanged. No second queue or observer was added.
+
+Unsupported boundaries, reported rather than hidden: the server cannot itself stop
+a subagent or know the Captain issued a new instruction; the first officer does
+both from the messages above. Whether a delivery reaches the panel when the parent
+turn has already finished, and whether work continues during preparation, depend
+on Codex host behavior that synthetic tests cannot establish; they require the
+installed-host acceptance recorded in the pull request.
+
 ## Checks
 
 Python 3.11 or newer and Node.js. The tests use synthetic records only and do
@@ -47,6 +106,7 @@ python3 -B -m unittest discover -s . -p 'test_*.py' -v
 node test_view.cjs
 node test_delivery.cjs
 node test_actions.cjs
+node test_preparation.cjs
 ```
 
 `scripts/verify.sh` runs these. Protocol and fixture checks do not establish
diff --git a/mcp/captains-bridge/preparation.py b/mcp/captains-bridge/preparation.py
new file mode 100644
index 0000000..4e3f958
--- /dev/null
+++ b/mcp/captains-bridge/preparation.py
@@ -0,0 +1,98 @@
+"""Background walkthrough preparation: portable request identity and settlement.
+
+The server keeps no request state. The panel owns the single active request and
+discards any settlement that is not for it, so cancellation, supersession, timeout
+and late completion need no cross-process coordination. Nothing is written.
+"""
+import copy
+import hashlib
+import json
+import re
+import secrets
+from walkthrough import fingerprint, validate
+
+OUTCOMES = ('delivered', 'failed', 'cancelled', 'superseded')
+CHAT = re.compile(r'[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+
+
+def records_digest(records):
+    """Digest of the exact captured records, in order."""
+    return hashlib.sha256(json.dumps(records, sort_keys=True).encode()).hexdigest()
+
+
+def seal(request_id, thread_id, snapshot):
+    """Bind every snapshot field so an edited or inconsistent field is detectable.
+
+    This is a consistency check, not authentication: the server keeps no secret
+    and no state, so it detects corruption and inconsistency, not a deliberate
+    forger who can read the chat. The captured records are verified separately.
+    """
+    fields = [request_id, thread_id, snapshot['fingerprint'], snapshot['readAt'],
+              snapshot['recordCount'], snapshot['evidence']]
+    return hashlib.sha256(json.dumps(fields).encode()).hexdigest()
+
+
+def new_request(thread_id, data):
+    """Capture the originating chat and a verifiable snapshot of what was read."""
+    request_id = secrets.token_urlsafe(18)
+    snapshot = {'fingerprint': fingerprint(data), 'readAt': data['readAt'],
+                'recordCount': len(data['records']), 'evidence': records_digest(data['records'])}
+    snapshot['seal'] = seal(request_id, thread_id, snapshot)
+    return {'requestId': request_id, 'threadId': thread_id, 'snapshot': snapshot}
+
+
+def check_request(request):
+    """Return a normalized copy of an untrusted request, or raise ValueError."""
+    if not isinstance(request, dict):
+        raise ValueError('The walkthrough request is missing.')
+    snapshot = request.get('snapshot')
+    request_id, thread_id = request.get('requestId'), request.get('threadId')
+    if not isinstance(request_id, str) or not re.fullmatch(r'[A-Za-z0-9_-]{16,64}', request_id):
+        raise ValueError('The walkthrough request has no valid identity.')
+    if not isinstance(thread_id, str) or not CHAT.fullmatch(thread_id):
+        raise ValueError('The walkthrough request has no valid originating chat.')
+    if not isinstance(snapshot, dict):
+        raise ValueError('The walkthrough request has no preparation snapshot.')
+    digest, read_at, count = snapshot.get('fingerprint'), snapshot.get('readAt'), snapshot.get('recordCount')
+    evidence, sealed = snapshot.get('evidence'), snapshot.get('seal')
+    if (not all(isinstance(h, str) and re.fullmatch(r'[0-9a-f]{64}', h) for h in (digest, evidence, sealed))
+            or not isinstance(read_at, str) or not 0 < len(read_at) <= 80
+            or not isinstance(count, int) or isinstance(count, bool) or count < 1):
+        raise ValueError('The walkthrough request snapshot is invalid.')
+    clean = {'fingerprint': digest, 'readAt': read_at, 'recordCount': count, 'evidence': evidence}
+    if not secrets.compare_digest(sealed, seal(request_id, thread_id, clean)):
+        raise ValueError('The walkthrough request snapshot is inconsistent. Request a new update.')
+    clean['seal'] = sealed
+    return {'requestId': request_id, 'threadId': thread_id, 'snapshot': clean}
+
+
+def prepared_walkthrough(request, walkthrough, data):
+    """Validate a delivered explanation against its snapshot, not the current read.
+
+    Citations must belong to the records that existed at snapshot time. The result
+    keeps the snapshot's fingerprint and read time, so records read later flag it
+    as older instead of presenting it as freshly interpreted.
+    """
+    snapshot = request['snapshot']
+    if len(data['records']) < snapshot['recordCount']:
+        raise ValueError('The chat has fewer records than the preparation snapshot. Request a new update.')
+    captured = data['records'][:snapshot['recordCount']]
+    if not secrets.compare_digest(records_digest(captured), snapshot['evidence']):
+        raise ValueError('The captured records have changed since the preparation snapshot. Request a new update.')
+    if len(data['records']) == snapshot['recordCount'] and fingerprint(data) != snapshot['fingerprint']:
+        raise ValueError('The snapshot fingerprint does not match the captured chat. Request a new update.')
+    bounded = dict(data, records=captured)
+    checked = validate(copy.deepcopy(walkthrough), bounded)
+    checked.update(fingerprint=snapshot['fingerprint'], explainedAt=snapshot['readAt'])
+    return checked
+
+
+def settlement(request, outcome, message=None):
+    if outcome not in OUTCOMES:
+        raise ValueError('Unknown settlement outcome.')
+    value = {'requestId': request['requestId'], 'outcome': outcome}
+    if message is not None:
+        if not isinstance(message, str) or len(message) > 500:
+            raise ValueError('A settlement message must be text, at most 500 characters.')
+        value['message'] = message
+    return value
diff --git a/mcp/captains-bridge/server.py b/mcp/captains-bridge/server.py
index 031c890..d943321 100644
--- a/mcp/captains-bridge/server.py
+++ b/mcp/captains-bridge/server.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 from chat_reader import read_chat
 from walkthrough import validate, fingerprint
+from preparation import new_request, check_request, prepared_walkthrough, settlement
 
 ROOT = Path(__file__).resolve().parent
 URI = 'ui://hermes-helmet/captains-bridge-v1'
@@ -42,6 +43,16 @@ def tool(name, title, description, properties, required=(), app=False, entry=Fal
 VIEW['_meta'] = {'ui': {'visibility': ['app']}}
 
 
+REQUEST = tool('request_walkthrough_update', 'Capture walkthrough request',
+               'Read the exact chat in the portable view and capture an immutable preparation snapshot and request identity. Starts no work.',
+               {'view': {'type': 'object'}}, ('view',))
+REQUEST['_meta'] = {'ui': {'visibility': ['app']}}
+DELIVER = tool('deliver_walkthrough_update', 'Deliver prepared walkthrough',
+               'For a read-only preparation agent: deliver the explanation for one captured request, or report failure. Pass the request unchanged. Cites record IDs from the request chat only. Delivery is discarded by the panel unless the request is still active. Never retry.',
+               {'request': {'type': 'object'}, 'walkthrough': {'type': 'object'},
+                'failure': {'type': 'string', 'maxLength': 500}}, ('request',), app=True)
+
+
 def bind(thread_id):
     data = read_chat(thread_id)
     key = secrets.token_urlsafe(24)
@@ -93,13 +104,38 @@ def read_view(view):
     return {'thread_id': view['threadId'], 'data': data, 'walkthrough': account}
 
 
+def capture_request(view):
+    state = read_view(view)
+    request = new_request(state['thread_id'], state['data'])
+    text = 'Captured walkthrough request ' + request['requestId'] + '. No work was started.'
+    return {'content': [{'type': 'text', 'text': text}], 'structuredContent': {'request': request}}
+
+
+def deliver(args):
+    request = check_request(args.get('request'))
+    failure = args.get('failure')
+    if failure is not None or args.get('walkthrough') is None:
+        note = failure if isinstance(failure, str) and failure.strip() else 'The preparation agent returned no explanation.'
+        outcome = settlement(request, 'failed', note[:500])
+        return {'content': [{'type': 'text', 'text': 'Reported failure for request ' + request['requestId'] + '.'}],
+                'structuredContent': {'preparation': outcome}}
+    # The reader opens only the request's own chat; the child never picks one.
+    data = read_chat(request['threadId'])
+    account = prepared_walkthrough(request, args['walkthrough'], data)
+    state = {'thread_id': request['threadId'], 'data': data, 'walkthrough': account}
+    result = present(None, state)
+    result['structuredContent']['preparation'] = settlement(request, 'delivered')
+    result['_meta']['preparation'] = result['structuredContent']['preparation']
+    return result
+
+
 def handle(method, params):
     if method == 'initialize':
         return {'protocolVersion': params.get('protocolVersion', '2025-06-18'), 'capabilities': {'tools': {}, 'resources': {}}, 'serverInfo': {'name': 'hermes-helmet-captains-bridge', 'version': VERSION}}
     if method == 'ping':
         return {}
     if method == 'tools/list':
-        return {'tools': [OPEN, READ, PRESENT, REFRESH, VIEW]}
+        return {'tools': [OPEN, READ, PRESENT, REFRESH, VIEW, REQUEST, DELIVER]}
     if method == 'resources/list':
         return {'resources': [{'uri': URI, 'name': 'Captain’s Bridge', 'mimeType': 'text/html;profile=mcp-app'}]}
     if method == 'resources/templates/list':
@@ -109,6 +145,10 @@ def handle(method, params):
     if method != 'tools/call':
         raise ValueError('Unknown method or resource')
     args, name = params.get('arguments') or {}, params.get('name')
+    if name == REQUEST['name']:
+        return capture_request(args.get('view'))
+    if name == DELIVER['name']:
+        return deliver(args)
     if name in (VIEW['name'], REFRESH['name']):
         return present(None, read_view(args.get('view')), for_app=True)
     if name in (OPEN['name'], READ['name']) and args.get('thread_id'):
diff --git a/mcp/captains-bridge/test_preparation.cjs b/mcp/captains-bridge/test_preparation.cjs
new file mode 100644
index 0000000..bb0f3f1
--- /dev/null
+++ b/mcp/captains-bridge/test_preparation.cjs
@@ -0,0 +1,154 @@
+const fs=require('fs'),vm=require('vm'),assert=require('node:assert/strict');
+class Element{
+  constructor(tag){this.tagName=tag;this.children=[];this.textContent='';this.hidden=false;this.disabled=false;this.style={setProperty(){}}}
+  append(c){this.children.push(c)} prepend(c){this.children.unshift(c)} replaceChildren(...c){this.children=c} focus(){}
+}
+const roots=Object.fromEntries(['app','error','connect','connection','request-status'].map(k=>[k,new Element(k)]));
+const document={getElementById:id=>roots[id],createElement:t=>new Element(t),documentElement:new Element('html')};
+let listener;const sent=[];const timers=[];
+const parent={postMessage(m){if(m.method)sent.push(m)}};
+const context=vm.createContext({document,parent,window:{scrollY:0,scrollTo(){}},
+  setTimeout:(fn,ms)=>{timers.push({fn,ms});return timers.length},clearTimeout:id=>{if(timers[id-1])timers[id-1].fn=null},
+  requestAnimationFrame:f=>f(),addEventListener:(t,fn)=>{if(t==='message')listener=fn},console});
+vm.runInContext(fs.readFileSync('view.html','utf8').match(/<script>([\s\S]*)<\/script>/)[1],context);
+const chat='11111111-1111-4111-8111-111111111111';
+const item=(title)=>({id:'k',title,group:'changed',status:'Recorded',summary:'s',detail:'d',evidence:['r'],steps:[],links:[]});
+const account=(title)=>({objective:'o',summary:'Summary '+title,evidence:['r'],items:[item(title)],explainedAt:'t',fingerprint:'a'.repeat(64)});
+const view={threadId:chat,walkthrough:account('Current')};
+const deckFor=(title)=>({threadId:chat,title:'Chat',turns:[],records:[],readAt:'now',walkthrough:account(title)});
+const run=s=>vm.runInContext(s,context);
+const walk=e=>[e,...e.children.flatMap(walk)];
+const visible=e=>e.textContent+' '+e.children.map(visible).join(' ');
+const button=label=>walk(roots.app).find(e=>e.tagName==='button'&&e.textContent===label);
+const tick=()=>new Promise(r=>setImmediate(r));
+const request=(id)=>({requestId:id,threadId:chat,snapshot:{fingerprint:'b'.repeat(64),readAt:'then',recordCount:3}});
+let capture=0,failCapture=false,failMessages=false,holdAcks=false;const pendingAcks=[];
+const answer=(message,result)=>listener({source:parent,data:{jsonrpc:'2.0',id:message.id,result}});
+const pump=async()=>{ // answer app tool calls and ui/message acknowledgements
+  for(let i=0;i<20;i++){await tick();for(const m of sent.splice(0)){
+    if(m.method==='tools/call'&&m.params.name==='request_walkthrough_update'){
+      capture++;answer(m,failCapture?{isError:true,content:[{type:'text',text:'Capture failed.'}]}:{structuredContent:{request:request('request-identity-'+String(capture).padStart(4,'0'))}})}
+    else if(m.method==='ui/message'){messages.push(m);
+      if(holdAcks)pendingAcks.push(m);
+      else if(failMessages)listener({source:parent,data:{jsonrpc:'2.0',id:m.id,error:{message:'Host refused'}}});
+      else answer(m,{})}
+    else if(m.method==='tools/call')answer(m,{structuredContent:{}})}}};
+const messages=[];
+const deliver=(id,title,outcome='delivered',message)=>listener({source:parent,data:{jsonrpc:'2.0',method:'ui/notifications/tool-result',params:
+  outcome==='delivered'?{structuredContent:{preparation:{requestId:id,outcome},view:{threadId:chat,walkthrough:account(title)}},_meta:{deck:deckFor(title),view:{threadId:chat,walkthrough:account(title)},preparation:{requestId:id,outcome}}}
+  :{structuredContent:{preparation:{requestId:id,outcome,message}}}}});
+process.on('exit',()=>{if(!globalThis.__done){console.error('STALLED at step',globalThis.__step);process.exitCode=1}});
+(async()=>{
+  run('receive({_meta:{deck:'+JSON.stringify(deckFor('Current'))+',view:'+JSON.stringify(view)+'}})');
+  sent.splice(0);
+  assert.equal(sent.length+messages.length,0,'Opening the Bridge must not start work.');
+  assert.match(visible(roots.app),/Current/);
+
+  globalThis.__step='request';
+  // Request, then duplicate submission is ignored.
+  const first=run('explain()');run('explain()');await pump();await first;
+  assert.equal(capture,1,'Duplicate submission must capture one request.');
+  assert.equal(messages.length,1,'One dispatch message per request.');
+  assert.match(messages[0].params.content[0].text,/exactly one read-only subagent/);
+  assert.match(messages[0].params.content[0].text,/Do not wait or poll/);
+  assert.match(messages[0].params.content[0].text,new RegExp(chat));
+  assert.match(visible(roots.app),/in the background/);
+  assert.match(visible(roots.app),/Current/,'The current walkthrough stays visible during preparation.');
+  assert.ok(button('Cancel update'));
+
+  // Delivery for a different request is dropped and does not replace the view.
+  deliver('request-identity-9999','Foreign');await pump();
+  assert.doesNotMatch(visible(roots.app),/Foreign/);
+  assert.match(visible(roots.app),/in the background/,'Another request must not settle the active one.');
+
+  globalThis.__step='cancel';
+  // Cancel invalidates delivery; a late completion preserves the last useful view.
+  const cancelled=run('cancelPrep()');await pump();await cancelled;
+  assert.equal(messages.length,2);
+  assert.match(messages[1].params.content[0].text,/Cancel .*request-identity-0001/);
+  assert.match(messages[1].params.content[0].text,/Do not start another/);
+  assert.equal(button('Cancel update'),undefined);
+  deliver('request-identity-0001','Late');await pump();
+  assert.doesNotMatch(visible(roots.app),/Late/,'Cancelled delivery must be discarded.');
+  assert.match(visible(roots.app),/Current/);
+
+  globalThis.__step='again';
+  // A new request can be made after cancellation, and delivery for it replaces the view.
+  const second=run('explain()');await pump();await second;
+  assert.equal(capture,2);
+  deliver('request-identity-0002','Fresh');await pump();
+  assert.match(visible(roots.app),/Fresh/);
+  assert.equal(button('Cancel update'),undefined,'Delivery ends the request.');
+  deliver('request-identity-0002','Duplicate delivery');await pump();
+  assert.doesNotMatch(visible(roots.app),/Duplicate delivery/,'A settled request cannot deliver twice.');
+
+  // Failure keeps the last view and shows the reason; it never retries.
+  const messageCount=messages.length;
+  const third=run('explain()');await pump();await third;
+  deliver('request-identity-0003','',"failed",'Could not read');await pump();
+  assert.match(roots.error.textContent,/Could not read/);
+  assert.match(visible(roots.app),/Fresh/);
+  assert.equal(messages.length,messageCount+1,'Failure must not create another request.');
+  assert.equal(capture,3);
+
+  // Supersession reported for the active request drops it.
+  const fourth=run('explain()');await pump();await fourth;
+  deliver('request-identity-0004','',"superseded");await pump();
+  assert.match(roots.error.textContent,/New instructions/);
+  assert.equal(button('Cancel update'),undefined);
+
+  // Timeout ends the request and preserves the view; later completion is dropped.
+  const fifth=run('explain()');await pump();await fifth;
+  const timer=timers.filter(t=>t.fn&&t.ms===600000).pop();
+  assert.ok(timer,'A bounded attempt needs a timeout.');
+  const beforeTimeout=messages.length;
+  const timedOut=timer.fn();
+  assert.equal(button('Cancel update'),undefined,'Timeout invalidates the request at once.');
+  deliver('request-identity-0005','Too late');await pump();await timedOut;
+  assert.match(roots.error.textContent,/took too long/);
+  assert.equal(messages.length,beforeTimeout+1,'Timeout must hand a stop request to the first officer.');
+  assert.match(messages.at(-1).params.content[0].text,/Cancel .*request-identity-0005.*timed out/);
+  assert.match(messages.at(-1).params.content[0].text,/Interrupt its read-only subagent/);
+  assert.match(roots.error.textContent,/asked to stop it; the stop is not confirmed/,'A requested stop is not reported as confirmed.');
+  assert.match(roots.error.textContent,/cannot show it/,'The timeout names the undeliverable-result boundary.');
+  assert.doesNotMatch(visible(roots.app),/Too late/);
+  assert.match(visible(roots.app),/Fresh/);
+
+  // A failed stop handoff after timeout is reported honestly and still discards the work.
+  const sixthA=run('explain()');await pump();await sixthA;
+  const timerB=timers.filter(t=>t.fn&&t.ms===600000).pop();
+  assert.ok(timerB);
+  failMessages=true;
+  const timedOutB=timerB.fn();await pump();await timedOutB;failMessages=false;
+  assert.match(roots.error.textContent,/could not be told to stop it/);
+  assert.match(roots.error.textContent,/may still be running/);
+  deliver('request-identity-0006','Too late again');await pump();
+  assert.doesNotMatch(visible(roots.app),/Too late again/);
+
+  // Late acknowledgement failure for cancelled request A must not clear newer request B.
+  failMessages=false;holdAcks=true;
+  const A=run('explain()');await pump();
+  assert.ok(pendingAcks.length>=1,'A dispatch acknowledgement is unresolved.');
+  const ackA=pendingAcks.shift();
+  const cancelA=run('cancelPrep()');await pump();
+  const B=run('explain()');await pump();
+  holdAcks=false;
+  for(const a of pendingAcks.splice(0))answer(a,{});
+  await pump();
+  assert.ok(button('Cancel update'),'B is active before the stale acknowledgement fails.');
+  listener({source:parent,data:{jsonrpc:'2.0',id:ackA.id,error:{message:'Late A failure'}}});
+  await pump();await A;await cancelA;await B;
+  assert.ok(button('Cancel update'),'A late failure of A must not clear B or its cancel control.');
+  assert.doesNotMatch(roots.error.textContent,/Late A failure/);
+  const idB=run('prep.request.requestId');
+  deliver(idB,'From B');await pump();
+  assert.match(visible(roots.app),/From B/,'B still settles after A fails late.');
+
+  // Capture failure sends nothing to the first officer.
+  failCapture=true;const before=messages.length;
+  const sixth=run('explain()');await pump();await sixth;
+  assert.equal(messages.length,before);
+  assert.match(roots.error.textContent,/Capture failed/);
+  assert.equal(button('Cancel update'),undefined);
+  globalThis.__done=true;console.log('PASS: request capture, single dispatch, duplicate submission, cancel, late and foreign delivery, failure, supersession, timeout and capture failure.');
+})().catch(e=>{console.error(e);process.exitCode=1});
diff --git a/mcp/captains-bridge/test_preparation.py b/mcp/captains-bridge/test_preparation.py
new file mode 100644
index 0000000..21595f0
--- /dev/null
+++ b/mcp/captains-bridge/test_preparation.py
@@ -0,0 +1,146 @@
+"""Background preparation: request capture, delivery validation and failure paths."""
+import copy
+import unittest
+import preparation
+import server
+import test_walkthrough
+
+CHAT = '11111111-1111-4111-8111-111111111111'
+
+
+class PreparationTests(unittest.TestCase):
+    def setUp(self):
+        fixture = test_walkthrough.WalkthroughTests()
+        fixture.setUp()
+        self.data, self.account = fixture.data, fixture.account
+        self.original = server.read_chat
+        self.reads = []
+
+        def read(thread_id):
+            self.reads.append(thread_id)
+            if thread_id != CHAT:
+                raise ValueError('Wrong chat selected')
+            return copy.deepcopy(self.data)
+        server.read_chat = read
+        self.addCleanup(setattr, server, 'read_chat', self.original)
+
+    def call(self, name, arguments):
+        return server.handle('tools/call', {'name': name, 'arguments': arguments})
+
+    def request(self):
+        result = self.call('request_walkthrough_update', {'view': {'threadId': CHAT, 'walkthrough': None}})
+        return result['structuredContent']['request']
+
+    def test_capture_records_chat_snapshot_and_identity_without_work(self):
+        request = self.request()
+        self.assertEqual(request['threadId'], CHAT)
+        self.assertEqual(request['snapshot']['recordCount'], len(self.data['records']))
+        self.assertEqual(request['snapshot']['fingerprint'], preparation.fingerprint(self.data))
+        self.assertNotIn('binding', request, 'No process-local binding may be transferred.')
+        self.assertEqual(server.BINDINGS.get(request['requestId']), None)
+        self.assertNotEqual(self.request()['requestId'], request['requestId'])
+
+    def test_tools_are_declared_read_only_and_capture_is_app_only(self):
+        tools = {t['name']: t for t in server.handle('tools/list', {})['tools']}
+        self.assertEqual(tools['request_walkthrough_update']['_meta']['ui']['visibility'], ['app'])
+        for name in ('request_walkthrough_update', 'deliver_walkthrough_update'):
+            self.assertTrue(tools[name]['annotations']['readOnlyHint'])
+            self.assertFalse(tools[name]['annotations']['destructiveHint'])
+
+    def test_delivery_reads_only_the_request_chat_and_keeps_snapshot_time(self):
+        request = self.request()
+        self.reads.clear()
+        result = self.call('deliver_walkthrough_update', {'request': request, 'walkthrough': self.account})
+        self.assertEqual(self.reads, [CHAT])
+        self.assertEqual(result['structuredContent']['preparation'], {'requestId': request['requestId'], 'outcome': 'delivered'})
+        account = result['_meta']['deck']['walkthrough']
+        self.assertEqual(account['explainedAt'], request['snapshot']['readAt'])
+        self.assertEqual(account['fingerprint'], request['snapshot']['fingerprint'])
+        self.assertEqual(result['structuredContent']['view']['threadId'], CHAT)
+
+    def test_late_delivery_is_marked_older_not_fresh(self):
+        request = self.request()
+        self.data['records'].append({'id': 'later', 'kind': 'report', 'actor': 'First officer', 'text': 'More work', 'turnId': 'turn-a'})
+        result = self.call('deliver_walkthrough_update', {'request': request, 'walkthrough': self.account})
+        deck = result['_meta']['deck']
+        self.assertTrue(deck['explanationStale'])
+        self.assertEqual(deck['walkthrough']['fingerprint'], request['snapshot']['fingerprint'])
+
+    def test_citation_after_snapshot_is_rejected(self):
+        request = self.request()
+        self.data['records'].append({'id': 'later', 'kind': 'report', 'actor': 'First officer', 'text': 'More work', 'turnId': 'turn-a'})
+        self.account['items'][0]['evidence'] = ['later']
+        with self.assertRaises(ValueError):
+            self.call('deliver_walkthrough_update', {'request': request, 'walkthrough': self.account})
+
+    def test_foreign_citation_and_shrunken_chat_are_rejected(self):
+        request = self.request()
+        self.account['items'][0]['evidence'] = ['another-chat']
+        with self.assertRaises(ValueError):
+            self.call('deliver_walkthrough_update', {'request': request, 'walkthrough': self.account})
+        self.data['records'] = self.data['records'][:1]
+        with self.assertRaises(ValueError):
+            self.call('deliver_walkthrough_update', {'request': request, 'walkthrough': self.account})
+
+    def test_request_cannot_name_another_chat_or_forged_snapshot(self):
+        request = self.request()
+        for change in ({'threadId': '22222222-2222-4222-8222-222222222222'}, {'threadId': 'recent'},
+                       {'requestId': 'x'}, {'snapshot': {'fingerprint': 'f', 'readAt': 'now', 'recordCount': 1}},
+                       {'snapshot': None}):
+            forged = dict(copy.deepcopy(request), **change)
+            with self.assertRaises(ValueError):
+                self.call('deliver_walkthrough_update', {'request': forged, 'walkthrough': self.account})
+        # A well-formed request for another chat reads only that chat, which this
+        # reader refuses; delivery has no way to ask for the "current" or latest chat.
+        foreign = dict(copy.deepcopy(request), threadId='22222222-2222-4222-8222-222222222222')
+        with self.assertRaises(ValueError):
+            self.call('deliver_walkthrough_update', {'request': foreign, 'walkthrough': self.account})
+
+    def test_changed_captured_record_is_rejected_even_with_same_ids_and_count(self):
+        request = self.request()
+        self.data['records'][0]['text'] = 'Rewritten after capture'
+        with self.assertRaisesRegex(ValueError, 'changed since'):
+            self.call('deliver_walkthrough_update', {'request': request, 'walkthrough': self.account})
+
+    def test_inconsistent_digest_is_rejected(self):
+        request = self.request()
+        for field in ('fingerprint', 'evidence', 'readAt', 'recordCount'):
+            forged = copy.deepcopy(request)
+            forged['snapshot'][field] = '0' * 64 if field in ('fingerprint', 'evidence') else (
+                'yesterday' if field == 'readAt' else request['snapshot']['recordCount'])
+            if field == 'recordCount':
+                forged['snapshot'][field] += 1
+            with self.assertRaises(ValueError, msg=field):
+                self.call('deliver_walkthrough_update', {'request': forged, 'walkthrough': self.account})
+        # A consistently re-sealed fingerprint that does not match the chat is still refused.
+        resealed = copy.deepcopy(request)
+        resealed['snapshot']['fingerprint'] = '0' * 64
+        resealed['snapshot']['seal'] = preparation.seal(resealed['requestId'], resealed['threadId'], resealed['snapshot'])
+        with self.assertRaisesRegex(ValueError, 'fingerprint'):
+            self.call('deliver_walkthrough_update', {'request': resealed, 'walkthrough': self.account})
+
+    def test_appended_records_do_not_reject_unchanged_snapshot(self):
+        request = self.request()
+        self.data['records'].append({'id': 'later', 'kind': 'report', 'actor': 'First officer', 'text': 'More', 'turnId': 'turn-a'})
+        result = self.call('deliver_walkthrough_update', {'request': request, 'walkthrough': self.account})
+        self.assertEqual(result['structuredContent']['preparation']['outcome'], 'delivered')
+
+    def test_failure_report_delivers_no_explanation(self):
+        request = self.request()
+        for args in ({'failure': 'Could not read'}, {}):
+            result = self.call('deliver_walkthrough_update', dict(args, request=request))
+            self.assertEqual(result['structuredContent']['preparation']['outcome'], 'failed')
+            self.assertNotIn('deck', result['structuredContent'])
+            self.assertNotIn('deck', result.get('_meta', {}))
+
+    def test_settlement_rejects_unknown_outcomes_and_long_messages(self):
+        request = self.request()
+        with self.assertRaises(ValueError):
+            preparation.settlement(request, 'retry')
+        with self.assertRaises(ValueError):
+            preparation.settlement(request, 'failed', 'x' * 501)
+        self.assertEqual(preparation.settlement(request, 'cancelled')['outcome'], 'cancelled')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/mcp/captains-bridge/view.html b/mcp/captains-bridge/view.html
index 9d4f942..4491c6a 100644
--- a/mcp/captains-bridge/view.html
+++ b/mcp/captains-bridge/view.html
@@ -53,7 +53,57 @@
 }
 function skillButton(skill,workItem){const b=button(skill==='retro'?'Retro':'Show Me',()=>requestSkill(skill,workItem,b),'button');b.title=skill==='retro'?'Suggest improvements for future sessions':'Ask for a visual explanation';b.disabled=messagePending;return b}
 function chatActions(main){append(main,append(el('div',null,'chat-actions'),skillButton('show-me'),skillButton('retro')),el('p','Visual explanation or session retrospective. The first officer responds in this chat.','action-context'))}
-async function explain(){try{await rpc('ui/message',{role:'user',content:[{type:'text',text:'Open Captain’s Bridge for this current chat with an updated source-grounded walkthrough. Use the observe-chat skill, read_chat_work, and present_chat_work. Preserve current-chat scope. Do not start or resume the underlying project work.'}]});error('');const n=el('p','Requested an updated walkthrough in this chat.','context');$('app').prepend(n)}catch(e){error(e.message)}}
+async function connectChat(){try{await rpc('ui/message',{role:'user',content:[{type:'text',text:'Open Captain’s Bridge for this current chat with an updated source-grounded walkthrough. Use the observe-chat skill, read_chat_work, and present_chat_work. Preserve current-chat scope. Do not start or resume the underlying project work.'}]});error('')}catch(e){error(e.message)}}
+let prep=null,prepTimer=null,capturing=false;
+const PREP_MS=600000;
+function clearPrep(){clearTimeout(prepTimer);prep=null}
+function prepText(request){return 'Prepare an updated Captain’s Bridge walkthrough in the background; this is optional and a new instruction from me ends it. Do not wait or poll for the result, and do not pause or change already-authorized project work. Dispatch exactly one read-only subagent, once, with no retry. The subagent reads only chat '+request.threadId+' (codex://threads/'+request.threadId+') and never substitutes its own chat. It must not run project tasks or repair the viewer. It uses the observe-chat skill and read_chat_work with that thread_id, cites only record IDs from that read, then calls deliver_walkthrough_update once with the request below unchanged (or with a failure message). Present its delivery briefly at the next available boundary. If I cancel this request or it times out, interrupt the subagent and discard any result.\n\nRequest:\n'+JSON.stringify(request)}
+async function explain(){
+ if(prep||capturing)return;
+ if(!portableView?.threadId){error('This view has no chat reference. Open its walkthrough before requesting an update.');return}
+ let mine=null;
+ try{
+  error('');capturing=true;
+  const captured=toolResult(await rpc('tools/call',{name:'request_walkthrough_update',arguments:{view:portableView}}));
+  if(captured?.isError)throw Error(captured.content?.find(c=>c.type==='text')?.text||'The update could not be requested.');
+  const request=captured?.structuredContent?.request;
+  if(!request?.requestId)throw Error('Codex returned no request identity. The current view is preserved.');
+  capturing=false;mine=request.requestId;
+  prep={request,state:'sending'};render();
+  const sent=await rpc('ui/message',{role:'user',content:[{type:'text',text:prepText(request)}]});
+  if(sent?.isError)throw Error(sent.content?.find(c=>c.type==='text')?.text||'The request could not be sent.');
+  if(owns(mine)){prep.state='preparing';clearTimeout(prepTimer);prepTimer=setTimeout(()=>timeoutPrep(mine),PREP_MS);render()}
+ }catch(e){
+  if(mine===null)capturing=false; // capture failed; no request exists yet
+  else if(!owns(mine))return; // cancelled, timed out or replaced: a late failure belongs to a dead attempt
+  else clearPrep();
+  error(e.message);render()}
+}
+const owns=id=>prep?.request.requestId===id;
+async function stopRequest(id,why){
+ try{await rpc('ui/message',{role:'user',content:[{type:'text',text:'Cancel Captain’s Bridge walkthrough request '+id+' ('+why+'). Interrupt its read-only subagent if it is still running and discard any result. Do not start another and do not change project work.'}]});return true}catch(e){return e.message||'unknown error'}}
+async function timeoutPrep(id){
+ if(!owns(id))return;clearPrep();
+ error('The update took too long. Asking Codex to stop it. Your current view is preserved.');render();
+ const stopped=await stopRequest(id,'timed out after 10 minutes');
+ if(prep||capturing)return; // a newer attempt owns the panel
+ error(stopped===true?'The update took too long. Codex was asked to stop it; the stop is not confirmed, and any result is ignored. If the agent had already finished, its result reached the server but this panel cannot show it. Your current view is preserved.'
+  :'The update took too long, and Codex could not be told to stop it ('+stopped+'). It may still be running; any result is ignored. Your current view is preserved.');render()}
+async function cancelPrep(){
+ if(!prep)return;const id=prep.request.requestId;clearPrep();render();
+ const stopped=await stopRequest(id,'cancelled');
+ if(stopped!==true&&!prep&&!capturing){error('Cancelled in this view. Codex could not be told: '+stopped);render()}
+}
+function settle(preparation){
+ if(!prep||!preparation||preparation.requestId!==prep.request.requestId)return false;
+ clearPrep();
+ if(preparation.outcome==='failed')error(preparation.message||'The update failed. Your current view is preserved.');
+ else if(preparation.outcome==='superseded')error('New instructions arrived, so the update was dropped. Your current view is preserved.');
+ return true}
+function prepNotice(main){
+ if(!prep)return;const n=el('div',null,'notice');
+ append(n,el('span',prep.state==='sending'?'Requesting an update…':'Update requested in the background. This view stays as it is, and project work is not paused. Codex may not show a result here if the chat turn has already finished; cancel to stop waiting.'),button('Cancel update',cancelPrep));
+ append(main,n)}
 let refreshSeq=0,refreshing=false;
 function newerOrSame(next){const a=Date.parse(next?.readAt),b=Date.parse(deck?.readAt);return !(Number.isFinite(a)&&Number.isFinite(b))||a>=b}
 function sameChat(next){return !deck||!next||next.threadId===deck.threadId}
@@ -93,7 +143,7 @@
 function change(main,i){const c=i.change;if(!c){view={page:'work',id:i.id};render();return}append(main,crumb(i.title),el('h1',i.title),el('p',i.summary,'context'));const compare=el('div',null,'compare');for(const [label,value,cls]of[['Before',c.before,''],['After',c.after,'after']])append(compare,append(el('div',null,'value '+cls),el('strong',value),el('small',label)));append(main,compare,el('h2','What changed'),el('p',c.explanation,'context'),evidenceButton(c.evidence,'View recorded change'),button('Return to this work',back));}
 function sources(main){append(main,crumb('Supporting records'),el('h1',view.title||'Supporting records'));const wanted=new Set(view.refs||[]),records=allRecords().filter(r=>wanted.has(r.id));if(!records.length)append(main,el('p','These source records are no longer available in this connection. Refresh or reopen the walkthrough.','context'));for(const r of records){const section=el('article',null,'record');append(section,append(el('header'),el('strong',r.actor||'Recorded source'),el('span',r.kind,'badge')));const t=deck.turns.find(t=>t.id===r.turnId);if(t)append(section,el('small','Within turn starting '+date(t.startedAt),'muted'));for(const url of [...new Set(String(r.text).match(/https:\/\/[^\s<>"')\]]+/g)||[])].slice(0,5)){const a=el('a','Open original: '+url,'external');a.href=url;a.target='_blank';a.rel='noopener noreferrer';append(section,a)}
  append(section,el(['command','tool','change'].includes(r.kind)?'pre':'div',r.text,['command','tool','change'].includes(r.kind)?'':'record-text'));if(r.truncated)append(section,el('p','This excerpt was shortened. Open the original chat for the complete record.','small muted'));append(main,section)}}
-function render(){if(!deck)return;seq=0;const main=$('app');main.replaceChildren();if(deck.partialAppend){append(main,el('div','The newest record was still being written and is not included yet. Refresh again shortly.','notice'))}
+function render(){if(!deck)return;seq=0;const main=$('app');main.replaceChildren();prepNotice(main);if(deck.partialAppend){append(main,el('div','The newest record was still being written and is not included yet. Refresh again shortly.','notice'))}
  if(deck.explanationStale){const n=el('div',null,'notice');append(n,el('span','Newer records were read after this explanation was prepared, so it is older than the chat. Its conclusions are unchanged and may need updating.'),button('Update walkthrough',explain));append(main,n)}
  if(view.page==='overview')overview(main);else if(view.page==='sources')sources(main);else if(view.page==='activity'){append(main,crumb('Activity'),el('h1','Recorded activity'),el('p','The gaps below are gaps between stored turns. They do not establish a stall.','context'),timeline());}else{const i=item();if(i)view.page==='change'?change(main,i):work(main,i);else{view={page:'overview'};overview(main)}}
  const d=el('details');append(d,el('summary','About these records'),el('p','The walkthrough is the first officer’s interpretation, with links to its supporting records. A report of completion and acceptance of the work are separate claims.'));append(d,el('p',deck.coverage||'Existing records from this chat.'));if(deck.walkthrough)append(d,el('p','Explanation prepared from records read '+date(deck.walkthrough.explainedAt)));append(main,d)}
@@ -102,8 +152,8 @@
 // Codex saved tool events may wrap a complete MCP result in a single JSON text block.
 // Unwrap only that result shape; prose and source-record JSON remain literal content.
 function toolResult(result){for(let depth=0;depth<2;depth++){if(result?.isError||result?.structuredContent||result?._meta?.deck)return result;const blocks=result?.content;if(!Array.isArray(blocks)||blocks.length!==1||blocks[0]?.type!=='text')return result;let nested;try{nested=JSON.parse(blocks[0].text)}catch{return result}if(!nested||typeof nested!=='object'||!Array.isArray(nested.content)||!('structuredContent'in nested||'_meta'in nested||'isError'in nested))return result;result=nested}return result}
-function receive(raw){const result=toolResult(raw);if(result?.isError){error(result.content?.find(c=>c.type==='text')?.text||'The records could not be read.');return}const data=result?.structuredContent||{},payload=result?._meta?.deck?result._meta:data;if(payload.deck&&deck&&(!sameChat(payload.deck)||!newerOrSame(payload.deck))){error('An older or unrelated result was ignored; the current view is kept.')}else if(payload.deck){++loadVersion;deck=payload.deck;portableView=payload.view;error('');render()}else if(data.needsBinding){showConnection('Ask the first officer to connect this view to the current chat.')}else if(data.view){return loadPrepared(data.view)}else{error('The panel received a result without walkthrough data. Its explanation has not opened.');showConnection('No walkthrough data received.')}}
-$('connect').onclick=explain;
+function receive(raw){const result=toolResult(raw);if(result?.isError){error(result.content?.find(c=>c.type==='text')?.text||'The records could not be read.');return}const data=result?.structuredContent||{};const preparation=data.preparation||result?._meta?.preparation;if(preparation){if(!settle(preparation)){render();return}if(preparation.outcome!=='delivered'){render();return}}const payload=result?._meta?.deck?result._meta:data;if(payload.deck&&deck&&(!sameChat(payload.deck)||(!preparation&&!newerOrSame(payload.deck)))){error('An older or unrelated result was ignored; the current view is kept.')}else if(payload.deck){++loadVersion;deck=payload.deck;portableView=payload.view;error('');render()}else if(data.needsBinding){showConnection('Ask the first officer to connect this view to the current chat.')}else if(data.view){return loadPrepared(data.view)}else{error('The panel received a result without walkthrough data. Its explanation has not opened.');showConnection('No walkthrough data received.')}}
+$('connect').onclick=connectChat;
 addEventListener('message',e=>{if(e.source!==parent)return;const m=e.data;if(m?.id===1&&m.result){host=true;send({method:'ui/notifications/initialized',params:{}});$('connect')&&($('connect').disabled=false);if($('connection'))$('connection').textContent='Connected to Codex. Waiting for this chat’s records.';for(const[k,v]of Object.entries(m.result.hostContext?.styles?.variables||{}))if(k.startsWith('--')&&!k.startsWith('--color-'))document.documentElement.style.setProperty(k,v);const hostTheme=m.result.hostContext?.theme;if(hostTheme==='light'||hostTheme==='dark')document.documentElement.setAttribute('data-theme',hostTheme)}else if(pending.has(m?.id)){const p=pending.get(m.id);clearTimeout(p.timer);pending.delete(m.id);m.error?p.reject(Error(m.error.message)):p.resolve(m.result)}else if(m?.method==='ui/notifications/tool-result')receive(m.params);else if(m?.method==='ping'||m?.method==='ui/resource-teardown')send({id:m.id,result:{}})});
 if(parent!==window)send({id:1,method:'ui/initialize',params:{protocolVersion:'2026-01-26',appInfo:{name:'hermes-helmet-captains-bridge',version:'1'},appCapabilities:{availableDisplayModes:['fullscreen']}}});else $('connection').textContent='Open Captain’s Bridge through the plugin in Codex.';
 </script></body></html>
diff --git a/pyproject.toml b/pyproject.toml
index dabe017..a5466bd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hermes-helmet"
-version = "0.5.0"
+version = "0.6.0"
 description = "Open-source software factory for coding agents: delegation, review, and repair"
 readme = "README.md"
 requires-python = ">=3.11"
diff --git a/scripts/verify.sh b/scripts/verify.sh
index 0f2d286..f6d99e2 100755
--- a/scripts/verify.sh
+++ b/scripts/verify.sh
@@ -163,7 +163,7 @@ PYTHONPATH=src "$PYTHON_BIN" -m unittest discover -s tests -v
     cd mcp/captains-bridge
     "$PYTHON_BIN" -B -m unittest discover -s . -p 'test_*.py' -v
     if command -v node >/dev/null 2>&1; then
-        for check in test_view.cjs test_delivery.cjs test_actions.cjs test_refresh.cjs; do
+        for check in test_view.cjs test_delivery.cjs test_actions.cjs test_refresh.cjs test_preparation.cjs; do
             node "$check"
         done
     elif [ -n "${CI:-}" ]; then
diff --git a/skills/observe-chat/SKILL.md b/skills/observe-chat/SKILL.md
index 66185ca..e7c3bc9 100644
--- a/skills/observe-chat/SKILL.md
+++ b/skills/observe-chat/SKILL.md
@@ -73,6 +73,18 @@ references, retaining consequential failures. Keep async handoffs and later
 wakeups related to the same work without inventing a parent-child execution tree.
 Do not assign turn timestamps to individual operations. Gaps are not proof of a stall.
 
+## Background update (preparation agent)
+
+When the Captain’s panel requests an update, the first officer dispatches one
+read-only subagent and continues authorized work without waiting or polling. The
+subagent reads only the `threadId` in the request with `read_chat_work`, never its
+own chat, runs no project task, does not repair the viewer, and never retries. It
+cites only IDs from that read and calls `deliver_walkthrough_update` once with the
+request unchanged, or with `failure`. On a cancel message or a substantive new
+instruction from the Captain, the first officer interrupts the subagent and
+discards its result unless the Captain keeps the request. Present a delivery
+briefly at an available boundary; do not hold project delivery open for it.
+
 ## Refresh and limitations
 
 The reader opens Codex’s existing local chat index in read-only mode and reads
@@ -85,7 +97,7 @@ The prepared result carries an explicit chat reference and explanation so app
 calls do not depend on the model tool process’s memory. Each app read validates
 the citations again; it writes no transcript or standalone viewer file.
 If records changed it labels the explanation as older, showing the record-read time apart from the explanation’s own source time, and never restamps or rewrites it. Refresh calls the read-only app tool directly: it sends no message to the first officer. A failed, timed-out, foreign or out-of-order refresh keeps the last view and reports why. “Update walkthrough”
-requests this skill again in this same chat. No automatic monitoring is added.
+starts the background update above in this same chat. No automatic monitoring is added.
 The extension does not directly collect Hermes Docker events: use recorded
 worker results only when explicitly connected to this chat, and disclose missing
 coverage at the affected item. A source-bound explanation is not independent
diff --git a/src/hermes_helmet/__init__.py b/src/hermes_helmet/__init__.py
index 73063cf..2adbd02 100644
--- a/src/hermes_helmet/__init__.py
+++ b/src/hermes_helmet/__init__.py
@@ -7,7 +7,7 @@
 
 from hermes_helmet.authority import Policy, load_authority, load_policy, render_crew_contract
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"
 
 __all__ = [
     "Policy",