Claude Code in deiner eigenen Web-App · Teil 7 von 16 der Serie
Teil 7: Das Ende einer Runde
Zeig, was Claude Code sagt, wenn es fertig ist, aus Markdown gerendert, ohne dass der Text des Modells eigenes HTML mitbringen kann, antworte ihm aus der Seite und erkenne genau, wann eine Runde vorbei ist, auch wenn sie ohne Stop-Hook endet.
Claude Code in deiner eigenen Web-AppTeil 7 von 16
Auf dieser Seite
Quest-Ziele
- Die Zusammenfassung einer Runde aus dem Stop-Hook nehmen
- Das Markdown von Claude Code sicher rendern: erst escapen, dann Tags setzen
- Claude Code aus der Seite antworten, als eine getippte Zeile
- Die Hooks entscheiden lassen, ob Claude Code beschäftigt ist
- Eine Runde beenden, die nie einen Stop-Hook schickt
Seit Teil 6 weiß die Seite, was Claude Code tut, während es arbeitet: jedes Werkzeug aus einem Hook, und was es dazwischen sagt, aus seinem Transkript. Der Stop-Hook sagt ihr auf die Sekunde, wann eine Runde vorbei ist. Dann zeigt das Panel „Done after 0:39“, und das war es.
Dabei ist das, was Claude Code in diesem Moment sagt, das Nützlichste an der ganzen Runde. Der Auftrag bittet es um zwei, drei Sätze dazu, was es gebaut oder geändert hat, und meistens schreibt es dazu, was es weggelassen hat und was du prüfen solltest. Bisher stehen diese Sätze nur im Terminal. Dieser Teil holt sie in die Seite, aus Markdown gerendert, ohne dem Text des Modells eine Tür zu öffnen, und setzt ein Feld darunter, in dem du antworten kannst. Unterwegs lernt die Seite, genauer zu erkennen, wann Claude Code beschäftigt ist, auch bei Runden, die ohne Stop-Hook enden.
Die letzte Nachricht kommt mit dem Stop-Hook
Die Eingabe des Stop-Hooks hat ein Feld, das du noch nicht benutzt hast: last_assistant_message, den Text der Nachricht, mit der Claude Code seine Runde beendet hat. Das ist die Zusammenfassung. Ein Lauf hebt sie auf, in shared/types.ts (ersetze Run):
/** A request from the page, from the moment it is asked until Claude Code's turn is over. */
export interface Run {
id: string;
title: string;
/**
* queued: waits until Claude Code is free; starting: typed in (or the session is starting);
* working: Claude Code works on it; then done, stopped or failed
*/
status: 'queued' | 'starting' | 'working' | 'done' | 'stopped' | 'failed';
queued: number;
started?: number;
ended?: number;
error?: string;
/** what Claude Code said at the end of its turn */
summary?: string;
}In server/agent.ts kopiert pub(), das aus einem Job macht, was die Seiten zu sehen bekommen, sie mit:
const pub = (j: Job): Run => ({ id: j.id, title: j.title, status: j.status, queued: j.queued, started: j.started, ended: j.ended, error: j.error, summary: j.summary });Und der Fall Stop in hookEvent() nimmt sie entgegen (ersetze den Fall):
case 'Stop': {
// the end of its turn, with its last message: exact, where the screen could only guess
s.hookBusy = false;
const said = String(ev.last_assistant_message ?? '').trim();
if (said) this.note(name, { kind: 'say', text: short(oneLine(said), 300) });
if (live(run)) {
run!.summary = said || undefined;
this.end(name, 'done');
}
break;
}Der ganze Text kommt in den Lauf. Auch der Verlauf bekommt ihn, zu einer Zeile zusammengezogen und nach 300 Zeichen abgeschnitten, wie alles andere, was Claude Code dort sagt.
Warum nicht aus dem Transkript lesen, wie den Rest dessen, was Claude Code sagt? Du hast in Teil 6 gesehen, dass das Transkript einen Moment nach den Hooks geschrieben wird. Wenn der Stop-Hook ankommt, steht die letzte Nachricht vielleicht noch nicht in der Datei, und die nächste Gelegenheit, sie zu lesen, wäre der nächste Hook, und der kann eine Stunde auf sich warten lassen. Der Stop-Hook bringt den Text mit, es gibt also nichts, worauf man warten müsste.
Einmal gesagt, einmal notiert
Dieselben Worte kommen jetzt zweimal an: vom Stop-Hook und später aus dem Transkript. Mit einer Antwort, die du tippst (weiter unten), ist es genauso: Sie wird notiert, wenn die Seite sie tippt, und noch einmal, wenn der Hook UserPromptSubmit sie meldet. Ersetze note():
/**
* A line of activity, in its place in time. What Claude Code says and what you type arrive twice
* (from a hook and from the transcript): a second copy within two minutes is left out.
*/
private note(name: string, a: Omit<Activity, 't'>, t = Date.now()) {
const s = this.site(name);
const window = a.kind === 'say' || a.kind === 'prompt' ? 120000 : 2000;
if (s.activity.slice(-6).some((b) => b.kind === a.kind && b.text === a.text && Math.abs(b.t - t) < window)) return;
// the transcript is written a moment after the hooks fire: its lines go back to where they belong
let i = s.activity.length;
while (i > 0 && s.activity[i - 1].t > t) i--;
s.activity.splice(i, 0, { t, ...a });
if (s.activity.length > ACTIVITY) s.activity.splice(0, s.activity.length - ACTIVITY);
}Eine Kopie erkennt die Funktion an Art und Text, unter den letzten sechs Zeilen, und nur, wenn beide zeitlich nah beieinander liegen. Die Zeile aus dem Transkript trägt den Zeitstempel des Transkripts, egal wie spät sie gelesen wird, beide Kopien tragen also fast dieselbe Zeit; zwei Minuten lassen reichlich Spielraum. Bei Werkzeugen und den übrigen Zeilen ist das Fenster zwei Sekunden lang, denn dasselbe Werkzeug zweimal hintereinander gibt es wirklich: Claude Code bearbeitet index.html gern zweimal.
Markdown, und sonst nichts
Claude Code schreibt Markdown: Fettes, Code in Backticks, Listen, ab und zu eine Tabelle oder eine Überschrift. Als reiner Text wird daraus ein Panel voller Sternchen. Eine Markdown-Bibliothek würde es tun, aber die Seite braucht nur einen kleinen Teil von Markdown, und dieser Teil muss sicher sein. Leg src/markdown.ts an:
/**
* Claude Code's messages as HTML: a small part of Markdown (paragraphs, headings, lists, code,
* emphasis, tables, links). Everything is escaped first, so the text can never bring its own
* markup, and links must be http(s).
*/
const esc = (s: string) => s.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"');
function inline(s: string) {
const codes: string[] = [];
let out = esc(s).replace(/`([^`]+)`/g, (_, c: string) => `\u0000${codes.push(c) - 1}\u0000`);
out = out
.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
.replace(/(^|[^*\w])\*([^*\s][^*]*)\*(?!\w)/g, '$1<em>$2</em>')
.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
return out.replace(/\u0000(\d+)\u0000/g, (_, i: string) => `<code>${codes[Number(i)]}</code>`);
}
export function markdown(text: string) {
const lines = text.replace(/\r\n/g, '\n').split('\n');
const html: string[] = [];
let i = 0;
while (i < lines.length) {
const line = lines[i];
if (/^```/.test(line)) {
const body: string[] = [];
for (i++; i < lines.length && !/^```/.test(lines[i]); i++) body.push(lines[i]);
i++;
html.push(`<pre><code>${esc(body.join('\n'))}</code></pre>`);
continue;
}
const h = line.match(/^(#{1,4})\s+(.*)$/);
if (h) { html.push(`<h${Math.min(6, h[1].length + 3)}>${inline(h[2])}</h${Math.min(6, h[1].length + 3)}>`); i++; continue; }
if (/^\s*\|.*\|\s*$/.test(line) && /^\s*\|?\s*:?-{2,}/.test(lines[i + 1] ?? '')) {
const cells = (l: string) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
const head = cells(line);
const rows: string[][] = [];
for (i += 2; i < lines.length && /^\s*\|.*\|\s*$/.test(lines[i]); i++) rows.push(cells(lines[i]));
html.push(`<table><thead><tr>${head.map((c) => `<th>${inline(c)}</th>`).join('')}</tr></thead><tbody>${rows.map((r) => `<tr>${r.map((c) => `<td>${inline(c)}</td>`).join('')}</tr>`).join('')}</tbody></table>`);
continue;
}
const list = line.match(/^\s*([-*]|\d+[.)])\s+/);
if (list) {
const ordered = /\d/.test(list[1]);
const items: string[] = [];
for (; i < lines.length; i++) {
const m = lines[i].match(/^\s*([-*]|\d+[.)])\s+(.*)$/);
if (m) items.push(m[2]);
else if (lines[i].trim() && /^\s{2,}/.test(lines[i]) && items.length) items[items.length - 1] += ` ${lines[i].trim()}`;
else break;
}
html.push(`<${ordered ? 'ol' : 'ul'}>${items.map((it) => `<li>${inline(it)}</li>`).join('')}</${ordered ? 'ol' : 'ul'}>`);
continue;
}
if (!line.trim()) { i++; continue; }
const para: string[] = [];
for (; i < lines.length && lines[i].trim() && !/^(```|#{1,4}\s|\s*([-*]|\d+[.)])\s)/.test(lines[i]); i++) para.push(lines[i]);
html.push(`<p>${para.map(inline).join('<br>')}</p>`);
}
return html.join('');
}Zuerst escapen. Das Erste, was inline() tut, und das Einzige, was mit einem Codeblock passiert, ist esc(): Jedes &, <, > und " wird zu einer Entity. Erst danach setzen die Muster ihre Tags. Im Ergebnis stehen also nur die Tags, die markdown() selbst schreibt, und was immer an HTML im Text steht, kommt als Text an.
Code wird beiseitegelegt. Code-Spans werden gegen nummerierte Platzhalter getauscht, bevor nach Fettem, Kursivem und Links gesucht wird, und am Ende wieder eingesetzt. Ein Sternchen in einem Code-Span bleibt ein Sternchen.
Links nur ins Web. Ein Link wird nur dann zu einem <a>, wenn seine Adresse mit http:// oder https:// beginnt; eine javascript:-Adresse bleibt Text. Links öffnen sich in einem neuen Tab, mit noopener noreferrer, damit die Seite dahinter keinen Zugriff auf Sitesmith bekommt.
Blöcke, Zeile für Zeile. markdown() geht die Zeilen durch und erkennt Codeblöcke, Überschriften, Tabellen (eine Zeile mit Zellen, gefolgt von einer Zeile mit Strichen), Listen und Absätze. Überschriften rutschen drei Stufen nach unten: Aus einem # in der Nachricht von Claude Code wird ein <h4>, damit es kleiner bleibt als die Überschriften der Seite. Ein Listenpunkt darf über mehrere Zeilen gehen, wenn sie eingerückt sind.
Das Panel
Ersetze src/agentPanel.ts durch:
import { api } from './api.ts';
import { h } from './dom.ts';
import { markdown } from './markdown.ts';
import type { AgentState, ReplyBody, Run } from '../shared/types.ts';
export const isLive = (r: Run | null | undefined) => Boolean(r && ['queued', 'starting', 'working'].includes(r.status));
/** 75 -> "1:15" */
const clock = (ms: number) => {
const s = Math.max(0, Math.round(ms / 1000));
return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`;
};
function statusText(r: Run, now: number) {
switch (r.status) {
case 'queued': return 'Waiting until Claude Code is free';
case 'starting': return 'Starting';
case 'working': return `Working for ${clock(now - (r.started ?? now))}`;
case 'done': return `Done after ${clock((r.ended ?? now) - (r.started ?? now))}`;
case 'stopped': return 'Stopped';
case 'failed': return r.error ? `Failed: ${r.error}` : 'Failed';
}
}
/**
* The current (or last) run: what it is, how long Claude Code has worked on it, what it does
* (its tools and what it says between them, from the hooks), and Stop. At the end, what it said
* last, and a box to reply to it.
*/
export class AgentPanel {
readonly el: HTMLElement;
private url: string;
private title = h('h2', { class: 'agent-title' });
private status = h('p', { class: 'agent-status' });
private stopBtn = h('button', { type: 'button', class: 'small ghost' }, 'Stop');
private feed = h('ol', { class: 'feed', 'aria-label': 'What Claude Code does', 'aria-live': 'polite' });
private summary = h('div', { class: 'summary md', hidden: true });
private replyText = h('input', { type: 'text', autocomplete: 'off', placeholder: 'Reply to Claude Code…', 'aria-label': 'Reply to Claude Code' });
private reply = h('form', { class: 'reply', hidden: true }, this.replyText, h('button', { type: 'submit', class: 'small' }, 'Send'));
private site: string;
private msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
private timer = 0;
constructor(site: string) {
this.site = site;
this.url = `/api/sites/${site}/stop`;
this.stopBtn.onclick = () => void this.stop();
this.reply.onsubmit = (e) => { e.preventDefault(); void this.send(); };
this.el = h('section', { class: 'panel agent', 'aria-label': 'Claude Code', hidden: true },
h('header', { class: 'agent-head' }, h('div', {}, this.title, this.status), this.stopBtn),
this.feed, this.summary, this.reply, this.msg);
}
update(state: AgentState | undefined) {
const run = state?.run ?? null;
clearInterval(this.timer);
this.el.hidden = !run;
if (!run) return;
this.el.dataset.status = run.status;
this.title.textContent = run.title;
this.status.textContent = statusText(run, Date.now());
if (run.status === 'working') this.timer = window.setInterval(() => { this.status.textContent = statusText(run, Date.now()); }, 1000);
this.stopBtn.hidden = !isLive(run) || run.status === 'queued';
// what it did for this run, the last few lines; at the end, what it said last instead
const live = isLive(run);
const mine = state!.activity.filter((a) => a.t >= run.queued - 1000).slice(-9);
this.feed.replaceChildren(...mine.map((a) => h('li', { class: a.kind }, a.text)));
this.feed.hidden = !mine.length || (!live && Boolean(run.summary));
this.summary.hidden = live || !run.summary;
if (!live && run.summary) this.summary.innerHTML = markdown(run.summary);
this.reply.hidden = live;
}
private async send() {
const body: ReplyBody = { text: this.replyText.value };
this.msg.textContent = '';
try {
await api('POST', `/api/sites/${this.site}/reply`, body);
this.replyText.value = '';
} catch (err) { this.msg.textContent = (err as Error).message; }
}
private async stop() {
if (!confirm('Stop Claude Code? It ends its turn where it is; what it changed so far stays.')) return;
try { await api('POST', this.url); } catch (err) { this.msg.textContent = (err as Error).message; }
}
dispose() { clearInterval(this.timer); }
}Solange ein Lauf aktiv ist, zeigt das Panel den Verlauf wie bisher. Ist der Lauf vorbei und hat er eine Zusammenfassung, nimmt sie den Platz des Verlaufs ein, gerendert von markdown(); ihre Klasse md nutzt style.css, um dem gerenderten Markdown seine Abstände zu geben. Darunter steht, sobald kein Lauf aktiv ist, das Formular zum Antworten. send() braucht nichts aus der Antwort des Servers: Der neue Zustand kommt über die Ereignisse des Servers, wie alles andere auch.
Antworten
Eine Antwort ist eine Nachricht, die in Claude Code getippt wird, so wie du sie im Terminal tippen würdest. Füg reply() in server/agent.ts zur Klasse Agent hinzu, nach stop():
/**
* Your reply to what Claude Code said at the end of its turn, typed in like a message in the
* terminal. It continues the last run: the page follows it there.
*/
async reply(t: Target, text: string) {
const s = this.site(t.name);
if (!this.terminals.get(t.name)?.claude) throw new Error('Claude Code is not running for this site.');
if (this.busy(t.name) || this.active(t.name)) throw new Error('Claude Code is working. Wait until its turn is over.');
if (!(await this.terminals.atEmptyPrompt(t))) throw new Error('Claude Code is not at an empty prompt: look in the terminal.');
// one line: a line break would send it early, a long text would arrive as a paste
const line = oneLine(text);
if (!line) throw new Error('Write a reply first.');
if (line.length > 500) throw new Error('Keep the reply under 500 characters, or send it as a new request.');
await this.terminals.type(t, line);
this.note(t.name, { kind: 'prompt', text: `You: ${short(line)}` });
const run = s.run;
if (run) {
run.status = 'starting';
run.started = run.sentAt = Date.now();
run.ended = run.summary = run.error = undefined;
}
this.changed(t.name);
}In fünf Fällen lehnt sie ab, jedes Mal mit einer Meldung, die das Panel anzeigt: Claude Code läuft nicht, es arbeitet, es steht nicht an einem leeren Prompt, die Antwort ist leer, oder sie ist zu lang. Der leere Prompt ist die Prüfung aus Teil 5: Tasten, die an etwas anderes gehen, würden das beantworten, und ein Enter kann eine Berechtigungsabfrage bestätigen. Eine Antwort ist eine Zeile, aller Leerraum wird zu einfachen Leerzeichen zusammengezogen, denn ein Zeilenumbruch im Terminal würde sie zu früh abschicken. Bis 500 Zeichen wird sie direkt getippt; alles, was länger ist, ist ein Auftrag, und Aufträge reisen in einer Datei.
Eine Antwort setzt den Lauf fort, auf den sie antwortet, statt einen neuen zu beginnen. Der Lauf geht zurück auf starting und verliert sein Ende, seine Zusammenfassung und seinen Fehler. Auch seine Uhr beginnt von vorn: started und sentAt werden auf jetzt gesetzt, damit das Panel die Zeit der neuen Runde zählt und check() ihr dieselben paar Sekunden zum Anlaufen gibt wie einem neuen Lauf. Ab da übernehmen die Hooks: UserPromptSubmit macht ihn zu working, und Stop bringt die neue Zusammenfassung.
Der Body der Anfrage, in shared/types.ts nach RequestBody:
/** A reply to what Claude Code said at the end of its turn. */
export interface ReplyBody {
text: string;
}Und die Route, in server/main.ts nach der für stop. Nimm ReplyBody in den Import aus ../shared/types.ts auf:
['POST', /^\/api\/sites\/([^/]+)\/reply$/, async (req, res, m) => {
const t = target(m[1]);
const { text } = await readJson<ReplyBody>(req);
try { await agent.reply(t, String(text ?? '')); } catch (err) { throw new HttpError(409, (err as Error).message); }
send(res, 200, agent.state(t.name));
}],Eine Ablehnung aus agent.reply() wird zu einer 409 mit ihrer Meldung, und api() in der Seite macht daraus den Fehler, den das Panel anzeigt.
Beschäftigt, laut den Hooks
Probier eine Antwort direkt nach dem Ende einer Runde, und mit dem bisherigen Code wird sie abgelehnt. So war es im Test, bei Lumen Café:
# a reply sent right after the end of a turn, while the screen still counted as busy:{"error":"Claude Code is working. Wait until its turn is over."}# with the hooks deciding "busy", the reply went through:{"site":"lumen-cafe","run":{"id":"8c6a8713-…","title":"Changing the site",…# the run's status and the start of its summary, at the next check a few seconds later:check 1: done | The "See the menu" button now darkens to `#7a3822` on hover, down from …
Der Stop-Hook hatte gemeldet, dass die Runde vorbei war, aber busy() hat auch den Bildschirm gefragt: beschäftigt war, wenn die Hooks es sagten oder der Bildschirm sich bewegte. Und der Bildschirm bewegt sich nach dem Ende einer Runde noch ein paar Sekunden, während Claude Code seine letzten Zeilen zeichnet. Eine Sitzung gilt als beschäftigt, solange sich ihr Bildschirm in drei der letzten fünf Sekunden geändert hat (Teil 3). Darum entscheiden jetzt die Hooks allein, bei den Sitzungen, die sie haben. Ersetze in server/agent.ts site() und busy():
private site(name: string) {
let s = this.sites.get(name);
if (!s) {
s = { run: null, queue: [], delivering: false, hooked: false, hookBusy: false, quietSince: 0, transcript: null, transcriptPos: 0, activity: [], sent: '' };
this.sites.set(name, s);
}
return s;
}
/**
* Working: with the hooks, between a prompt and the end of its turn (exact, the moment it
* happens); without them, while the screen moves (a few seconds late).
*/
private busy(name: string) {
const term = this.terminals.get(name);
const s = this.site(name);
return Boolean(term?.claude && (s.hooked ? s.hookBusy : term.busy));
}Bei Sitzungen ohne Hooks, etwa einer, die gestartet wurde, bevor der Server seine Einstellungen geschrieben hat, entscheidet weiterhin der Bildschirm. Die Hooks kennen den Moment, in dem eine Runde beginnt und endet; der Bildschirm merkt es erst ein paar Sekunden später.
site() setzt ein neues Feld, quietSince, auf 0. Füg es im Interface SiteAgent nach hookBusy ein:
/** since when the hooks say busy while the screen sits still at the prompt (0: not so) */
quietSince: number;Runden, die wortlos enden
Die Hooks haben einen blinden Fleck: Eine Runde, die unterbrochen wird, endet ohne Stop-Hook. Der Stop-Knopf in der Seite drückt Escape, also beendet stop() das Beschäftigt der Hooks jetzt selbst. Ersetze es:
/** Interrupts Claude Code: Escape in its session, as you would press it. */
async stop(t: Target) {
const s = this.site(t.name);
s.queue = [];
await this.terminals.keys(t, 'Escape').catch(() => undefined);
// an interrupted turn ends without a Stop hook
s.hookBusy = false;
this.end(t.name, 'stopped');
this.changed(t.name);
}Escape kann aber auch im Terminal gedrückt werden, von dir, und eine Runde kann mit einem Fehler enden. Dann sagt kein Hook etwas, und die Seite würde bis zum nächsten Prompt „working“ anzeigen. Hier eine solche Runde aus dem Test, und wie die Seite sie mit dem Code unten gesehen hat:
# Escape typed in the terminal itself, not the page's Stop: no Stop hook comes13:39:13 Escape sent# the run's status as the page saw it, checked every few seconds:check 1: workingcheck 2: workingcheck 3: stopped | Stopped13:39:31 at most 18 s after the Escape (a few seconds until the screen counts as still, then 12 s of quiet)# Claude Code's screen:❯ Do what .sitesmith/request.md says. Listed 1 directory ⎿ Interrupted · What should Claude do instead?────────────────────────────────────────────────────────────❯
Wieder hilft der Bildschirm aus, als zweite Meinung: Sagen die Hooks beschäftigt, steht der Bildschirm aber seit zwölf Sekunden still an einem leeren Prompt, ist die Runde vorbei. Ersetze check():
private async check(name: string, s: SiteAgent) {
if (s.queue.length) await this.deliver(name);
const run = s.run;
const term = this.terminals.get(name);
if (!term?.claude) s.hookBusy = false;
// a turn that ends without a Stop hook (Escape in the terminal, an error): the hooks still say
// busy, but the screen has sat still at an empty prompt for a while
if (s.hookBusy && term && !term.busy && await this.terminals.atEmptyPrompt({ name })) {
if (!s.quietSince) s.quietSince = Date.now();
if (Date.now() - s.quietSince > 12000) {
s.hookBusy = false;
if (live(run)) this.end(name, 'stopped', 'The turn ended without a word: interrupted, or an error.');
}
} else s.quietSince = 0;
if (!run || !live(run)) return;
const since = Date.now() - run.sentAt;
if (!term) { if (since > 5000) this.end(name, 'failed', 'The session ended.'); return; }
if (!term.claude) { if (since > 8000) this.end(name, 'failed', 'Claude Code exited.'); return; }
// with the hooks, the Stop hook ends the run; without them, only the screen can tell
if (s.hooked) return;
if (term.busy) { run.status = 'working'; return; }
// quiet again, at an empty prompt: the turn is over. A turn too short to count as busy ends
// the same way, once it has had time to start.
if ((run.status === 'working' || since > 15000) && await this.terminals.atEmptyPrompt(run.target)) this.end(name, 'done');
}Warum zwölf Sekunden warten? Während Claude Code arbeitet, bleibt sein Eingabefeld auf dem Bildschirm, und zwar leer, ein leerer Prompt allein beweist also nichts. Was es beweist, ist ein Bildschirm, der sich eine Weile nicht bewegt hat, und ein ruhiger Moment mitten in einer Runde darf nie zählen. Ein Lauf, der so endet, ist stopped, nicht done, mit einer Notiz, die so viel sagt, wie sich sagen lässt: „The turn ended without a word: interrupted, or an error.“
Probier es aus
Starte Server und Seite wie bisher (npm start, oder npm run server und npm run dev), öffne eine Site, die schon gebaut ist, und schick eine kleine Änderung. Wenn der Lauf fertig ist, zeigt sein Panel, was Claude Code gesagt hat. Antworte darauf: Der Lauf beginnt von Neuem, und seine neue Zusammenfassung ersetzt die alte. Dann stopp einen Lauf mittendrin, einmal mit dem Stop-Knopf und einmal mit Escape im Terminal-Tab. Der erste endet sofort, der zweite nach den ruhigen Sekunden.
Die Seite hört jetzt das Ende einer Runde in den Worten von Claude Code, und du kannst darauf antworten. Was sie noch nicht beantworten kann, ist eine Frage, die Claude Code mitten in seiner Arbeit stellt: So ein Dialog wartet weiterhin im Terminal, während die Seite „working“ sagt. Das ändert der nächste Teil, und er ist das Herz der Serie: Die Fragen von Claude Code in der Seite.
Kommentare
Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.
Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.
