@grackle-ai/core 0.75.4

package/dist/credential-bundle.js

@@ -0,0 +1,183 @@
+/**
+ * Builds token bundles from enabled credential providers by reading
+ * `process.env` and credential files from disk.
+ *
+ * Separated from {@link ./credential-providers.ts} (persistence layer) and
+ * {@link ./token-push.ts} (network orchestration) to keep each module
+ * focused on a single concern.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { create } from "@bufbuild/protobuf";
+import { powerline } from "@grackle-ai/common";
+import { credentialProviders } from "@grackle-ai/database";
+/** Maps each runtime to the credential providers it needs. */
+const RUNTIME_PROVIDERS = {
+    "claude-code": ["claude", "github"],
+    "copilot": ["copilot", "github"],
+    "codex": ["codex", "github"],
+    "goose": ["goose", "github"],
+    "stub": [],
+    // ACP runtimes (experimental) — auth via ACP authenticate method, not credential files
+    "claude-code-acp": ["claude", "github"],
+    "codex-acp": ["codex", "github"],
+    "copilot-acp": ["copilot", "github"],
+};
+/**
+ * Build a token bundle containing enabled provider credentials.
+ * When `runtime` is a known {@link RuntimeName}, only providers mapped to that runtime are included.
+ * When `runtime` is omitted, all enabled providers are included.
+ * When `runtime` is provided but not a recognized {@link RuntimeName}, no providers are included
+ * (fails safe rather than exposing all credentials for an unrecognized runtime).
+ * Reads values fresh from `process.env` or disk at call time.
+ */
+export function buildProviderTokenBundle(runtime, database) {
+    const config = credentialProviders.getCredentialProviders(database);
+    // When runtime is given, look it up in the map. Unknown runtimes get [] (empty, not all providers).
+    const runtimeProviders = runtime !== undefined
+        ? (Object.hasOwn(RUNTIME_PROVIDERS, runtime) ? RUNTIME_PROVIDERS[runtime] : [])
+        : undefined;
+    const allowedProviders = runtimeProviders !== undefined
+        ? new Set(runtimeProviders)
+        : undefined;
+    const items = [];
+    // Claude provider
+    if ((!allowedProviders || allowedProviders.has("claude")) && config.claude === "subscription") {
+        const credentialsPath = join(homedir(), ".claude", ".credentials.json");
+        if (existsSync(credentialsPath)) {
+            const value = readFileSync(credentialsPath, "utf-8");
+            if (value.trim()) {
+                items.push(create(powerline.TokenItemSchema, {
+                    name: "claude-credentials",
+                    type: "file",
+                    filePath: "~/.claude/.credentials.json",
+                    value,
+                }));
+            }
+        }
+    }
+    else if ((!allowedProviders || allowedProviders.has("claude")) && config.claude === "api_key") {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (apiKey) {
+            items.push(create(powerline.TokenItemSchema, {
+                name: "anthropic-api-key",
+                type: "env_var",
+                envVar: "ANTHROPIC_API_KEY",
+                value: apiKey,
+            }));
+        }
+    }
+    // GitHub provider
+    if ((!allowedProviders || allowedProviders.has("github")) && config.github === "on") {
+        for (const varName of ["GITHUB_TOKEN", "GH_TOKEN"]) {
+            const value = process.env[varName];
+            if (value) {
+                items.push(create(powerline.TokenItemSchema, {
+                    name: varName.toLowerCase().replace(/_/g, "-"),
+                    type: "env_var",
+                    envVar: varName,
+                    value,
+                }));
+            }
+        }
+    }
+    // Copilot provider — push the config file so the SDK's useLoggedInUser path works.
+    // Also forward env vars for explicit token / BYOK scenarios.
+    if ((!allowedProviders || allowedProviders.has("copilot")) && config.copilot === "on") {
+        const copilotConfigPath = join(homedir(), ".copilot", "config.json");
+        if (existsSync(copilotConfigPath)) {
+            const value = readFileSync(copilotConfigPath, "utf-8");
+            if (value.trim()) {
+                items.push(create(powerline.TokenItemSchema, {
+                    name: "copilot-config",
+                    type: "file",
+                    filePath: "~/.copilot/config.json",
+                    value,
+                }));
+            }
+        }
+        for (const varName of [
+            "COPILOT_GITHUB_TOKEN",
+            "COPILOT_CLI_URL",
+            "COPILOT_CLI_PATH",
+            "COPILOT_PROVIDER_CONFIG",
+        ]) {
+            const value = process.env[varName];
+            if (value) {
+                items.push(create(powerline.TokenItemSchema, {
+                    name: varName.toLowerCase().replace(/_/g, "-"),
+                    type: "env_var",
+                    envVar: varName,
+                    value,
+                }));
+            }
+        }
+    }
+    // Codex provider — push the auth file so the SDK's ChatGPT auth path works.
+    // Also forward OPENAI_API_KEY env var for API-key scenarios.
+    if ((!allowedProviders || allowedProviders.has("codex")) && config.codex === "on") {
+        const codexAuthPath = join(homedir(), ".codex", "auth.json");
+        if (existsSync(codexAuthPath)) {
+            const value = readFileSync(codexAuthPath, "utf-8");
+            if (value.trim()) {
+                items.push(create(powerline.TokenItemSchema, {
+                    name: "codex-auth",
+                    type: "file",
+                    filePath: "~/.codex/auth.json",
+                    value,
+                }));
+            }
+        }
+        const openaiKey = process.env.OPENAI_API_KEY;
+        if (openaiKey) {
+            items.push(create(powerline.TokenItemSchema, {
+                name: "openai-api-key",
+                type: "env_var",
+                envVar: "OPENAI_API_KEY",
+                value: openaiKey,
+            }));
+        }
+    }
+    // Goose provider — forward config file and provider-related env vars.
+    // Goose is provider-agnostic so we forward whichever API keys are available.
+    if ((!allowedProviders || allowedProviders.has("goose")) && config.goose === "on") {
+        const isWindows = process.platform === "win32";
+        const gooseConfigPath = isWindows
+            ? join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "Block", "goose", "config", "config.yaml")
+            : join(homedir(), ".config", "goose", "config.yaml");
+        const gooseConfigFilePath = isWindows
+            ? "%APPDATA%/Block/goose/config/config.yaml"
+            : "~/.config/goose/config.yaml";
+        if (existsSync(gooseConfigPath)) {
+            const value = readFileSync(gooseConfigPath, "utf-8");
+            if (value.trim()) {
+                items.push(create(powerline.TokenItemSchema, {
+                    name: "goose-config",
+                    type: "file",
+                    filePath: gooseConfigFilePath,
+                    value,
+                }));
+            }
+        }
+        for (const varName of [
+            "GOOSE_PROVIDER",
+            "GOOSE_MODEL",
+            "ANTHROPIC_API_KEY",
+            "OPENAI_API_KEY",
+            "GOOGLE_API_KEY",
+        ]) {
+            const value = process.env[varName];
+            if (value) {
+                items.push(create(powerline.TokenItemSchema, {
+                    name: varName.toLowerCase().replace(/_/g, "-"),
+                    type: "env_var",
+                    envVar: varName,
+                    value,
+                }));
+            }
+        }
+    }
+    return create(powerline.TokenBundleSchema, { tokens: items });
+}
+//# sourceMappingURL=credential-bundle.js.map

