diff --git a/README.md b/README.md
index 41dff03..6d639d5 100644
--- a/README.md
+++ b/README.md
@@ -310,7 +310,13 @@ built by one function apiece:
 
 `issueContext` (also in `prompt.go`) renders the shared issue-body/comment block all the task
 prompts embed, truncating at `maxBodyChars`/`maxCommentChars`/`maxCommentsInclu` so a very long
-issue thread can't blow the prompt out.
+issue thread can't blow the prompt out. It also drops the harness's own comments (the plan, the
+PR announcement, failure notes — anything carrying the `<!-- coding-agent-loop:...` marker) and
+bare `implement` approvals before that window is applied: none of it is information the model
+needs re-sent to itself on every turn, and on a retry the failure notes are pure noise. Only
+genuine human discussion survives the filter. `prCommentTaskPrompt` caps at `maxPRCommentsInclu`,
+`maxDiffHunkChars`, and `maxReviewsInclu` for the same reason on the PR-comment path. See issue
+#18.
 
 To change what the agent is told, edit the relevant function in `prompt.go` — `prompt_test.go`
 pins the exact wording of the harness rules (git/GitHub ownership, scope, autonomy), so a
@@ -325,6 +331,8 @@ result is parsed from a streamed JSONL transcript:
 
 ```sh
 claude --print --output-format stream-json --verbose --no-session-persistence \
+  --strict-mcp-config --disable-slash-commands \
+  --exclude-dynamic-system-prompt-sections --autocompact 200000 \
   --model <head of the role's models.json ladder> \
   --fallback-model <the rest of that ladder, comma-separated> \
   --effort <models.json "effort" for this model+role, if set> \
@@ -344,6 +352,18 @@ one for the role, otherwise the CLI's own default applies. The terminal `type: "
 (tokens used, cost, which model actually served the run, stop reason) is what gets recorded against
 the run in SQLite.
 
