@gajae-code/coding-agent 0.6.4 → 0.7.0

package/src/modes/shared/agent-wire/event-observation.ts

@@ -235,6 +235,22 @@ export function observeAgentSessionEvent(event: AgentSessionEvent): AgentWireOwn
 				semantic: false,
 				coalesceKey: null,
 			});
+		case "subagent_steer_message": {
+			const details = recordObject(event.message.details);
+			return obs(event, {
+				kind: "rpc_subagent_steer",
+				signal: null,
+				evidence: {
+					from: str(details?.from) ?? null,
+					to: str(details?.to) ?? null,
+					state: str(details?.state) ?? null,
+					observationId: str(details?.observationId) ?? null,
+				},
+				severity: "info",
+				semantic: false,
+				coalesceKey: null,
+			});
+		}
 		case "notice": {
 			const level = event.level;
 			return obs(event, {

package/src/modes/shared/agent-wire/unattended-audit.ts

@@ -12,6 +12,7 @@
  */
 import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, writeSync } from "node:fs";
 import * as path from "node:path";
+import { sessionAuditDir } from "../../../gjc-runtime/session-layout";
 import type { RpcBudgetExceeded, RpcWorkflowGateKind, RpcWorkflowStage } from "../../rpc/rpc-types";
 import { answerHashOf } from "./workflow-gate-schema";
 
@@ -69,9 +70,9 @@ function defaultId(): string {
 	return `ae_${Date.now().toString(36)}_${idCounter.toString(36)}`;
 }
 
-export function defaultAuditPath(runId: string, root = process.cwd()): string {
+export function defaultAuditPath(runId: string, root = process.cwd(), gjcSessionId = runId): string {
 	const safe = runId.replace(/[^a-zA-Z0-9_.-]/g, "_");
-	return path.join(root, ".gjc", "audit", "unattended", `${safe}.jsonl`);
+	return path.join(sessionAuditDir(root, gjcSessionId), "unattended", `${safe}.jsonl`);
 }
 
 /** Append-only audit log writer + reader for one unattended run. */

package/src/modes/shared/agent-wire/unattended-session.ts

@@ -59,6 +59,14 @@ export interface WorkflowGateEmitter {
 	isUnattended(): boolean;
 	/** Open + emit a gate; resolves with the agent's answer (from workflow_gate_response). */
 	emitGate(input: OpenGateInput): Promise<unknown>;
+	/**
+	 * Optional bridge surface (present on {@link UnattendedSessionControlPlane}) that
+	 * lets an in-process extension observe emitted gates and answer them — used by
+	 * the notifications SDK to resolve a real ask gate from a remote reply.
+	 */
+	onGateEmitted?(listener: (gate: RpcWorkflowGate) => void): () => void;
+	resolveGate?(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+	listPendingGates?(): RpcWorkflowGate[];
 }
 
 export interface UnattendedSessionOptions {
@@ -82,6 +90,7 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 	#broker: WorkflowGateBroker | undefined;
 	readonly #pending = new Map<string, { resolve: (answer: unknown) => void; reject: (err: Error) => void }>();
 	readonly #earlyAnswers = new Map<string, unknown>();
+	readonly #gateListeners = new Set<(gate: RpcWorkflowGate) => void>();
 
 	constructor(private readonly opts: UnattendedSessionOptions) {}
 
@@ -89,6 +98,12 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 		return this.#controller !== undefined;
 	}
 
+	/** Observe every emitted gate (e.g. so an extension can map an ask to its gate_id). */
+	onGateEmitted(listener: (gate: RpcWorkflowGate) => void): () => void {
+		this.#gateListeners.add(listener);
+		return () => this.#gateListeners.delete(listener);
+	}
+
 	get controller(): UnattendedRunController | undefined {
 		return this.#controller;
 	}
@@ -195,6 +210,13 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 			return Promise.reject(new Error("cannot emit a workflow gate before unattended mode is negotiated"));
 		}
 		const gate = this.#broker.openGate(input);
+		for (const listener of this.#gateListeners) {
+			try {
+				listener(gate);
+			} catch {
+				// A misbehaving observer must never break gate emission.
+			}
+		}
 		if (this.#earlyAnswers.has(gate.gate_id)) {
 			const answer = this.#earlyAnswers.get(gate.gate_id);
 			this.#earlyAnswers.delete(gate.gate_id);

package/src/modes/types.ts

@@ -17,6 +17,7 @@ import type { MCPManager } from "../runtime-mcp";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { CredentialAutoImportOptions } from "../setup/credential-auto-import";
 import type { LspStartupServerInfo } from "../tools";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -247,7 +248,7 @@ export interface InteractiveModeContext {
 	showSessionSelector(): void;
 	handleResumeSession(sessionPath: string): Promise<void>;
 	handleSessionDeleteCommand(): Promise<void>;
-	showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+	showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
 	showHookConfirm(title: string, message: string): Promise<boolean>;
 	showDebugSelector(): void;
 	showSessionObserver(): void;
@@ -311,3 +312,8 @@ export interface InteractiveModeContext {
 	showExtensionError(extensionPath: string, error: string): void;
 	showToolError(toolName: string, error: string): void;
 }
+export interface OAuthSelectorOptions {
+	allowExternalCredentialDiscovery?: boolean;
+	trigger?: "bare-login";
+	externalCredentialDiscover?: CredentialAutoImportOptions["discover"];
+}

package/src/modes/utils/ui-helpers.ts

@@ -203,6 +203,29 @@ export class UiHelpers {
 						}
 						return components;
 					}
+					if (message.customType === "subagent:steer" || message.customType === "subagent:steer:relay") {
+						const details = (
+							message as CustomMessage<{
+								from?: string;
+								to?: string;
+								body?: string;
+								state?: string;
+							}>
+						).details;
+						const components: Component[] = [];
+						const header = `${theme.fg("accent", `[Steer ${details?.state ?? "queued"}] ${details?.from ?? "?"} ⇨ ${details?.to ?? "?"}`)}`;
+						const headerComponent = new Text(header, 1, 0);
+						this.ctx.chatContainer.addChild(headerComponent);
+						components.push(headerComponent);
+						if (details?.body) {
+							for (const line of details.body.split("\n")) {
+								const lineComponent = new Text(theme.fg("muted", `  ${line}`), 0, 0);
+								this.ctx.chatContainer.addChild(lineComponent);
+								components.push(lineComponent);
+							}
+						}
+						return components;
+					}
 					const renderer = this.ctx.session.extensionRunner?.getMessageRenderer(message.customType);
 					// Both HookMessage and CustomMessage have the same structure, cast for compatibility
 					const component = new CustomMessageComponent(message as CustomMessage<unknown>, renderer);

package/src/notifications/config-commands.ts

@@ -0,0 +1,50 @@
+/**
+ * In-thread configuration slash commands for the threaded session surface.
+ *
+ * Replies are thread-native now (the old `/answer <sessionId> …` command is
+ * removed), but the user can still adjust per-surface behaviour from inside a
+ * session thread with small slash commands:
+ *
+ * - `/verbose`            switch the mirror to verbose (full tool output + reasoning)
+ * - `/lean`               switch back to lean (assistant text + tool names)
+ * - `/verbosity lean|verbose`
+ * - `/redact on|off`      toggle redaction of streamed content
+ *
+ * This parser is pure so the command grammar is unit-testable; the daemon maps
+ * the returned change onto a `config_command` frame / settings update.
+ */
+
+/** A parsed in-thread configuration change. */
+export interface ConfigCommandChange {
+	verbosity?: "lean" | "verbose";
+	redact?: boolean;
+}
+
+/**
+ * Parse an in-thread config command. Returns the requested change, or
+ * `undefined` when the text is not a recognised config command (so the daemon
+ * can fall through to treating it as a free-text injection).
+ */
+export function parseInThreadConfigCommand(text: string): ConfigCommandChange | undefined {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("/")) return undefined;
+	const [rawCommand, ...rest] = trimmed.slice(1).split(/\s+/);
+	const command = rawCommand?.toLowerCase();
+	const arg = rest[0]?.toLowerCase();
+
+	switch (command) {
+		case "verbose":
+			return { verbosity: "verbose" };
+		case "lean":
+			return { verbosity: "lean" };
+		case "verbosity":
+			if (arg === "lean" || arg === "verbose") return { verbosity: arg };
+			return undefined;
+		case "redact":
+			if (arg === "on" || arg === "true" || arg === "1") return { redact: true };
+			if (arg === "off" || arg === "false" || arg === "0") return { redact: false };
+			return undefined;
+		default:
+			return undefined;
+	}
+}

package/src/notifications/config.ts

@@ -0,0 +1,107 @@
+import * as crypto from "node:crypto";
+import type { Settings } from "../config/settings";
+
+export interface NotificationConfig {
+	enabled: boolean;
+	botToken?: string;
+	chatId?: string;
+	redact: boolean;
+	verbosity: "lean" | "verbose";
+	idleTimeoutMs: number;
+}
+
+/** Read typed config from Settings. */
+export function getNotificationConfig(settings: Settings): NotificationConfig {
+	return {
+		enabled: settings.get("notifications.enabled"),
+		botToken: settings.get("notifications.telegram.botToken"),
+		chatId: settings.get("notifications.telegram.chatId"),
+		redact: settings.get("notifications.redact"),
+		verbosity: settings.get("notifications.verbosity") === "verbose" ? "verbose" : "lean",
+		idleTimeoutMs: settings.get("notifications.daemon.idleTimeoutMs"),
+	};
+}
+
+/** Is global config sufficient for auto-on (enabled + botToken + chatId all present)? */
+export function isGloballyConfigured(cfg: NotificationConfig): boolean {
+	return cfg.enabled && Boolean(cfg.botToken) && Boolean(cfg.chatId);
+}
+
+/** Resolve whether the notifications extension should be registered at SDK startup. */
+export function shouldRegisterNotificationsExtension(input: {
+	env: NodeJS.ProcessEnv;
+	cfg?: NotificationConfig;
+}): boolean {
+	if (input.env.GJC_NOTIFICATIONS === "0") return false;
+	if (input.env.GJC_NOTIFICATIONS === "1" || input.env.GJC_NOTIFICATIONS_TOKEN) return true;
+	return input.cfg ? isGloballyConfigured(input.cfg) : false;
+}
+
+/**
+ * Resolve whether THIS session should run notifications.
+ * Precedence (highest first):
+ *  1) env.GJC_NOTIFICATIONS === "0"  -> false (hard opt-out)
+ *  2) sessionDisabled === true       -> false (local /notify off)
+ *  3) env.GJC_NOTIFICATIONS === "1" || env.GJC_NOTIFICATIONS_TOKEN present -> true (legacy explicit)
+ *  4) isGloballyConfigured(cfg)      -> true (global auto-on)
+ *  5) otherwise false
+ */
+export function isSessionNotificationsEnabled(input: {
+	cfg: NotificationConfig;
+	env: NodeJS.ProcessEnv;
+	sessionDisabled: boolean;
+}): boolean {
+	if (input.env.GJC_NOTIFICATIONS === "0") return false;
+	if (input.sessionDisabled) return false;
+	if (input.env.GJC_NOTIFICATIONS === "1" || input.env.GJC_NOTIFICATIONS_TOKEN) return true;
+	return isGloballyConfigured(input.cfg);
+}
+
+/** Mask a bot token for display: first 4 chars + "…" + "(len N)"; "(unset)" when undefined/empty. Never reveal full token. */
+export function maskToken(token: string | undefined): string {
+	if (!token) return "(unset)";
+	return `${token.slice(0, 4)}…(len ${token.length})`;
+}
+
+/** Stable non-reversible fingerprint of a token: sha256 hex, first 12 chars. */
+export function tokenFingerprint(token: string): string {
+	return crypto.createHash("sha256").update(token).digest("hex").slice(0, 12);
+}
+
+/** Short session tag for display, e.g. last 6 chars of sessionId. */
+export function sessionTag(sessionId: string): string {
+	return sessionId.slice(-6);
+}
+
+export interface RedactableAction {
+	id: string;
+	kind: string;
+	sessionId: string;
+	question?: string;
+	options?: string[];
+	summary?: string;
+}
+
+/**
+ * When redact is true, strip sensitive content for remote delivery:
+ *  - ask: NOT redacted. An ask is an interactive prompt the human must read and
+ *    answer on the remote surface; redacting its question/options would make it
+ *    unanswerable, defeating remote answering. Asks are returned unchanged.
+ *  - idle: summary removed, (no question/options).
+ * When redact is false, return the action unchanged.
+ *
+ * Redaction still applies to streamed content frames (turn_stream, context_update,
+ * image_attachment) which are suppressed at their emit sites, not here.
+ */
+export function buildRedactedAction(
+	action: RedactableAction,
+	opts: { redact: boolean; sessionTag: string },
+): RedactableAction {
+	if (!opts.redact) return action;
+
+	// Asks stay fully readable/answerable even under redaction.
+	if (action.kind === "ask") return action;
+
+	const { summary: _summary, question: _question, ...base } = action;
+	return base;
+}

package/src/notifications/helpers.ts

@@ -0,0 +1,135 @@
+/**
+ * Pure helpers for the notifications extension.
+ *
+ * Kept side-effect-free so the mapping logic (ask extraction, idle summary,
+ * dedupe keys) is unit-testable without a live session or the native server.
+ */
+
+import { buildRedactedAction, type RedactableAction } from "./config";
+
+/** A pending ask derived from an `ask` tool call. */
+export interface PendingAsk {
+	/** Action id: `${toolCallId}:${questionId}`. */
+	id: string;
+	/** Question text. */
+	question: string;
+	/** Option labels (may be empty for free-text questions). */
+	options: string[];
+}
+
+/** Truncate text to `max` chars, appending an ellipsis when cut. */
+export function truncate(text: string, max = 280): string {
+	if (max <= 0) return "";
+	return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+}
+
+/** Stable per-turn idle dedupe key so exactly one idle action fires per turn. */
+export function idleDedupeKey(sessionId: string, turnIndex: number): string {
+	return `${sessionId}#${turnIndex}`;
+}
+
+/**
+ * Extract pending asks from an `ask` tool call input.
+ *
+ * Defensive: tolerates partial/unknown shapes and always returns an array.
+ */
+export function asksFromAskInput(toolCallId: string, input: unknown): PendingAsk[] {
+	const questions = (input as { questions?: unknown } | null | undefined)?.questions;
+	if (!Array.isArray(questions)) return [];
+	const asks: PendingAsk[] = [];
+	for (const raw of questions) {
+		if (!raw || typeof raw !== "object") continue;
+		const q = raw as { id?: unknown; question?: unknown; options?: unknown };
+		const qid = typeof q.id === "string" && q.id.length > 0 ? q.id : String(asks.length);
+		const question = typeof q.question === "string" ? q.question : "";
+		const options = Array.isArray(q.options)
+			? q.options.map(opt => {
+					if (opt && typeof opt === "object" && typeof (opt as { label?: unknown }).label === "string") {
+						return (opt as { label: string }).label;
+					}
+					return String(opt);
+				})
+			: [];
+		asks.push({ id: `${toolCallId}:${qid}`, question, options });
+	}
+	return asks;
+}
+
+/** Prepare an action JSON payload for remote notification delivery. */
+export function notificationActionPayload<T extends RedactableAction>(
+	action: T,
+	opts: { redact: boolean; sessionTag: string },
+): RedactableAction {
+	return buildRedactedAction(action, opts);
+}
+
+/** Extract a plain-text summary from an agent message's content, if any. */
+export function summaryFromMessage(message: unknown, max = 280): string | undefined {
+	const content = (message as { content?: unknown } | null | undefined)?.content;
+	if (typeof content === "string") {
+		const trimmed = content.trim();
+		return trimmed ? truncate(trimmed, max) : undefined;
+	}
+	if (!Array.isArray(content)) return undefined;
+	const parts: string[] = [];
+	for (const block of content) {
+		if (block && typeof block === "object" && (block as { type?: unknown }).type === "text") {
+			const text = (block as { text?: unknown }).text;
+			if (typeof text === "string") parts.push(text);
+		}
+	}
+	const joined = parts.join("").trim();
+	return joined ? truncate(joined, max) : undefined;
+}
+
+/**
+ * Extract an idle summary from an `agent_end` event's settled message list: the
+ * last message that yields text (i.e. the final assistant message; tool-result
+ * messages have no text and are skipped).
+ *
+ * `agent_end` fires exactly once when the agent loop settles to await the user,
+ * so emitting idle from this — instead of per-`turn_end` — produces exactly one
+ * idle notification per genuine idle, eliminating the multi-turn flood.
+ */
+export function summaryFromMessages(messages: unknown, max = 280): string | undefined {
+	if (!Array.isArray(messages)) return undefined;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const summary = summaryFromMessage(messages[i], max);
+		if (summary) return summary;
+	}
+	return undefined;
+}
+
+/** An agent-produced image extracted from a message's content. */
+export interface ExtractedImage {
+	source: string;
+	mime: string;
+	data: string;
+}
+
+/**
+ * Extract agent-produced images (`{ type: "image", data, mimeType }` blocks)
+ * from a message's content — e.g. computer-use/browser screenshots or tool
+ * image outputs — for `image_attachment` delivery.
+ */
+export function imageAttachmentsFromMessage(message: unknown, source = "agent"): ExtractedImage[] {
+	const content = (message as { content?: unknown } | null | undefined)?.content;
+	if (!Array.isArray(content)) return [];
+	const out: ExtractedImage[] = [];
+	for (const block of content) {
+		if (
+			block &&
+			typeof block === "object" &&
+			(block as { type?: unknown }).type === "image" &&
+			typeof (block as { data?: unknown }).data === "string" &&
+			typeof (block as { mimeType?: unknown }).mimeType === "string"
+		) {
+			out.push({
+				source,
+				mime: (block as { mimeType: string }).mimeType,
+				data: (block as { data: string }).data,
+			});
+		}
+	}
+	return out;
+}