package/dist/credential-bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-bundle.js","sourceRoot":"","sources":["../src/credential-bundle.ts"],"names":[],"mappings":"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"}

package/dist/event-bus.d.ts

@@ -0,0 +1,37 @@
+/** All domain event types emitted by the event bus. */
+export type GrackleEventType = "task.created" | "task.updated" | "task.started" | "task.completed" | "task.deleted" | "workspace.created" | "workspace.archived" | "workspace.updated" | "persona.created" | "persona.updated" | "persona.deleted" | "finding.posted" | "environment.added" | "environment.removed" | "environment.changed" | "environment.provision_progress" | "token.changed" | "credential.providers_changed" | "setting.changed";
+/** A domain event emitted by the event bus. */
+export interface GrackleEvent {
+    /** ULID — chronologically sortable unique identifier. */
+    id: string;
+    /** Dot-notation event type (e.g. "task.created"). */
+    type: GrackleEventType;
+    /** ISO 8601 timestamp. */
+    timestamp: string;
+    /** Domain-specific payload. */
+    payload: Record<string, unknown>;
+}
+/** Callback signature for event subscribers. */
+export type Subscriber = (event: GrackleEvent) => void;
+/**
+ * Emit a domain event. Persists to SQLite synchronously, then
+ * fans out to all subscribers asynchronously via queueMicrotask.
+ *
+ * @param type - The dot-notation event type.
+ * @param payload - Domain-specific data.
+ * @returns The created GrackleEvent.
+ */
+export declare function emit(type: GrackleEventType, payload: Record<string, unknown>): GrackleEvent;
+/**
+ * Register a subscriber to receive all domain events.
+ *
+ * @param subscriber - Callback invoked for each emitted event.
+ * @returns An unsubscribe function.
+ */
+export declare function subscribe(subscriber: Subscriber): () => void;
+/**
+ * Reset all subscribers. For use in tests only.
+ * @internal
+ */
+export declare function _resetForTesting(): void;
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../src/event-bus.ts"],"names":[],"mappings":"AAMA,uDAAuD;AACvD,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,cAAc,GACd,cAAc,GACd,gBAAgB,GAChB,cAAc,GACd,mBAAmB,GACnB,oBAAoB,GACpB,mBAAmB,GACnB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,GACjB,gBAAgB,GAChB,mBAAmB,GACnB,qBAAqB,GACrB,qBAAqB,GACrB,gCAAgC,GAChC,eAAe,GACf,8BAA8B,GAC9B,iBAAiB,CAAC;AAEtB,+CAA+C;AAC/C,MAAM,WAAW,YAAY;IAC3B,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,IAAI,EAAE,gBAAgB,CAAC;IACvB,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,gDAAgD;AAChD,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;AAQvD;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,YAAY,CA+Bd;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,IAAI,CAK5D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/dist/event-bus.js

