@gajae-code/coding-agent 0.13.2 → 0.14.0

package/src/session/yield-queue.ts

@@ -4,6 +4,13 @@ import { logger } from "@gajae-code/utils";
 export interface YieldDispatcher<P> {
 	/** Drop entries already delivered through another path. Called per-entry at flush time. */
 	isStale?(entry: P): boolean;
+	/**
+	 * Optional ownership-origin key: when provided, the flush builds ONE
+	 * message per distinct key instead of one message for the whole batch, so
+	 * a later scope:"owned" drop of one origin never suppresses entries of
+	 * another origin (review thread P2).
+	 */
+	groupKey?(entry: P): string;
 	/** Produce one batched AgentMessage from non-stale entries. Return null to skip. */
 	build(survivors: P[]): AgentMessage | null;
 }
@@ -19,6 +26,7 @@ type YieldFlushMode = "streaming" | "idle";
 
 interface StoredDispatcher {
 	isStale?: (entry: unknown) => boolean;
+	groupKey?: (entry: unknown) => string;
 	build: (survivors: unknown[]) => AgentMessage | null;
 }
 
@@ -39,6 +47,7 @@ export class YieldQueue {
 	register<P>(kind: string, dispatcher: YieldDispatcher<P>): () => void {
 		const stored: StoredDispatcher = {
 			...(dispatcher.isStale ? { isStale: entry => dispatcher.isStale?.(entry as P) ?? false } : {}),
+			...(dispatcher.groupKey ? { groupKey: entry => dispatcher.groupKey?.(entry as P) ?? "default" } : {}),
 			build: survivors => dispatcher.build(survivors as P[]),
 		};
 		this.#dispatchers.set(kind, stored);
@@ -81,16 +90,17 @@ export class YieldQueue {
 		for (const [kind, dispatcher] of this.#dispatchers) {
 			const entries = this.#drain(kind);
 			if (entries.length === 0) continue;
-			const message = this.#build(kind, dispatcher, entries);
-			if (!message) continue;
-			if (mode === "streaming") {
-				try {
-					this.#options.injectStreaming(message);
-				} catch (error) {
-					logger.warn("Yield queue streaming dispatch failed", { kind, error: formatError(error) });
+			const messages = this.#build(kind, dispatcher, entries) ?? [];
+			for (const message of messages) {
+				if (mode === "streaming") {
+					try {
+						this.#options.injectStreaming(message);
+					} catch (error) {
+						logger.warn("Yield queue streaming dispatch failed", { kind, error: formatError(error) });
+					}
+				} else {
+					idleMessages.push(message);
 				}
-			} else {
-				idleMessages.push(message);
 			}
 		}
 		if (mode === "idle" && idleMessages.length > 0) {
@@ -149,7 +159,16 @@ export class YieldQueue {
 		return entries;
 	}
 
-	#build(kind: string, dispatcher: StoredDispatcher, entries: unknown[]): AgentMessage | null {
+	#build(kind: string, dispatcher: StoredDispatcher, entries: unknown[]): AgentMessage[] | null {
+		// Corrected turn semantics (terminal abort): turn-scope abort blocks only
+		// deliveries whose origin is a continuation of the aborted turn.
+		// Owned-completion deliveries from work deliberately left running are
+		// intentionally allowed to resume the agent through the normal
+		// followUp/prompt path and receive a fresh turn attempt. A closed
+		// terminal record must never make an allowed owned-completion entry
+		// stale merely because it is closed; stale filtering below applies only
+		// to ordinary manager state (e.g. isDeliverySuppressed) or explicit
+		// blocked-continuation/owned-cleanup entries.
 		const survivors: unknown[] = [];
 		for (const entry of entries) {
 			if (dispatcher.isStale) {
@@ -165,11 +184,34 @@ export class YieldQueue {
 			survivors.push(entry);
 		}
 		if (survivors.length === 0) return null;
-		try {
-			return dispatcher.build(survivors);
-		} catch (error) {
-			logger.warn("Yield queue build failed", { kind, error: formatError(error) });
-			return null;
+		// Build one message per ownership-origin group (when the dispatcher
+		// declares a groupKey) so a later owned-scope drop of one group never
+		// suppresses another group's entries. Groups are partitioned into
+		// CONTIGUOUS origin runs (preserving the queued FIFO chronology): with
+		// entries A1, B1, A2, a map grouping every A together would deliver A2
+		// before the earlier B1, changing the observable order of async results
+		// (review thread P2).
+		const groups: unknown[][] = [];
+		let currentGroupKey: string | undefined;
+		for (const entry of survivors) {
+			const key = dispatcher.groupKey ? dispatcher.groupKey(entry) : "default";
+			const last = groups[groups.length - 1];
+			if (last !== undefined && currentGroupKey === key) {
+				last.push(entry);
+			} else {
+				groups.push([entry]);
+				currentGroupKey = key;
+			}
+		}
+		const messages: AgentMessage[] = [];
+		for (const group of groups.values()) {
+			try {
+				const message = dispatcher.build(group);
+				if (message) messages.push(message);
+			} catch (error) {
+				logger.warn("Yield queue build failed", { kind, error: formatError(error) });
+			}
 		}
+		return messages.length > 0 ? messages : null;
 	}
 }

package/src/session-import/claude.ts

@@ -0,0 +1,334 @@
+/**
+ * Claude adapter (issue #3709).
+ *
+ * Parses two first-party observable Claude transcript/export shapes:
+ *
+ * 1. `claude-code-jsonl` — Claude Code session transcripts
+ *    (`~/.claude/projects/<project-slug>/<session-uuid>.jsonl`), one JSON object
+ *    per line with `type: "user" | "assistant" | "summary" | "system" | …`.
+ * 2. `claude-export-json` — the claude.ai data export (`conversations.json`):
+ *    a JSON array of conversations (or a single conversation object) whose
+ *    `chat_messages` carry `sender: "human" | "assistant"` and `content` blocks.
+ *
+ * The same quarantine contract as the Codex adapter applies: unmappable
+ * records/messages are counted and digested, never silently dropped.
+ */
+
+import { createHash } from "node:crypto";
+import { redactImportedText } from "./redact";
+import type { ImportedConversation, ImportedMessage, ImportQuarantineRecord, SessionImportCounts } from "./types";
+
+type JsonRecord = Record<string, unknown>;
+
+export interface ClaudeParseResult {
+	conversation: ImportedConversation;
+	quarantine: ImportQuarantineRecord[];
+	counts: SessionImportCounts;
+	redactionKinds: string[];
+}
+
+const MAX_EVIDENCE_LINE_CHARS = 400;
+const MAX_EVIDENCE_LINES = 100;
+const MAX_EVIDENCE_BYTES = 8 * 1024;
+
+function isRecord(value: unknown): value is JsonRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function sha256Hex(text: string): string {
+	return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+function boundEvidence(text: string): string {
+	const singleLine = text.replace(/\s+/g, " ").trim();
+	if (singleLine.length <= MAX_EVIDENCE_LINE_CHARS) return singleLine;
+	return `${singleLine.slice(0, MAX_EVIDENCE_LINE_CHARS - 1)}…`;
+}
+
+class ParseSink {
+	static readonly MAX_QUARANTINE_RECORDS = 512;
+	readonly messages: ImportedMessage[] = [];
+	readonly quarantine: ImportQuarantineRecord[] = [];
+	readonly counts: SessionImportCounts = { mapped: 0, quarantined: 0, redacted: 0, omitted: 0 };
+	readonly redactionKinds = new Set<string>();
+	#evidence: string[] = [];
+	#evidenceBytes = 0;
+	evidenceTruncated = false;
+	#current: ImportedMessage | undefined;
+
+	redact(input: string): string {
+		const result = redactImportedText(input);
+		this.counts.redacted += result.redacted;
+		for (const kind of result.kinds) this.redactionKinds.add(kind);
+		return result.value;
+	}
+
+	quarantineRecord(record: number, raw: string, reason: ImportQuarantineRecord["reason"]): void {
+		if (this.quarantine.length < ParseSink.MAX_QUARANTINE_RECORDS) {
+			this.quarantine.push({ record, byteLength: Buffer.byteLength(raw, "utf8"), sha256: sha256Hex(raw), reason });
+		}
+		this.counts.quarantined++;
+	}
+
+	addEvidence(line: string): void {
+		if (line.length === 0) return;
+		if (this.#evidence.length >= MAX_EVIDENCE_LINES || this.#evidenceBytes + line.length > MAX_EVIDENCE_BYTES) {
+			this.evidenceTruncated = true;
+			return;
+		}
+		this.#evidence.push(line);
+		this.#evidenceBytes += line.length;
+	}
+
+	closeEvidence(): void {
+		if (this.#current && this.#evidence.length > 0) {
+			this.#current.toolEvidence = [...(this.#current.toolEvidence ?? []), ...this.#evidence];
+		}
+		this.#evidence = [];
+		this.#evidenceBytes = 0;
+	}
+
+	/** Assemble visible text into the running conversation. `mapped` is counted by the caller. */
+	pushMessage(role: "user" | "assistant", rawText: string, timestamp?: string): void {
+		const sanitized = this.redact(rawText).trim();
+		if (role === "user") {
+			this.closeEvidence();
+			if (!sanitized) {
+				this.#current = undefined;
+				return;
+			}
+			this.#current = { role, text: sanitized, ...(timestamp ? { timestamp } : {}) };
+			this.messages.push(this.#current);
+			return;
+		}
+		if (!sanitized) return;
+		if (this.#current?.role === "assistant") {
+			this.#current.text = this.#current.text ? `${this.#current.text}\n\n${sanitized}` : sanitized;
+		} else {
+			this.closeEvidence();
+			this.#current = { role, text: sanitized, ...(timestamp ? { timestamp } : {}) };
+			this.messages.push(this.#current);
+		}
+	}
+}
+
+function toolUseSummary(input: unknown): string {
+	if (!isRecord(input)) return "";
+	if (typeof input.command === "string") return input.command;
+	if (typeof input.file_path === "string") return input.file_path;
+	if (typeof input.path === "string") return input.path;
+	if (typeof input.pattern === "string") return input.pattern;
+	if (typeof input.query === "string") return input.query;
+	if (typeof input.url === "string") return input.url;
+	if (typeof input.prompt === "string") return boundEvidence(input.prompt);
+	if (typeof input.content === "string") return boundEvidence(input.content);
+	return "";
+}
+
+function toolResultText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts: string[] = [];
+	for (const block of content) {
+		if (isRecord(block) && block.type === "text" && typeof block.text === "string") parts.push(block.text);
+	}
+	return parts.join("\n");
+}
+
+/** Parse a Claude Code session JSONL transcript. */
+export function parseClaudeCodeTranscript(text: string): ClaudeParseResult {
+	const sink = new ParseSink();
+	let sourceSessionId: string | undefined;
+	let title: string | undefined;
+	let cwd: string | undefined;
+
+	const lines = text.split("\n");
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index]!.trim();
+		if (line.length === 0) continue;
+		const recordNumber = index + 1;
+		let record: unknown;
+		try {
+			record = JSON.parse(line);
+		} catch {
+			sink.quarantineRecord(recordNumber, line, "invalid_json");
+			continue;
+		}
+		if (!isRecord(record) || typeof record.type !== "string") {
+			sink.quarantineRecord(recordNumber, line, "invalid_json");
+			continue;
+		}
+		if (typeof record.sessionId === "string" && !sourceSessionId) sourceSessionId = sink.redact(record.sessionId);
+		if (typeof record.cwd === "string" && !cwd) cwd = sink.redact(record.cwd);
+		const timestamp = typeof record.timestamp === "string" ? record.timestamp : undefined;
+
+		switch (record.type) {
+			case "summary": {
+				if (typeof record.summary === "string" && record.summary.trim().length > 0) {
+					title = sink.redact(record.summary).trim();
+				}
+				sink.counts.mapped++;
+				break;
+			}
+			case "user":
+			case "assistant": {
+				const message = record.message;
+				if (!isRecord(message)) {
+					sink.quarantineRecord(recordNumber, line, "missing_fields");
+					break;
+				}
+				sink.counts.mapped++;
+				const isMeta = record.isMeta === true || record.isSidechain === true;
+				if (isMeta) break; // command/system bookkeeping rows are not conversation.
+				const role: "user" | "assistant" = record.type === "user" ? "user" : "assistant";
+				const content = message.content;
+				if (typeof content === "string") {
+					sink.pushMessage(role, content, timestamp);
+					break;
+				}
+				if (!Array.isArray(content)) break;
+				for (const block of content) {
+					if (!isRecord(block) || typeof block.type !== "string") continue;
+					switch (block.type) {
+						case "text":
+							sink.pushMessage(role, typeof block.text === "string" ? block.text : "", timestamp);
+							break;
+						case "thinking":
+							// Model-internal reasoning is never imported (non-goal).
+							break;
+						case "tool_use": {
+							const name = sink.redact(typeof block.name === "string" ? block.name : "tool");
+							const summary = sink.redact(boundEvidence(toolUseSummary(block.input)));
+							sink.addEvidence(summary ? `$ ${name} ${summary}` : `$ ${name}`);
+							break;
+						}
+						case "tool_result": {
+							const summary = sink.redact(boundEvidence(toolResultText(block.content)));
+							if (summary) sink.addEvidence(`→ ${summary}`);
+							break;
+						}
+						default:
+							// image/document blocks and future variants: visible content we
+							// cannot safely represent becomes bounded placeholder evidence.
+							if (block.type === "image" || block.type === "document") sink.addEvidence(`[${block.type}]`);
+					}
+				}
+				break;
+			}
+			case "system":
+			case "file-history-snapshot":
+			case "queue-operation":
+				// Provider hooks/bookkeeping; not conversation content.
+				sink.counts.mapped++;
+				break;
+			default:
+				sink.quarantineRecord(recordNumber, line, "unknown_record");
+		}
+	}
+	sink.closeEvidence();
+
+	return {
+		conversation: {
+			provider: "claude",
+			format: "claude-code-jsonl",
+			...(sourceSessionId ? { sourceSessionId } : {}),
+			...(title ? { title } : {}),
+			...(cwd ? { cwd } : {}),
+			messages: sink.messages,
+		},
+		quarantine: sink.quarantine,
+		counts: sink.counts,
+		redactionKinds: [...sink.redactionKinds].sort(),
+	};
+}
+
+function claudeExportMessageText(message: JsonRecord): string {
+	// Current exports carry structured content blocks; older ones carry `text`.
+	if (Array.isArray(message.content)) {
+		const parts: string[] = [];
+		for (const block of message.content) {
+			if (isRecord(block) && block.type === "text" && typeof block.text === "string") parts.push(block.text);
+		}
+		if (parts.length > 0) return parts.join("\n");
+	}
+	if (typeof message.text === "string") return message.text;
+	return "";
+}
+
+/** Parse a claude.ai data-export conversation (array or single object). */
+export function parseClaudeExport(text: string): ClaudeParseResult {
+	const sink = new ParseSink();
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		sink.quarantineRecord(1, text, "invalid_json");
+		return emptyResult(sink);
+	}
+
+	const conversations = Array.isArray(parsed) ? parsed : [parsed];
+	if (conversations.length === 0 || !conversations.every(isRecord)) {
+		sink.quarantineRecord(1, text, "missing_fields");
+		return emptyResult(sink);
+	}
+	// Deterministic order: the export array order is preserved; otherwise sort by
+	// created_at so multi-conversation files reconstruct chronologically.
+	const ordered = [...conversations].sort((a, b) => {
+		const left = typeof a.created_at === "string" ? a.created_at : "";
+		const right = typeof b.created_at === "string" ? b.created_at : "";
+		return left.localeCompare(right);
+	});
+
+	let title: string | undefined;
+	let sourceSessionId: string | undefined;
+	let recordNumber = 0;
+	for (const conversation of ordered) {
+		if (typeof conversation.uuid === "string" && !sourceSessionId) sourceSessionId = sink.redact(conversation.uuid);
+		if (typeof conversation.name === "string" && conversation.name.trim().length > 0 && !title) {
+			title = sink.redact(conversation.name).trim();
+		}
+		const chatMessages = conversation.chat_messages;
+		if (!Array.isArray(chatMessages)) {
+			sink.quarantineRecord(++recordNumber, JSON.stringify(conversation), "missing_fields");
+			continue;
+		}
+		for (const message of chatMessages) {
+			recordNumber++;
+			if (!isRecord(message)) {
+				sink.quarantineRecord(recordNumber, JSON.stringify(message), "invalid_json");
+				continue;
+			}
+			const sender = message.sender;
+			if (sender !== "human" && sender !== "assistant") {
+				sink.quarantineRecord(recordNumber, JSON.stringify(message), "unknown_record");
+				continue;
+			}
+			sink.counts.mapped++;
+			const timestamp = typeof message.created_at === "string" ? message.created_at : undefined;
+			sink.pushMessage(sender === "human" ? "user" : "assistant", claudeExportMessageText(message), timestamp);
+		}
+	}
+	sink.closeEvidence();
+
+	return {
+		conversation: {
+			provider: "claude",
+			format: "claude-export-json",
+			...(sourceSessionId ? { sourceSessionId } : {}),
+			...(title ? { title } : {}),
+			messages: sink.messages,
+		},
+		quarantine: sink.quarantine,
+		counts: sink.counts,
+		redactionKinds: [...sink.redactionKinds].sort(),
+	};
+}
+
+function emptyResult(sink: ParseSink): ClaudeParseResult {
+	return {
+		conversation: { provider: "claude", format: "claude-export-json", messages: [] },
+		quarantine: sink.quarantine,
+		counts: sink.counts,
+		redactionKinds: [],
+	};
+}