@@ -67,7 +67,7 @@ What the session was asked to build, and which skills it used.
 | Local spec sources read at push | A capture whose source is a local file holds only a header and a placeholder. Each push reads the file and records its current content, so the evidence follows the edits of the file. Only a regular text file of up to 1 MiB is read. Otherwise the push keeps the body that the agent wrote, or drops the capture with a warning when there is no body (spec issue-3561). | Yes | Yes | Yes | Yes |
 | Skills tracking | The evidence lists the skills that the session used, with a copy of each skill as it ran. | Yes | No | Partial | Partial |
 | Spec source pointers | Exact copies of spec sources in the transcript (full file reads and file writes) are replaced with a pointer to the spec material, so the evidence does not hold the same content two or three times (spec issue-3556). | Yes | No | No | No |
-| Pasted image pointers | Each distinct image that the user pasted into the session is stored once as an image spec entry, from the data in the transcript, with the title "Pasted image N" and no role. A repeated paste of the same image adds no entry. The inline image in the transcript is replaced with a pointer to that material. An image whose data cannot be decoded, or that the push could not store, stays inline, and the push continues. When the agent captured the same image, its entry is kept and no second entry is added (spec issue-3569). | Yes | No | No | No |
+| Pasted image pointers | Each distinct image that the user pasted into the session, including images in prompts sent while the agent was busy, is stored once as an image spec entry, from the data in the transcript, with the title "Pasted image N" and no role. A repeated paste of the same image adds no entry. The inline image in the transcript is replaced with a pointer to that material. An image whose data cannot be decoded, or that the push could not store, stays inline, and the push continues. When the agent captured the same image, its entry is kept and no second entry is added (spec issue-3569). | Yes | No | No | No |
 
 Why not Yes:
 
 
@@ -31,6 +31,11 @@ var _ trace.PastedImageFinder = (*Provider)(nil)
 const (
 	blockImage   = "image"
 	sourceBase64 = "base64"
+	// recordTypeAttachment is a record that Claude Code adds to the
+	// conversation, such as a prompt that the user queued.
+	recordTypeAttachment    = "attachment"
+	attachmentQueuedCommand = "queued_command"
+	originHuman             = "human"
 )
 
 // PastedImages returns the images that the user pasted into the session