@@ -0,0 +1,65 @@
+import { ulid } from "ulid";
+import { persistEvent } from "@grackle-ai/database";
+import { logger } from "./logger.js";
+// ─── Module State ─────────────────────────────────────────
+const subscribers = new Set();
+// ─── Public API ───────────────────────────────────────────
+/**
+ * Emit a domain event. Persists to SQLite synchronously, then
+ * fans out to all subscribers asynchronously via queueMicrotask.
+ *
+ * @param type - The dot-notation event type.
+ * @param payload - Domain-specific data.
+ * @returns The created GrackleEvent.
+ */
+export function emit(type, payload) {
+    const event = {
+        id: ulid(),
+        type,
+        timestamp: new Date().toISOString(),
+        payload,
+    };
+    // Persist synchronously (SQLite is fast in WAL mode).
+    // Intentionally non-fatal: a persistence failure is logged but does not
+    // prevent subscribers from receiving the event. Domain events drive live
+    // UI updates which must not break if SQLite is temporarily unavailable.
+    // Replay/audit consumers should monitor logs for persistence errors.
+    try {
+        persistEvent(event);
+    }
+    catch (err) {
+        logger.error({ err, event }, "Failed to persist domain event");
+    }
+    // Fan out asynchronously — subscriber errors never block the emitter
+    queueMicrotask(() => {
+        for (const subscriber of subscribers) {
+            try {
+                subscriber(event);
+            }
+            catch (err) {
+                logger.error({ err, eventType: event.type }, "Subscriber error");
+            }
+        }
+    });
+    return event;
+}
+/**
+ * Register a subscriber to receive all domain events.
+ *
+ * @param subscriber - Callback invoked for each emitted event.
+ * @returns An unsubscribe function.
+ */
+export function subscribe(subscriber) {
+    subscribers.add(subscriber);
+    return () => {
+        subscribers.delete(subscriber);
+    };
+}
+/**
+ * Reset all subscribers. For use in tests only.
+ * @internal
+ */
+export function _resetForTesting() {
+    subscribers.clear();
+}
+//# sourceMappingURL=event-bus.js.map

package/dist/event-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.js","sourceRoot":"","sources":["../src/event-bus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAyCrC,6DAA6D;AAE7D,MAAM,WAAW,GAAoB,IAAI,GAAG,EAAE,CAAC;AAE/C,6DAA6D;AAE7D;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAClB,IAAsB,EACtB,OAAgC;IAEhC,MAAM,KAAK,GAAiB;QAC1B,EAAE,EAAE,IAAI,EAAE;QACV,IAAI;QACJ,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnC,OAAO;KACR,CAAC;IAEF,sDAAsD;IACtD,wEAAwE;IACxE,yEAAyE;IACzE,wEAAwE;IACxE,qEAAqE;IACrE,IAAI,CAAC;QACH,YAAY,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,gCAAgC,CAAC,CAAC;IACjE,CAAC;IAED,qEAAqE;IACrE,cAAc,CAAC,GAAG,EAAE;QAClB,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;YACrC,IAAI,CAAC;gBACH,UAAU,CAAC,KAAK,CAAC,CAAC;YACpB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,kBAAkB,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,UAAsB;IAC9C,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC5B,OAAO,GAAG,EAAE;QACV,WAAW,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IACjC,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB;IAC9B,WAAW,CAAC,KAAK,EAAE,CAAC;AACtB,CAAC"}