+The four flags on the second line are unconditional, baked-in defaults with no config knob (see
+issue #18): the daemon shells out with the operator's own environment, so without them every run
+would inherit that operator's ambient MCP servers and skills into the system prompt on every
+single turn. `--strict-mcp-config` loads zero MCP servers (the harness only needs the built-in
+file/bash tools); `--disable-slash-commands` drops the skills listing, which the harness never
+invokes anyway; `--exclude-dynamic-system-prompt-sections` moves per-machine sections (cwd, env,
+git status) out of the cached system prompt and into the first user message, improving
+prompt-cache reuse; `--autocompact 200000` bounds how large the conversation grows before
+compaction, which is what caps the per-turn cache-read cost on a long run. An operator who needs
+MCP in agent runs can still add `--mcp-config <file>` to `claude.extra_args`, which
+`--strict-mcp-config` honours.
+
 ## Responding to PR comments
 
 Once a draft PR is open, a reviewer can hand feedback back to the agent without re-labelling
diff --git a/internal/claude/runner.go b/internal/claude/runner.go
index 65bd276..1ad1158 100644
--- a/internal/claude/runner.go
+++ b/internal/claude/runner.go
@@ -123,6 +123,32 @@ func (r *Result) TokensOut() int64 {
 	return r.Usage.OutputTokens
 }
 
+// FreshTokensIn is the input tokens actually processed fresh, excluding all
+// cache traffic — the number that predicts rate-limit pressure.
+func (r *Result) FreshTokensIn() int64 {
+	if r == nil {
+		return 0
+	}
+	return r.Usage.InputTokens
+}
+
+// CacheWriteTokens is the input tokens written into the prompt cache.
+func (r *Result) CacheWriteTokens() int64 {
+	if r == nil {
+		return 0
+	}
+	return r.Usage.CacheCreationInputTokens
+}
+
+// CacheReadTokens is the input tokens served from the prompt cache, billed at
+// a fraction of fresh input and not what drives a rate limit.
+func (r *Result) CacheReadTokens() int64 {
+	if r == nil {
+		return 0
+	}
+	return r.Usage.CacheReadInputTokens
+}
+
 // Options configures one headless invocation.
 type Options struct {
 	// Binary is the claude executable.
@@ -200,6 +226,14 @@ func (r *Runner) Run(ctx context.Context, opts Options) (*Result, error) {
 		"--output-format", "stream-json",
 		"--verbose", // required alongside stream-json in print mode
 		"--no-session-persistence",
+		// Keep the per-turn system prompt to what the harness actually needs:
+		// no ambient MCP servers, no skills listing, dynamic sections moved out
+		// of the cached prefix, and a hard cap on how large the conversation
+		// grows before compaction. See issue #18.
+		"--strict-mcp-config",
+		"--disable-slash-commands",
+		"--exclude-dynamic-system-prompt-sections",
+		"--autocompact", "200000",
 	}
 	if opts.Model != "" {
 		args = append(args, "--model", opts.Model)
diff --git a/internal/claude/runner_test.go b/internal/claude/runner_test.go
index 03f9bc0..ecd1804 100644
--- a/internal/claude/runner_test.go
+++ b/internal/claude/runner_test.go
@@ -194,6 +194,42 @@ printf '{"type":"result","subtype":"success","is_error":false,"result":"%s"}\n'
 	}
 }
 
+// The harness must never load the operator's ambient MCP servers, skills, or
+// an unbounded conversation into every turn's system prompt — see issue #18.
+func TestRunPassesTokenReductionFlags(t *testing.T) {
+	bin := stubCLI(t, `cat > /dev/null
+for a in "$@"; do printf '%s\n' "$a" >> "$ARGS_FILE"; done
+echo '`+successResult+`'
+`)
+	argsFile := filepath.Join(t.TempDir(), "args.txt")
+	res, err := (&Runner{}).Run(context.Background(), Options{
+		Binary: bin, LogPath: filepath.Join(t.TempDir(), "run.jsonl"),
+		Env: []string{"ARGS_FILE=" + argsFile},
+	})
+	if err != nil {
+		t.Fatalf("run: %v", err)
+	}
+	if res == nil {
+		t.Fatal("expected a result")
+	}
+	got, err := os.ReadFile(argsFile)
+	if err != nil {
+		t.Fatalf("stub did not record args: %v", err)
+	}
+	args := string(got)
+	for _, want := range []string{
+		"--strict-mcp-config",
+		"--disable-slash-commands",
+		"--exclude-dynamic-system-prompt-sections",
+		"--autocompact",
+		"200000",
+	} {
+		if !strings.Contains(args, want) {
+			t.Errorf("invocation should include %q, got: %s", want, args)
+		}
+	}
+}
+
 func TestLogPathRequired(t *testing.T) {
 	if _, err := (&Runner{}).Run(context.Background(), Options{Binary: "true"}); err == nil {
 		t.Fatal("LogPath must be required so every run leaves a transcript")
diff --git a/internal/discord/notifier.go b/internal/discord/notifier.go
index 30a014f..9bab391 100644
--- a/internal/discord/notifier.go
+++ b/internal/discord/notifier.go
@@ -115,9 +115,7 @@ func (n *Notifier) post(e embed) {
 		return
 	}
 
-	n.wg.Add(1)
-	go func() {
-		defer n.wg.Done()
+	n.wg.Go(func() {
 		ctx, cancel := context.WithTimeout(context.Background(), postTimeout)
 		defer cancel()
 
@@ -137,7 +135,7 @@ func (n *Notifier) post(e embed) {
 		if resp.StatusCode >= 300 {
 			n.log("discord: webhook returned %d", resp.StatusCode)
 		}
-	}()
+	})
 }
 
 // postRun sends e to the webhook after making sure it carries a clickable
@@ -266,7 +264,8 @@ func (n *Notifier) ClaudeFinished(r RunRef, res *claude.Result, elapsed time.Dur
 			embedField{Name: "Model", Value: orNone(res.PrimaryModel()), Inline: true},
 			embedField{Name: "Turns", Value: fmt.Sprintf("%d", res.NumTurns), Inline: true},
 			embedField{Name: "Cost", Value: money(res.TotalCostUSD), Inline: true},
-			embedField{Name: "Tokens", Value: fmt.Sprintf("%d in / %d out", res.TokensIn(), res.TokensOut()), Inline: true},
+			embedField{Name: "Tokens", Value: fmt.Sprintf("%d in (%d new · %d written · %d cached) / %d out",
+				res.TokensIn(), res.FreshTokensIn(), res.CacheWriteTokens(), res.CacheReadTokens(), res.TokensOut()), Inline: true},
 			embedField{Name: "Duration", Value: humanDuration(elapsed), Inline: true},
 			embedField{Name: "Session", Value: orNone(res.SessionID), Inline: true},
 		),
diff --git a/internal/gate/gate.go b/internal/gate/gate.go
index c3e54b8..9a5a59f 100644
--- a/internal/gate/gate.go
+++ b/internal/gate/gate.go
@@ -160,7 +160,7 @@ type Snapshot struct {
 	Percent     float64   `json:"percent,omitempty"`
 	Enabled     bool      `json:"enabled"`
 	Note        string    `json:"note,omitempty"`
-	CooldownEnd time.Time `json:"cooldown_end,omitempty"`
+	CooldownEnd time.Time `json:"cooldown_end"`
 }
 
 // Gate evaluates and records gating state.
diff --git a/internal/install/install.go b/internal/install/install.go
index f16009d..7c8c422 100644
--- a/internal/install/install.go
+++ b/internal/install/install.go
@@ -470,12 +470,12 @@ func runSystemctl(log func(string, ...any), args ...string) error {
 }
 
 func argsString(args []string) string {
-	s := ""
+	var s strings.Builder
 	for i, a := range args {
 		if i > 0 {
-			s += " "
+			s.WriteString(" ")
 		}
-		s += a
+		s.WriteString(a)
 	}
-	return s
+	return s.String()
 }
diff --git a/internal/orchestrator/loop.go b/internal/orchestrator/loop.go
index f4c5152..4acab00 100644
--- a/internal/orchestrator/loop.go
+++ b/internal/orchestrator/loop.go
@@ -238,12 +238,10 @@ func (o *Orchestrator) tick(ctx context.Context) {
 		capacity--
 
 		cand := candidate{repo: repo, number: r.Number, title: r.Title, url: r.URL}
-		o.wg.Add(1)
-		go func() {
-			defer o.wg.Done()
+		o.wg.Go(func() {
 			defer o.releaseRepo(cand.repo)
 			o.work(ctx, cand)
-		}()
+		})
 	}
 }
 
@@ -657,7 +655,7 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 	if err != nil {
 		return fmt.Errorf("select model: %w", err)
 	}
-	if err := o.opts.Store.RecordUsage(ctx, runID, head.ID, "", 0, 0, 0, 0); err != nil {
+	if err := o.opts.Store.RecordUsage(ctx, runID, store.RunUsage{ModelID: head.ID}); err != nil {
 		log.Warn("could not pre-record model", "error", err)
 	}
 
@@ -737,8 +735,16 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 		if m := result.PrimaryModel(); m != "" {
 			usedModel = m
 		}
-		if err := o.opts.Store.RecordUsage(bookkeeping, runID, usedModel, result.SessionID,
-			result.TotalCostUSD, result.TokensIn(), result.TokensOut(), result.NumTurns); err != nil {
+		if err := o.opts.Store.RecordUsage(bookkeeping, runID, store.RunUsage{
+			ModelID:    usedModel,
+			SessionID:  result.SessionID,
+			CostUSD:    result.TotalCostUSD,
+			TokensIn:   result.TokensIn(),
+			TokensOut:  result.TokensOut(),
+			CacheRead:  result.CacheReadTokens(),
+			CacheWrite: result.CacheWriteTokens(),
+			Turns:      result.NumTurns,
+		}); err != nil {
 			log.Warn("usage record failed", "error", err)
 		}
 		// Re-record now that the model that actually served the run is known.
@@ -791,7 +797,8 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 		log.Warn("could not clear usage gate", "error", err)
 	}
 	o.opts.Discord.GateCleared()
-	o.event(ctx, runID, "claude_done", fmt.Sprintf("turns=%d cost=$%.4f", result.NumTurns, result.TotalCostUSD))
+	o.event(ctx, runID, "claude_done", fmt.Sprintf("turns=%d cost=$%.4f fresh_in=%d cached_in=%d out=%d",
+		result.NumTurns, result.TotalCostUSD, result.FreshTokensIn(), result.CacheReadTokens(), result.TokensOut()))
 
 	if phase == phasePlan {
 		if strings.TrimSpace(result.Result) == "" {
diff --git a/internal/orchestrator/loop_test.go b/internal/orchestrator/loop_test.go
index 98cc739..e39cab2 100644
--- a/internal/orchestrator/loop_test.go
+++ b/internal/orchestrator/loop_test.go
@@ -245,7 +245,7 @@ func TestTaskPromptHandlesEmptyBody(t *testing.T) {
 
 func TestTaskPromptTrimsLongDiscussions(t *testing.T) {
 	issue := gh.Issue{Number: 1, Title: "t", Body: "b"}
-	for i := 0; i < 40; i++ {
+	for range 40 {
 		issue.Comments = append(issue.Comments, gh.Comment{Author: gh.User{Login: "u"}, Body: "comment"})
 	}
 	p := implementTaskPrompt("acme/widgets", issue, "")
diff --git a/internal/orchestrator/phase.go b/internal/orchestrator/phase.go
index 9a0d804..f06681b 100644
--- a/internal/orchestrator/phase.go
+++ b/internal/orchestrator/phase.go
@@ -135,11 +135,11 @@ func extractPlan(body string) string {
 	if !isPlanComment(body) {
 		return ""
 	}
-	i := strings.Index(body, planHeader)
-	if i < 0 {
+	_, after, ok := strings.Cut(body, planHeader)
+	if !ok {
 		return ""
 	}
-	plan := body[i+len(planHeader):]
+	plan := after
 
 	// The footer is matched from the end: a plan may well contain its own
 	// horizontal rule, and only the last one is the comment's own.
diff --git a/internal/orchestrator/prcomments.go b/internal/orchestrator/prcomments.go
index dc21817..7ef36e4 100644
--- a/internal/orchestrator/prcomments.go
+++ b/internal/orchestrator/prcomments.go
@@ -34,7 +34,7 @@ func mentionsAgent(body, handle string) bool {
 		return false
 	}
 	inFence := false
-	for _, line := range strings.Split(body, "\n") {
+	for line := range strings.SplitSeq(body, "\n") {
 		trimmed := strings.TrimSpace(line)
 		if strings.HasPrefix(trimmed, "```") {
 			inFence = !inFence
@@ -238,12 +238,10 @@ func (o *Orchestrator) tickPRComments(ctx context.Context, capacity int) int {
 		capacity--
 
 		cand := candidate{repo: repo, number: r.Number, title: pr.Title, url: pr.URL}
-		o.wg.Add(1)
-		go func() {
-			defer o.wg.Done()
+		o.wg.Go(func() {
 			defer o.releaseRepo(cand.repo)
 			o.workPRComments(ctx, cand, pr, pending)
-		}()
+		})
 	}
 	return capacity
 }
@@ -382,7 +380,7 @@ func (o *Orchestrator) executePRComments(ctx context.Context, log *slog.Logger,
 	if err != nil {
 		return fmt.Errorf("select model: %w", err)
 	}
-	if err := o.opts.Store.RecordUsage(ctx, runID, head.ID, "", 0, 0, 0, 0); err != nil {
+	if err := o.opts.Store.RecordUsage(ctx, runID, store.RunUsage{ModelID: head.ID}); err != nil {
 		log.Warn("could not pre-record model", "error", err)
 	}
 	if err := o.opts.Store.SetRunStatus(ctx, runID, store.StatusWorking); err != nil {
@@ -432,8 +430,16 @@ func (o *Orchestrator) executePRComments(ctx context.Context, log *slog.Logger,
 		if m := result.PrimaryModel(); m != "" {
 			usedModel = m
 		}
-		if err := o.opts.Store.RecordUsage(ctx, runID, usedModel, result.SessionID,
-			result.TotalCostUSD, result.TokensIn(), result.TokensOut(), result.NumTurns); err != nil {
+		if err := o.opts.Store.RecordUsage(ctx, runID, store.RunUsage{
+			ModelID:    usedModel,
+			SessionID:  result.SessionID,
+			CostUSD:    result.TotalCostUSD,
+			TokensIn:   result.TokensIn(),
+			TokensOut:  result.TokensOut(),
+			CacheRead:  result.CacheReadTokens(),
+			CacheWrite: result.CacheWriteTokens(),
+			Turns:      result.NumTurns,
+		}); err != nil {
 			log.Warn("usage record failed", "error", err)
 		}
 		o.recordSession(ctx, log, cand, runID, result.SessionID, usedModel)
@@ -476,7 +482,8 @@ func (o *Orchestrator) executePRComments(ctx context.Context, log *slog.Logger,
 		log.Warn("could not clear usage gate", "error", err)
 	}
 	o.opts.Discord.GateCleared()
-	o.event(ctx, runID, "claude_done", fmt.Sprintf("turns=%d cost=$%.4f", result.NumTurns, result.TotalCostUSD))
+	o.event(ctx, runID, "claude_done", fmt.Sprintf("turns=%d cost=$%.4f fresh_in=%d cached_in=%d out=%d",
+		result.NumTurns, result.TotalCostUSD, result.FreshTokensIn(), result.CacheReadTokens(), result.TokensOut()))
 
 	hasWork, err := o.opts.Git.HasWork(ctx, worktree, pr.HeadRefName)
 	if err != nil {
diff --git a/internal/orchestrator/progress_test.go b/internal/orchestrator/progress_test.go
index f8b9e8e..4db5ab8 100644
--- a/internal/orchestrator/progress_test.go
+++ b/internal/orchestrator/progress_test.go
@@ -31,7 +31,7 @@ func TestProgressHeartbeatIsRateLimited(t *testing.T) {
 	if first != 1 {
 		t.Fatalf("the first event past the interval should report, got %d lines:\n%s", first, buf.String())
 	}
-	for i := 0; i < 50; i++ {
+	for range 50 {
 		p.observe("assistant", assistantEvent(t, "Bash"))
 	}
 	if got := strings.Count(buf.String(), "claude still working"); got != 1 {
diff --git a/internal/orchestrator/prompt.go b/internal/orchestrator/prompt.go
index 7550376..729bb93 100644
--- a/internal/orchestrator/prompt.go
+++ b/internal/orchestrator/prompt.go
@@ -8,10 +8,24 @@ import (
 )
 
 // maxCommentChars bounds how much issue discussion goes into the prompt.
+// Kept tight because this is paid on every turn of every run: see issue #18.
 const (
-	maxBodyChars     = 12000
-	maxCommentChars  = 2000
-	maxCommentsInclu = 12
+	maxBodyChars     = 6000
+	maxCommentChars  = 1200
+	maxCommentsInclu = 6
+
+	// maxPlanChars bounds the approved/previous plan carried into a prompt.
+	// truncate appends truncationSuffix, and extractPlan deliberately refuses
+	// to recover a plan ending in it, so this only bites on a runaway plan —
+	// comfortably above any real one (~5K tokens).
+	maxPlanChars = 20000
+
+	// maxPRCommentsInclu, maxDiffHunkChars and maxReviewsInclu bound
+	// prCommentTaskPrompt, which otherwise renders every pending comment and
+	// review with no cap at all.
+	maxPRCommentsInclu = 10
+	maxDiffHunkChars   = 800
+	maxReviewsInclu    = 3
 )
 
 // systemPrompt states the rules of the harness. It is deliberately short and
@@ -151,6 +165,12 @@ func prCommentTaskPrompt(repo string, pr gh.PullRequest, comments []gh.PRComment
 	}
 
 	b.WriteString("### Comments to address\n\n")
+	// Keep the most recent comments: a big review pass can leave dozens
+	// pending, and the newest ones are the ones still relevant.
+	if len(comments) > maxPRCommentsInclu {
+		fmt.Fprintf(&b, "(showing the last %d of %d comments)\n\n", maxPRCommentsInclu, len(comments))
+		comments = comments[len(comments)-maxPRCommentsInclu:]
+	}
 	for _, c := range comments {
 		author := c.Author
 		if author == "" {
@@ -165,7 +185,7 @@ func prCommentTaskPrompt(repo string, pr gh.PullRequest, comments []gh.PRComment
 			b.WriteString(":\n\n")
 			if c.DiffHunk != "" {
 				b.WriteString("```diff\n")
-				b.WriteString(truncate(c.DiffHunk, maxCommentChars))
+				b.WriteString(truncate(c.DiffHunk, maxDiffHunkChars))
 				b.WriteString("\n```\n\n")
 			}
 		}
@@ -173,6 +193,9 @@ func prCommentTaskPrompt(repo string, pr gh.PullRequest, comments []gh.PRComment
 
 	if len(reviews) > 0 {
 		b.WriteString("### Review summaries (context only)\n\n")
+		if len(reviews) > maxReviewsInclu {
+			reviews = reviews[len(reviews)-maxReviewsInclu:]
+		}
 		for _, r := range reviews {
 			fmt.Fprintf(&b, "%s\n\n", truncate(strings.TrimSpace(r), maxCommentChars))
 		}
@@ -205,9 +228,21 @@ func issueContext(repo string, issue gh.Issue) string {
 	}
 	fmt.Fprintf(&b, "### Description\n\n%s\n", truncate(body, maxBodyChars))
 
-	if len(issue.Comments) > 0 {
+	// The model does not need its own prior narration read back to it: the
+	// plan, the PR announcement, and every failure comment the harness itself
+	// wrote carry no information the "Approved plan" section doesn't already
+	// state, and on a retry they are pure noise. Bare approvals ("implement")
+	// carry nothing beyond that either. See issue #18.
+	var comments []gh.Comment
+	for _, c := range issue.Comments {
+		if isAgentComment(c.Body) || isApproval(c.Body) {
+			continue
+		}
+		comments = append(comments, c)
+	}
+
+	if len(comments) > 0 {
 		b.WriteString("\n### Discussion\n\n")
-		comments := issue.Comments
 		// Keep the most recent discussion: that is where the requirements
 		// usually get refined.
 		if len(comments) > maxCommentsInclu {
@@ -241,7 +276,7 @@ func planTaskPrompt(repo string, issue gh.Issue, previousPlan string) string {
 
 	if previousPlan != "" {
 		b.WriteString("\n### Previous plan\n\n")
-		b.WriteString(previousPlan)
+		b.WriteString(truncate(previousPlan, maxPlanChars))
 		b.WriteString("\n\nA reviewer replied with feedback (see the newest comment in the discussion above) " +
 			"instead of approving this plan. Revise the plan to address it; keep whatever still holds.\n")
 	}
@@ -262,7 +297,7 @@ func implementTaskPrompt(repo string, issue gh.Issue, plan string) string {
 		b.WriteString("\n### Approved plan\n\n")
 		b.WriteString("A human reviewed and approved the following plan. Follow it; deviate only where it is " +
 			"demonstrably wrong, and say so in your final summary.\n\n")
-		b.WriteString(plan)
+		b.WriteString(truncate(plan, maxPlanChars))
 		b.WriteString("\n")
 	}
 
diff --git a/internal/orchestrator/prompt_test.go b/internal/orchestrator/prompt_test.go
index 6d98a8e..71e7bb1 100644
--- a/internal/orchestrator/prompt_test.go
+++ b/internal/orchestrator/prompt_test.go
@@ -107,3 +107,85 @@ func TestPRCommentSystemPromptForbidsCreatingPRs(t *testing.T) {
 		}
 	}
 }
+
+// PR comments beyond maxPRCommentsInclu must be dropped, keeping the newest.
+func TestPRCommentTaskPromptCapsCommentCount(t *testing.T) {
+	pr := gh.PullRequest{Number: 12, Title: "Add retry logic"}
+	var comments []gh.PRComment
+	for i := range maxPRCommentsInclu + 5 {
+		comments = append(comments, gh.PRComment{Author: "alice", Body: strings.Repeat("x", 10) + " " + string(rune('a'+i))})
+	}
+	p := prCommentTaskPrompt("acme/widgets", pr, comments, nil)
+	if !strings.Contains(p, "showing the last") {
+		t.Fatalf("prompt should say how many comments were dropped:\n%s", p)
+	}
+	// The oldest comment's marker must be gone; the newest must survive.
+	oldest := string(rune('a' + 0))
+	newest := string(rune('a' + len(comments) - 1))
+	if strings.Contains(p, "x "+oldest) {
+		t.Fatalf("oldest comment should have been dropped:\n%s", p)
+	}
+	if !strings.Contains(p, "x "+newest) {
+		t.Fatalf("newest comment should be kept:\n%s", p)
+	}
+}
+
+// The harness's own comments (plan, PR announcement, failure notes) and bare
+// approvals carry nothing the "Approved plan" section doesn't already state,
+// and on a retry they are pure noise fed back to the model. See issue #18.
+func TestIssueContextFiltersOutAgentCommentsAndApprovals(t *testing.T) {
+	issue := gh.Issue{Number: 7, Title: "Add retry logic", Comments: []gh.Comment{
+		{Author: gh.User{Login: "the-bot"}, Body: markerPlan + "\n\n## Plan\n\nDo the thing."},
+		{Author: gh.User{Login: "alice"}, Body: "please also handle timeouts"},
+		{Author: gh.User{Login: "alice"}, Body: "implement"},
+		{Author: gh.User{Login: "the-bot"}, Body: markerFailure + "\n\nrun failed: boom"},
+	}}
+	p := issueContext("acme/widgets", issue)
+	if strings.Contains(p, "boom") || strings.Contains(p, "Do the thing") {
+		t.Fatalf("harness-authored comments must be filtered out:\n%s", p)
+	}
+	if strings.Contains(p, "implement") {
+		t.Fatalf("a bare approval must be filtered out:\n%s", p)
+	}
+	if !strings.Contains(p, "please also handle timeouts") {
+		t.Fatalf("genuine human feedback must survive the filter:\n%s", p)
+	}
+}
+
+// When filtering leaves no comments at all, the Discussion header must not
+// appear — an empty section is worse than none.
+func TestIssueContextOmitsEmptyDiscussion(t *testing.T) {
+	issue := gh.Issue{Number: 7, Title: "Add retry logic", Comments: []gh.Comment{
+		{Author: gh.User{Login: "the-bot"}, Body: markerPlan + "\n\n## Plan\n\nDo the thing."},
+		{Author: gh.User{Login: "alice"}, Body: "implement"},
+	}}
+	p := issueContext("acme/widgets", issue)
+	if strings.Contains(p, "### Discussion") {
+		t.Fatalf("an all-filtered discussion should omit the header entirely:\n%s", p)
+	}
+}
+
+// A real-shaped implement prompt must stay well under the old worst case
+// (~36K chars for the issue alone, plus an untruncated plan on top). This is
+// a regression guard against the constants drifting back up.
+func TestImplementTaskPromptStaysBounded(t *testing.T) {
+	issue := gh.Issue{
+		Number: 42,
+		Title:  "A moderately complex feature request",
+		Body:   strings.Repeat("This is the issue body. ", 1000), // ~24K chars
+	}
+	for i := range 20 {
+		body := strings.Repeat("Some discussion text. ", 200) // ~4.6K chars
+		if i%2 == 0 {
+			body = markerFailure + "\n\n" + body
+		}
+		issue.Comments = append(issue.Comments, gh.Comment{Author: gh.User{Login: "someone"}, Body: body})
+	}
+	plan := strings.Repeat("Plan detail line.\n", 3000) // ~57K chars
+
+	p := implementTaskPrompt("acme/widgets", issue, plan)
+	const ceiling = 40000
+	if len(p) > ceiling {
+		t.Fatalf("implement prompt is %d chars, want under %d", len(p), ceiling)
+	}
+}
diff --git a/internal/server/server_test.go b/internal/server/server_test.go
index 57c8866..fb14c60 100644
--- a/internal/server/server_test.go
+++ b/internal/server/server_test.go
@@ -526,7 +526,7 @@ func TestLoginThrottlesRepeatedFailures(t *testing.T) {
 	s, _, _ := withPassword(t, "hunter2")
 
 	var lastCode int
-	for i := 0; i < throttleMax+1; i++ {
+	for range throttleMax + 1 {
 		lastCode, _ = do(t, s, http.MethodPost, "/login", strings.NewReader(`{"password":"nope"}`))
 	}
 	if lastCode != http.StatusTooManyRequests {
diff --git a/internal/store/store.go b/internal/store/store.go
index 6fd2138..a3b37d6 100644
--- a/internal/store/store.go
+++ b/internal/store/store.go
@@ -91,17 +91,21 @@ type Run struct {
 	PRURL     string
 	Status    string
 	// Kind is RunKindIssue or RunKindPRComment.
-	Kind         string
-	StartedAt    time.Time
-	EndedAt      time.Time
-	CostUSD      float64
-	TokensIn     int64
-	TokensOut    int64
-	NumTurns     int
-	SessionID    string
-	VerifyStatus string
-	Error        string
-	LogPath      string
+	Kind      string
+	StartedAt time.Time
+	EndedAt   time.Time
+	CostUSD   float64
+	TokensIn  int64
+	TokensOut int64
+	// TokensCacheRead and TokensCacheWrite are the split-out subset of
+	// TokensIn that was cache traffic rather than fresh input. See issue #18.
+	TokensCacheRead  int64
+	TokensCacheWrite int64
+	NumTurns         int
+	SessionID        string
+	VerifyStatus     string
+	Error            string
+	LogPath          string
 }
 
 // Gate is a reason the loop is not claiming new work.
@@ -298,6 +302,12 @@ var migrations = []string{
 		PRIMARY KEY (comment_kind, comment_id)
 	);
 	CREATE INDEX IF NOT EXISTS pr_comment_tasks_pr ON pr_comment_tasks(repo, pr);`,
+
+	// Splits the cache-heavy portion out of tokens_in so the dashboard can show
+	// how much of a run's reported usage was fresh input versus cache traffic,
+	// which is billed at a fraction and is not what drives a rate limit.
+	`ALTER TABLE runs ADD COLUMN tokens_cache_read  INTEGER NOT NULL DEFAULT 0;
+	ALTER TABLE runs ADD COLUMN tokens_cache_write INTEGER NOT NULL DEFAULT 0;`,
 }
 
 func (s *Store) migrate(ctx context.Context) error {
@@ -449,15 +459,29 @@ func (s *Store) SetRunStatus(ctx context.Context, runID, status string) error {
 	return nil
 }
 
+// RunUsage is what one Claude invocation cost, passed to RecordUsage.
+type RunUsage struct {
+	ModelID    string
+	SessionID  string
+	CostUSD    float64
+	TokensIn   int64
+	TokensOut  int64
+	CacheRead  int64
+	CacheWrite int64
+	Turns      int
+}
+
 // RecordUsage stores what one Claude invocation cost.
-func (s *Store) RecordUsage(ctx context.Context, runID, modelID, sessionID string, cost float64, in, out int64, turns int) error {
+func (s *Store) RecordUsage(ctx context.Context, runID string, u RunUsage) error {
 	_, err := s.db.ExecContext(ctx, `
 		UPDATE runs SET
 			model_id   = CASE WHEN ? <> '' THEN ? ELSE model_id END,
 			session_id = CASE WHEN ? <> '' THEN ? ELSE session_id END,
-			cost_usd = ?, tokens_in = ?, tokens_out = ?, num_turns = ?
+			cost_usd = ?, tokens_in = ?, tokens_out = ?,
+			tokens_cache_read = ?, tokens_cache_write = ?, num_turns = ?
 		WHERE id = ?`,
-		modelID, modelID, sessionID, sessionID, cost, in, out, turns, runID)
+		u.ModelID, u.ModelID, u.SessionID, u.SessionID, u.CostUSD, u.TokensIn, u.TokensOut,
+		u.CacheRead, u.CacheWrite, u.Turns, runID)
 	if err != nil {
 		return fmt.Errorf("record usage for run %s: %w", runID, err)
 	}
@@ -577,14 +601,14 @@ var errNoRows = errors.New("not found")
 var ErrNotFound = errNoRows
 
 const runColumns = `id, repo, issue, attempt, model_id, branch, pr_url, status, kind, created_at, started_at, ended_at,
-	cost_usd, tokens_in, tokens_out, num_turns, session_id, verify_status, error, log_path`
+	cost_usd, tokens_in, tokens_out, tokens_cache_read, tokens_cache_write, num_turns, session_id, verify_status, error, log_path`
 
 func scanRun(sc interface{ Scan(...any) error }) (Run, error) {
 	var r Run
 	var created, started, ended int64
 	err := sc.Scan(&r.ID, &r.Repo, &r.Issue, &r.Attempt, &r.ModelID, &r.Branch, &r.PRURL, &r.Status, &r.Kind,
-		&created, &started, &ended, &r.CostUSD, &r.TokensIn, &r.TokensOut, &r.NumTurns, &r.SessionID,
-		&r.VerifyStatus, &r.Error, &r.LogPath)
+		&created, &started, &ended, &r.CostUSD, &r.TokensIn, &r.TokensOut, &r.TokensCacheRead, &r.TokensCacheWrite,
+		&r.NumTurns, &r.SessionID, &r.VerifyStatus, &r.Error, &r.LogPath)
 	if err != nil {
 		return r, err
 	}
diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index 8062d32..c39b5c8 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -75,7 +75,7 @@ func TestConcurrentClaimsElectOneWinner(t *testing.T) {
 		wins int
 	)
 	start := make(chan struct{})
-	for i := 0; i < workers; i++ {
+	for i := range workers {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
@@ -151,7 +151,10 @@ func TestRunLifecycleAndHistory(t *testing.T) {
 	if err := st.CreateRun(ctx, run); err != nil {
 		t.Fatalf("create run: %v", err)
 	}
-	if err := st.RecordUsage(ctx, "r1", "claude-opus-5", "sess", 0.25, 1200, 300, 4); err != nil {
+	if err := st.RecordUsage(ctx, "r1", RunUsage{
+		ModelID: "claude-opus-5", SessionID: "sess", CostUSD: 0.25,
+		TokensIn: 1200, TokensOut: 300, CacheRead: 900, CacheWrite: 100, Turns: 4,
+	}); err != nil {
 		t.Fatalf("record usage: %v", err)
 	}
 	if err := st.SetVerifyStatus(ctx, "r1", VerifyPassed); err != nil {
@@ -168,7 +171,8 @@ func TestRunLifecycleAndHistory(t *testing.T) {
 	if err != nil {
 		t.Fatalf("get run: %v", err)
 	}
-	if got.CostUSD != 0.25 || got.TokensIn != 1200 || got.ModelID != "claude-opus-5" {
+	if got.CostUSD != 0.25 || got.TokensIn != 1200 || got.ModelID != "claude-opus-5" ||
+		got.TokensCacheRead != 900 || got.TokensCacheWrite != 100 {
 		t.Fatalf("usage not persisted: %+v", got)
 	}
 	if got.Status != StatusPROpen || got.EndedAt.IsZero() {
@@ -282,7 +286,7 @@ func TestGetRunNotFound(t *testing.T) {
 
 func TestMigrationsAreIdempotent(t *testing.T) {
 	path := filepath.Join(t.TempDir(), "state.db")
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		st, err := Open(path)
 		if err != nil {
 			t.Fatalf("open %d: %v", i, err)
@@ -441,7 +445,7 @@ func TestSessionsAreRecordedAndLookedUpByIssue(t *testing.T) {
 		t.Fatalf("run session id = %q", run.SessionID)
 	}
 	// A result event with no session must not wipe what is already known.
-	if err := st.RecordUsage(ctx, "r1", "claude-opus-5", "", 0.1, 10, 5, 2); err != nil {
+	if err := st.RecordUsage(ctx, "r1", RunUsage{ModelID: "claude-opus-5", CostUSD: 0.1, TokensIn: 10, TokensOut: 5, Turns: 2}); err != nil {
 		t.Fatal(err)
 	}
 	if run, _ := st.GetRun(ctx, "r1"); run.SessionID != "sess-abc" {
@@ -661,6 +665,39 @@ func TestMigrationAddsKindAndPRCommentTasks(t *testing.T) {
 	}
 }
 
+func TestMigrationAddsCacheTokenColumns(t *testing.T) {
+	ctx := context.Background()
+	path := filepath.Join(t.TempDir(), "state.db")
+
+	st, err := Open(path)
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	if err := st.CreateRun(ctx, Run{ID: "r1", Repo: "o/r", Issue: 1, Status: StatusClaimed, StartedAt: time.Now()}); err != nil {
+		t.Fatal(err)
+	}
+	if err := st.RecordUsage(ctx, "r1", RunUsage{
+		ModelID: "claude-opus-5", CostUSD: 0.1, TokensIn: 1000, TokensOut: 50,
+		CacheRead: 900, CacheWrite: 80, Turns: 3,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	st.Close()
+
+	// Reopening re-runs migrate(), exercising it against an already-migrated
+	// database, which must be a no-op rather than an error.
+	st2, err := Open(path)
+	if err != nil {
+		t.Fatalf("reopen: %v", err)
+	}
+	defer st2.Close()
+
+	got, err := st2.GetRun(ctx, "r1")
+	if err != nil || got.TokensCacheRead != 900 || got.TokensCacheWrite != 80 {
+		t.Fatalf("cache token columns not preserved across reopen: %+v, err=%v", got, err)
+	}
+}
+
 // A run stopped from outside is nobody's fault. Counting it would back the
 // issue off for hours because someone restarted the daemon.
 func TestCancelledRunsAreNeitherAttemptsNorFailures(t *testing.T) {
diff --git a/internal/web/assets/app.js b/internal/web/assets/app.js
index 158d106..2e74fbf 100644
--- a/internal/web/assets/app.js
+++ b/internal/web/assets/app.js
@@ -137,6 +137,17 @@ function fmtTokens(value) {
   return String(n);
 }
 
+// Splits tokens_in into fresh input vs. cache traffic: on an agentic run the
+// whole conversation prefix is re-read from cache every turn, so the total
+// alone makes usage look far higher than what actually drove a rate limit.
+function fmtTokensBreakdown(run) {
+  const total = fmtTokens(run.TokensIn);
+  const cacheRead = Number(run.TokensCacheRead) || 0;
+  const cacheWrite = Number(run.TokensCacheWrite) || 0;
+  const fresh = Number(run.TokensIn) - cacheRead - cacheWrite;
+  return `${total} in (${fmtTokens(fresh)} new · ${fmtTokens(cacheWrite)} written · ${fmtTokens(cacheRead)} cached)`;
+}
+
 const STATUS_KIND = {
   pr_open: "ok",
   addressed: "ok",
@@ -646,7 +657,7 @@ function runsTableBody(runs) {
         td("Model", r.ModelID || "—"),
         td("Attempt", String(r.Attempt ?? "—")),
         td("Cost", fmtUSD(r.CostUSD)),
-        td("Tokens", `${fmtTokens(r.TokensIn)} in / ${fmtTokens(r.TokensOut)} out`),
+        td("Tokens", `${fmtTokensBreakdown(r)} / ${fmtTokens(r.TokensOut)} out`),
         td("Verify", r.VerifyStatus || "—"),
         td("Duration", fmtDuration(r.StartedAt, r.EndedAt)),
         td("PR", prCell),
@@ -682,7 +693,7 @@ async function renderRunDetail(id, silent) {
     ["Branch", run.Branch || "—"],
     ["Session", run.SessionID || "—"],
     ["Cost", fmtUSD(run.CostUSD)],
-    ["Tokens in", fmtTokens(run.TokensIn)],
+    ["Tokens in", fmtTokensBreakdown(run)],
     ["Tokens out", fmtTokens(run.TokensOut)],
     ["Turns", run.NumTurns],
     ["Verify", run.VerifyStatus || "—"],