@@ -43,8 +48,11 @@ func (p *Provider) PastedImages(raw map[string][]json.RawMessage) []trace.Pasted
 	position := 0
 	for _, key := range streamOrder(raw) {
 		for _, l := range raw[key] {
-			e, blocks := pastedImages(l)
-			for _, b := range blocks {
+			pl := pastedImages(l)
+			if pl == nil {
+				continue
+			}
+			for _, b := range pl.images {
 				position++
 				data, err := b.decode()
 				if err != nil {
@@ -65,7 +73,7 @@ func (p *Provider) PastedImages(raw map[string][]json.RawMessage) []trace.Pasted
 					Digest:    digest,
 					MediaType: b.block.object("source").str("media_type"),
 					Number:    number,
-					Timestamp: normalizeTimestamp(e.fields.str("timestamp")),
+					Timestamp: normalizeTimestamp(pl.fields.str("timestamp")),
 				})
 			}
 		}
@@ -81,13 +89,14 @@ func (p *Provider) PastedImages(raw map[string][]json.RawMessage) []trace.Pasted
 func replacePastedImages(raw map[string][]json.RawMessage, sources pointer.Sources, report pointer.Report) {
 	for _, lines := range raw {
 		for i, l := range lines {
-			e, blocks := pastedImages(l)
-			if len(blocks) == 0 {
+			pl := pastedImages(l)
+			if pl == nil {
 				continue
 			}
 
 			res := report.Finder(pointer.FinderPastedImage)
-			for _, b := range blocks {
+			changed := false
+			for _, b := range pl.images {
 				data, err := b.decode()
 				if err != nil {
 					res.Skip(pointer.ReasonInvalidImage, 1)
@@ -104,23 +113,23 @@ func replacePastedImages(raw map[string][]json.RawMessage, sources pointer.Sourc
 				res.BytesRemoved += len(b.block["source"])
 				b.block["source"] = pointer.New(material)
 				res.Replaced++
-				e.changed = true
+				changed = true
 			}
 
-			if !e.changed {
+			if !changed {
 				continue
 			}
 			// A line that cannot be written again keeps its content inline.
-			if out, err := e.encode(); err == nil {
+			if out, err := pl.encode(); err == nil {
 				lines[i] = out
 			}
 		}
 	}
 }
 
-// pastedImage is one pasted image block of a transcript entry.
+// pastedImage is one pasted image block of a transcript line.
 type pastedImage struct {
-	// block is the image block, which belongs to the content of the entry.
+	// block is the image block, which belongs to the prompt of the line.
 	block object
 	// number is the number of the paste that the agent showed to the user,
 	// or 0 when it showed none.
@@ -146,40 +155,90 @@ func (b pastedImage) decode() ([]byte, error) {
 	return data, nil
 }
 
-// pastedImages decodes a line that is a user prompt with pasted images, and
-// returns the entry and its image blocks with inline data, in order. It
-// returns no blocks for any other line.
-func pastedImages(line json.RawMessage) (*entry, []pastedImage) {
+// pastedLine is a transcript line that holds pasted images.
+type pastedLine struct {
+	fields object
+	images []pastedImage
+	// encode writes the line again, with its changed image blocks.
+	encode func() (json.RawMessage, error)
+}
+
+// pastedImages decodes a line that holds pasted images, or returns nil. Claude
+// Code writes a prompt in two shapes: a user message, or, when the user sent
+// it while the agent was busy, a queued command attachment. A queued prompt
+// is not written again as a user message, so both shapes hold pastes.
+func pastedImages(line json.RawMessage) *pastedLine {
 	if !bytes.Contains(line, []byte(`"`+blockImage+`"`)) || !bytes.Contains(line, []byte(`"`+sourceBase64+`"`)) {
-		return nil, nil
+		return nil
 	}
 
-	e := decodeEntry(line)
-	if e == nil || !isUserPrompt(e) {
-		return nil, nil
-	}
+	fields := decodeObject(line)
+	switch fields.str("type") {
+	case recordTypeUser:
+		e := newEntry(fields)
+		if e == nil || !isUserPrompt(e) {
+			return nil
+		}
 
-	var blocks []pastedImage
-	for _, b := range e.content {
-		if b.str("type") != blockImage {
-			continue
+		return newPastedLine(fields, e.content, fields["imagePasteIds"], e.encode)
+	case recordTypeAttachment:
+		att := fields.object("attachment")
+		if !isQueuedPrompt(att) {
+			return nil
 		}
-		if b.object("source").str("type") != sourceBase64 {
-			continue
+		prompt := att.objects("prompt")
+
+		return newPastedLine(fields, prompt, att["imagePasteIds"], func() (json.RawMessage, error) {
+			raw, err := marshal(prompt)
+			if err != nil {
+				return nil, err
+			}
+			att["prompt"] = raw
+			if fields["attachment"], err = marshal(att); err != nil {
+				return nil, err
+			}
+
+			return marshal(fields)
+		})
+	}
+
+	return nil
+}
+
+// newPastedLine selects the image blocks with inline data of a prompt, in
+// order, or returns nil when there is none.
+func newPastedLine(fields object, prompt []object, pasteIDs json.RawMessage, encode func() (json.RawMessage, error)) *pastedLine {
+	var images []pastedImage
+	for _, b := range prompt {
+		if b.str("type") == blockImage && b.object("source").str("type") == sourceBase64 {
+			images = append(images, pastedImage{block: b})
 		}
-		blocks = append(blocks, pastedImage{block: b})
+	}
+	if len(images) == 0 {
+		return nil
 	}
 
 	// Claude Code records the paste numbers that the user saw, one for each
 	// image of the prompt. When they do not match the images, none is used.
 	var ids []int
-	if v, ok := e.fields["imagePasteIds"]; ok && json.Unmarshal(v, &ids) == nil && len(ids) == len(blocks) {
-		for i := range blocks {
-			blocks[i].number = ids[i]
+	if json.Unmarshal(pasteIDs, &ids) == nil && len(ids) == len(images) {
+		for i := range images {
+			images[i].number = ids[i]
 		}
 	}
 
-	return e, blocks
+	return &pastedLine{fields: fields, images: images, encode: encode}
+}
+
+// isQueuedPrompt reports whether an attachment is a prompt that the user
+// sent while the agent was busy, and not one that Claude Code queued itself.
+func isQueuedPrompt(att object) bool {
+	if att.str("type") != attachmentQueuedCommand {
+		return false
+	}
+	origin := att.object("origin")
+
+	return origin == nil || origin.str("kind") == originHuman
 }
 
 // isUserPrompt reports whether the entry is a message that the user wrote,
 
@@ -61,6 +61,22 @@ func paste(text string, pasteIDs []int, images ...obj) obj {
 	return e
 }
 
+// queuedPaste is a prompt with pasted images that the user sent while the
+// agent was busy, as Claude Code writes it: an attachment that holds the
+// prompt blocks and the paste numbers. origin is the kind of its origin.
+func queuedPaste(origin string, pasteIDs []int, images ...obj) obj {
+	prompt := make([]any, 0, 1+len(images))
+	prompt = append(prompt, obj{keyType: resultText, resultText: "look at this"})
+	for _, img := range images {
+		prompt = append(prompt, img)
+	}
+
+	return obj{keyType: "attachment", "timestamp": pastedTime, "attachment": obj{
+		keyType: "queued_command", "prompt": prompt, "imagePasteIds": pasteIDs,
+		"commandMode": "prompt", "origin": obj{"kind": origin}, "humanTurn": true,
+	}}
+}
+
 func TestPastedImages(t *testing.T) {
 	testCases := []struct {
 		name string
@@ -116,6 +132,33 @@ func TestPastedImages(t *testing.T) {
 				{Data: pastedBytes, MediaType: pngType, Number: 1, Timestamp: pastedUTC},
 			},
 		},
+		{
+			name: "an image pasted while the agent was busy keeps its paste number",
+			raw: map[string][]obj{mainStream: {
+				paste("[Image #1] first", []int{1}, imageBlock(pngType, pastedBytes)),
+				queuedPaste("human", []int{2}, imageBlock("image/jpeg", otherPasted)),
+			}},
+			want: []trace.PastedImage{
+				{Data: pastedBytes, MediaType: pngType, Number: 1, Timestamp: pastedUTC},
+				{Data: otherPasted, MediaType: "image/jpeg", Number: 2, Timestamp: pastedUTC},
+			},
+		},
+		{
+			name: "a queued prompt that a human did not send is not a paste",
+			raw: map[string][]obj{mainStream: {
+				queuedPaste("task-notification", []int{1}, imageBlock(pngType, pastedBytes)),
+			}},
+		},
+		{
+			name: "another attachment with an image is not a paste",
+			raw: map[string][]obj{mainStream: {
+				func() obj {
+					e := queuedPaste("human", []int{1}, imageBlock(pngType, pastedBytes))
+					e["attachment"].(obj)[keyType] = "skill_listing"
+					return e
+				}(),
+			}},
+		},
 		{
 			name: "an image in the result of a file read is not a pasted image",
 			raw: map[string][]obj{mainStream: {
@@ -224,6 +267,22 @@ func TestReplacePastedImages(t *testing.T) {
 			},
 			wantReport: map[string]pointer.Result{pointer.FinderPastedImage: {Replaced: 2}},
 		},
+		{
+			name: "an image pasted while the agent was busy becomes a pointer in the attachment",
+			session: []obj{
+				queuedPaste("human", []int{3}, imageBlock(pngType, pastedBytes)),
+			},
+			check: func(t *testing.T, out []json.RawMessage) {
+				e := decode(t, out[0])
+				assert.Equal(t, "look at this", at(t, e, "attachment", "prompt", 0, resultText))
+				assert.Equal(t, blockImage, at(t, e, "attachment", "prompt", 1, keyType))
+				assert.Equal(t, ptr(pastedMaterial), at(t, e, "attachment", "prompt", 1, keySource))
+				// The other fields of the attachment are kept.
+				assert.Equal(t, []any{float64(3)}, at(t, e, "attachment", "imagePasteIds"))
+				assert.Equal(t, "queued_command", at(t, e, "attachment", keyType))
+			},
+			wantReport: map[string]pointer.Result{pointer.FinderPastedImage: {Replaced: 1}},
+		},
 		{
 			// The file read finder looks at the image of the result, not
 			// the pasted image finder.
 
@@ -442,7 +442,12 @@ type pendingWrite struct {
 
 // decodeEntry decodes a line whose message holds blocks, or returns nil.
 func decodeEntry(line json.RawMessage) *entry {
-	fields := decodeObject(line)
+	return newEntry(decodeObject(line))
+}
+
+// newEntry returns the entry of the decoded fields of a line whose message
+// holds blocks, or nil.
+func newEntry(fields object) *entry {
 	message := fields.object("message")
 	content := message.objects("content")
 	if content == nil {