package/dist/event-processor.d.ts

@@ -0,0 +1,36 @@
+import { powerline } from "@grackle-ai/common";
+import type { ProcessorContext } from "./processor-registry.js";
+/** Options for processing an agent event stream. */
+export interface EventStreamOptions {
+    sessionId: string;
+    logPath: string;
+    workspaceId?: string;
+    taskId?: string;
+    /** System context injected into the agent session. Emitted as the first event in the stream. */
+    systemContext?: string;
+    /** Initial user prompt sent to the agent. Emitted as a user_input event after systemContext. */
+    prompt?: string;
+}
+/**
+ * Process a finding event, storing it in the finding store and broadcasting.
+ * Shared between live event processing and replay on late-bind.
+ */
+export declare function processFindingEvent(ctx: ProcessorContext, content: string, sessionId: string): void;
+/**
+ * Process a subtask creation event, creating a child task and broadcasting.
+ * Shared between live event processing and replay on late-bind.
+ */
+export declare function processSubtaskEvent(ctx: ProcessorContext, content: string, subtaskLocalIdMap: Map<string, string>): void;
+/**
+ * Process an async iterable of agent events from a PowerLine spawn or resume stream.
+ * Handles event transformation, logging, finding interception, status updates, and cleanup.
+ *
+ * This function is fire-and-forget: it runs in the background and does not throw.
+ * Callers should use `onComplete` callback for post-processing.
+ *
+ * Supports late-binding: if a task is associated with the session after the stream starts,
+ * the processor registry notifies this function via a bind listener, and pre-association
+ * events are replayed from the session log.
+ */
+export declare function processEventStream(events: AsyncIterable<powerline.AgentEvent>, options: EventStreamOptions): void;
+//# sourceMappingURL=event-processor.d.ts.map

package/dist/event-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-processor.d.ts","sourceRoot":"","sources":["../src/event-processor.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,SAAS,EAA0E,MAAM,oBAAoB,CAAC;AAYhI,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,oDAAoD;AACpD,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gGAAgG;IAChG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gGAAgG;IAChG,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,IAAI,CAmBN;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACrC,IAAI,CA6FN;AAsCD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,UAAU,CAAC,EAC3C,OAAO,EAAE,kBAAkB,GAC1B,IAAI,CA+KN"}

package/dist/event-processor.js

@@ -0,0 +1,312 @@
+import { create } from "@bufbuild/protobuf";
+import { grackle, eventTypeToEnum, SESSION_STATUS, TERMINAL_SESSION_STATUSES, END_REASON } from "@grackle-ai/common";
+import { v4 as uuid } from "uuid";
+import { sessionStore, findingStore, taskStore, workspaceStore, slugify } from "@grackle-ai/database";
+import * as streamHub from "./stream-hub.js";
+import * as logWriter from "./log-writer.js";
+import * as processorRegistry from "./processor-registry.js";
+import { writeTranscript } from "./transcript.js";
+import { emit } from "./event-bus.js";
+import { logger } from "./logger.js";
+import { publishChildCompletion } from "./pipe-delivery.js";
+import { cleanupLifecycleStream } from "./lifecycle.js";
+/**
+ * Process a finding event, storing it in the finding store and broadcasting.
+ * Shared between live event processing and replay on late-bind.
+ */
+export function processFindingEvent(ctx, content, sessionId) {
+    if (!ctx.workspaceId) {
+        return;
+    }
+    try {
+        const data = JSON.parse(content);
+        const findingId = uuid();
+        findingStore.postFinding(findingId, ctx.workspaceId, ctx.taskId || "", sessionId, data.category || "general", data.title || "Untitled", data.content || "", data.tags || []);
+        emit("finding.posted", { workspaceId: ctx.workspaceId, findingId });
+        logger.info({ findingId, workspaceId: ctx.workspaceId, title: data.title }, "Finding stored");
+    }
+    catch (err) {
+        logger.error({ err, workspaceId: ctx.workspaceId, taskId: ctx.taskId }, "Failed to store finding");
+    }
+}
+/**
+ * Process a subtask creation event, creating a child task and broadcasting.
+ * Shared between live event processing and replay on late-bind.
+ */
+export function processSubtaskEvent(ctx, content, subtaskLocalIdMap) {
+    if (!ctx.taskId) {
+        return;
+    }
+    try {
+        const data = JSON.parse(content);
+        const parentTask = taskStore.getTask(ctx.taskId);
+        if (!parentTask) {
+            logger.warn({ taskId: ctx.taskId }, "Subtask creation failed: parent task not found");
+            return;
+        }
+        if (!parentTask.canDecompose) {
+            logger.warn({ taskId: ctx.taskId }, "Subtask creation failed: parent task cannot decompose");
+            return;
+        }
+        const workspace = parentTask.workspaceId ? workspaceStore.getWorkspace(parentTask.workspaceId) : undefined;
+        if (parentTask.workspaceId && !workspace) {
+            logger.warn({ workspaceId: parentTask.workspaceId }, "Subtask creation failed: workspace not found");
+            return;
+        }
+        // Validate required fields
+        const title = typeof data.title === "string" ? data.title.trim() : "";
+        const description = typeof data.description === "string" ? data.description.trim() : "";
+        if (!title || !description) {
+            logger.warn({ taskId: ctx.taskId, rawTitle: data.title, rawDescription: data.description }, "Subtask creation failed: invalid title or description");
+            return;
+        }
+        // Normalize and validate depends_on, local_id, and can_decompose
+        const dependsOn = Array.isArray(data.depends_on)
+            ? data.depends_on.filter((d) => typeof d === "string").map(d => d.trim()).filter(Boolean)
+            : [];
+        const localId = typeof data.local_id === "string" ? data.local_id.trim() : "";
+        const canDecompose = typeof data.can_decompose === "boolean" ? data.can_decompose : false;
+        // Resolve depends_on local IDs to real task IDs
+        const resolvedDeps = [];
+        for (const localDep of dependsOn) {
+            const realId = subtaskLocalIdMap.get(localDep);
+            if (realId) {
+                resolvedDeps.push(realId);
+            }
+            else {
+                logger.warn({ localDep, taskId: ctx.taskId }, "Subtask dependency local_id not found, skipping");
+            }
+        }
+        const subtaskId = uuid().slice(0, 8);
+        taskStore.createTask(subtaskId, parentTask.workspaceId || undefined, title, description, resolvedDeps, workspace ? slugify(workspace.name) : "", ctx.taskId, canDecompose);
+        // Record the local_id → real ID mapping, detecting duplicates
+        if (localId) {
+            if (subtaskLocalIdMap.has(localId)) {
+                logger.warn({
+                    localId,
+                    existingSubtaskId: subtaskLocalIdMap.get(localId),
+                    newSubtaskId: subtaskId,
+                    parentTaskId: ctx.taskId,
+                }, "Duplicate subtask local_id encountered; keeping existing mapping");
+            }
+            else {
+                subtaskLocalIdMap.set(localId, subtaskId);
+            }
+        }
+        emit("task.created", { taskId: subtaskId, workspaceId: parentTask.workspaceId ?? undefined });
+        logger.info({ subtaskId, parentTaskId: ctx.taskId, title }, "Subtask created");
+    }
+    catch (err) {
+        logger.error({ err, taskId: ctx.taskId }, "Failed to create subtask");
+    }
+}
+/**
+ * Replay pre-association events from the session log through finding/subtask interceptors.
+ * Called when a session is late-bound to a task. Does not re-publish to streamHub.
+ *
+ * Note: Uses synchronous readFileSync while the log is written via a buffered WriteStream.
+ * Events written very recently may still be in the write buffer and not yet flushed to disk.
+ * In practice this is negligible since replay targets events written before the current
+ * iteration of the for-await loop, which are already flushed by the time lateBind is called.
+ */
+function replayLoggedEvents(ctx, subtaskLocalIdMap) {
+    try {
+        const entries = logWriter.readLog(ctx.logPath);
+        let findingsReplayed = 0;
+        let subtasksReplayed = 0;
+        for (const entry of entries) {
+            if (entry.type === "finding") {
+                processFindingEvent(ctx, entry.content, entry.session_id);
+                findingsReplayed++;
+            }
+            else if (entry.type === "subtask_create") {
+                processSubtaskEvent(ctx, entry.content, subtaskLocalIdMap);
+                subtasksReplayed++;
+            }
+        }
+        if (findingsReplayed > 0 || subtasksReplayed > 0) {
+            logger.info({ sessionId: ctx.sessionId, taskId: ctx.taskId, findingsReplayed, subtasksReplayed }, "Replayed pre-association events from session log");
+        }
+    }
+    catch (err) {
+        logger.error({ err, sessionId: ctx.sessionId }, "Failed to replay logged events");
+    }
+}
+/**
+ * Process an async iterable of agent events from a PowerLine spawn or resume stream.
+ * Handles event transformation, logging, finding interception, status updates, and cleanup.
+ *
+ * This function is fire-and-forget: it runs in the background and does not throw.
+ * Callers should use `onComplete` callback for post-processing.
+ *
+ * Supports late-binding: if a task is associated with the session after the stream starts,
+ * the processor registry notifies this function via a bind listener, and pre-association
+ * events are replayed from the session log.
+ */
+export function processEventStream(events, options) {
+    const { sessionId, logPath } = options;
+    // Create a mutable context that can be updated via the processor registry
+    const ctx = {
+        sessionId,
+        logPath,
+        workspaceId: options.workspaceId || "",
+        taskId: options.taskId || "",
+    };
+    /** Maps local_id strings (assigned by the agent) to real task IDs, scoped to this stream. */
+    const subtaskLocalIdMap = new Map();
+    processorRegistry.register(ctx);
+    // Register the bind listener synchronously alongside register() to close the race
+    // window where lateBind() could fire between register and the async IIFE starting.
+    processorRegistry.onBind(sessionId, () => {
+        replayLoggedEvents(ctx, subtaskLocalIdMap);
+    });
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    (async () => {
+        try {
+            logWriter.initLog(logPath);
+            sessionStore.updateSessionStatus(sessionId, SESSION_STATUS.RUNNING);
+            // Emit system context and initial prompt as the first visible events in the stream.
+            // Only for task sessions — ad-hoc spawns show the prompt in the chat input already.
+            // Use distinct timestamps so clients can reliably sort/dedup by timestamp+eventType.
+            if (options.systemContext && options.taskId) {
+                const sysCtxEvent = create(grackle.SessionEventSchema, {
+                    sessionId,
+                    type: grackle.EventType.SYSTEM,
+                    timestamp: new Date().toISOString(),
+                    content: options.systemContext,
+                    raw: JSON.stringify({ systemContext: true }),
+                });
+                logWriter.writeEvent(logPath, sysCtxEvent);
+                streamHub.publish(sysCtxEvent);
+            }
+            if (options.prompt && options.taskId) {
+                const promptEvent = create(grackle.SessionEventSchema, {
+                    sessionId,
+                    type: grackle.EventType.USER_INPUT,
+                    timestamp: new Date().toISOString(),
+                    content: options.prompt,
+                });
+                logWriter.writeEvent(logPath, promptEvent);
+                streamHub.publish(promptEvent);
+            }
+            for await (const event of events) {
+                // runtime_session_id is an internal control event: persist it then skip
+                // logging/publishing — it has no proto enum value and is not client-visible.
+                if (event.type === "runtime_session_id") {
+                    if (event.content) {
+                        sessionStore.updateRuntimeSessionId(sessionId, event.content);
+                    }
+                    continue;
+                }
+                const sessionEvent = create(grackle.SessionEventSchema, {
+                    sessionId,
+                    type: eventTypeToEnum(event.type),
+                    timestamp: event.timestamp,
+                    content: event.content,
+                    raw: event.raw,
+                });
+                logWriter.writeEvent(logPath, sessionEvent);
+                streamHub.publish(sessionEvent);
+                // Intercept finding events and store + broadcast them
+                if (event.type === "finding" && ctx.workspaceId) {
+                    processFindingEvent(ctx, event.content, sessionId);
+                }
+                // Intercept subtask creation events and create child tasks
+                if (event.type === "subtask_create" && ctx.taskId) {
+                    processSubtaskEvent(ctx, event.content, subtaskLocalIdMap);
+                }
+                // Intercept usage events and accumulate token counts on the session record
+                if (event.type === "usage") {
+                    try {
+                        const data = JSON.parse(event.content);
+                        const inputTokens = Number.isFinite(data.input_tokens)
+                            ? Math.max(0, Math.trunc(data.input_tokens))
+                            : 0;
+                        const outputTokens = Number.isFinite(data.output_tokens)
+                            ? Math.max(0, Math.trunc(data.output_tokens))
+                            : 0;
+                        const costUsd = Number.isFinite(data.cost_usd)
+                            ? Math.max(0, data.cost_usd)
+                            : 0;
+                        if (inputTokens > 0 || outputTokens > 0 || costUsd > 0) {
+                            sessionStore.updateSessionUsage(sessionId, inputTokens, outputTokens, costUsd);
+                        }
+                    }
+                    catch (err) {
+                        logger.error({ err, sessionId }, "Failed to process usage event");
+                    }
+                }
+                if (event.type === "status") {
+                    // Map runtime status strings to our session status model
+                    if (event.content === "waiting_input") {
+                        sessionStore.updateSessionStatus(sessionId, SESSION_STATUS.IDLE);
+                    }
+                    else if (event.content === "running") {
+                        sessionStore.updateSessionStatus(sessionId, SESSION_STATUS.RUNNING);
+                    }
+                    else if (event.content === "completed") {
+                        sessionStore.updateSession(sessionId, SESSION_STATUS.STOPPED, undefined, undefined, END_REASON.COMPLETED);
+                    }
+                    else if (event.content === "killed") {
+                        sessionStore.updateSession(sessionId, SESSION_STATUS.STOPPED, undefined, undefined, END_REASON.KILLED);
+                    }
+                    else if (event.content === "failed") {
+                        sessionStore.updateSession(sessionId, SESSION_STATUS.STOPPED, undefined, undefined, END_REASON.INTERRUPTED);
+                        cleanupLifecycleStream(sessionId);
+                    }
+                    // On terminal status: publish child completion to IPC pipe stream.
+                    // Note: lifecycle streams are NOT cleaned up here — they persist until
+                    // the spawner explicitly closes the fd (killAgent, closeFd). This is the
+                    // emergent lifecycle model: fd closure drives hibernation, not status events.
+                    if (["completed", "killed", "failed"].includes(event.content)) {
+                        publishChildCompletion(sessionId, event.content);
+                    }
+                    // Broadcast task_updated on status changes so frontend re-fetches computed status.
+                    // This covers both terminal events (completed/killed/failed) and non-terminal
+                    // transitions (running, waiting_input) that affect the computed task status.
+                    if (ctx.taskId && ["completed", "killed", "failed", "running", "waiting_input"].includes(event.content)) {
+                        emit("task.updated", { taskId: ctx.taskId, workspaceId: ctx.workspaceId });
+                    }
+                }
+            }
+            // Fallback: if stream ended without a terminal status event, emit a UI refresh
+            // without changing status. Guard against overwriting terminal or SUSPENDED states.
+            const current = sessionStore.getSession(sessionId);
+            if (current && !TERMINAL_SESSION_STATUSES.has(current.status) && current.status !== SESSION_STATUS.SUSPENDED) {
+                if (ctx.taskId) {
+                    emit("task.updated", { taskId: ctx.taskId, workspaceId: ctx.workspaceId });
+                }
+            }
+        }
+        catch (err) {
+            const current = sessionStore.getSession(sessionId);
+            if (current && !TERMINAL_SESSION_STATUSES.has(current.status)) {
+                // Transport error during active or idle session — suspend for auto-recovery
+                // on reconnect. Don't publish child completion (session will resume).
+                logger.info({ sessionId, err: String(err) }, "Stream lost — suspending session for recovery");
+                sessionStore.suspendSession(sessionId);
+                streamHub.publish(create(grackle.SessionEventSchema, {
+                    sessionId,
+                    type: grackle.EventType.STATUS,
+                    timestamp: new Date().toISOString(),
+                    content: SESSION_STATUS.SUSPENDED,
+                }));
+                if (ctx.taskId) {
+                    emit("task.updated", { taskId: ctx.taskId, workspaceId: ctx.workspaceId });
+                }
+            }
+            // If already terminal (killAgent/completed/failed set status before transport
+            // died), the session is in its correct final state and task.updated was already
+            // emitted — skip the duplicate to avoid interfering with SIGCHLD delivery.
+        }
+        finally {
+            processorRegistry.unregister(sessionId);
+            logWriter.endSession(logPath);
+            try {
+                writeTranscript(logPath);
+            }
+            catch { /* non-critical */ }
+        }
+    })();
+}
+//# sourceMappingURL=event-processor.js.map