poe-code 3.0.258 → 3.0.259-beta.1

package/dist/sdk/gaslight.d.ts

@@ -1 +1 @@
-export { GASLIGHT_CONFIG_EXAMPLE, loadGaslightConfig, runGaslight, type GaslightConfig, type GaslightEvent, type GaslightFileSystem, type GaslightOptions, type GaslightResult, type GaslightRound, type GaslightSpawn } from "../../packages/agent-gaslight/dist/index.js";
+export { GASLIGHT_CONFIG_EXAMPLE, ingestGaslight, loadGaslightConfig, parseGaslightConfig, runGaslight, type GaslightConfig, type GaslightCollectHumanPrompts, type GaslightEvent, type GaslightFileSystem, type GaslightIngestEvent, type GaslightIngestOptions, type GaslightIngestResult, type GaslightOptions, type GaslightResult, type GaslightRound, type GaslightSpawn } from "../../packages/agent-gaslight/dist/index.js";

package/dist/sdk/gaslight.js

@@ -1,2 +1,2 @@
-export { GASLIGHT_CONFIG_EXAMPLE, loadGaslightConfig, runGaslight } from "@poe-code/agent-gaslight";
+export { GASLIGHT_CONFIG_EXAMPLE, ingestGaslight, loadGaslightConfig, parseGaslightConfig, runGaslight } from "@poe-code/agent-gaslight";
 //# sourceMappingURL=gaslight.js.map

package/dist/sdk/gaslight.js.map

@@ -1 +1 @@
-{"version":3,"file":"gaslight.js","sourceRoot":"","sources":["../../src/sdk/gaslight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,WAAW,EAQZ,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"gaslight.js","sourceRoot":"","sources":["../../src/sdk/gaslight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EAYZ,MAAM,0BAA0B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.258",
+  "version": "3.0.259-beta.1",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",
@@ -116,6 +116,7 @@
     "packages/agent-harness/dist",
     "packages/agent-harness-tools/dist",
     "packages/agent-gaslight/dist",
+    "packages/agent-traces/dist",
     "packages/agent-hook-config/dist",
     "packages/agent-human-in-loop/dist",
     "packages/agent-maestro/dist",
@@ -213,6 +214,7 @@
     "@poe-code/agent-script": "*",
     "@poe-code/agent-skill-config": "*",
     "@poe-code/agent-spawn": "*",
+    "@poe-code/agent-traces": "*",
     "@poe-code/braintrust": "*",
     "@poe-code/cached-resource": "*",
     "@poe-code/config-extends": "*",

package/packages/agent-gaslight/dist/config.d.ts

@@ -1,3 +1,7 @@
 import type { GaslightConfig, GaslightFileSystem } from "./types.js";
 export declare const GASLIGHT_CONFIG_EXAMPLE: string;
-export declare function loadGaslightConfig(cwd: string, homeDir: string, fs?: GaslightFileSystem): Promise<GaslightConfig>;
+export interface ParseGaslightConfigOptions {
+    rejectExtraKeys?: boolean;
+}
+export declare function parseGaslightConfig(content: string, configPath: string, options?: ParseGaslightConfigOptions): Omit<GaslightConfig, "path">;
+export declare function loadGaslightConfig(cwd: string, homeDir: string, fs?: GaslightFileSystem, configPath?: string): Promise<GaslightConfig>;

package/packages/agent-gaslight/dist/config.js

@@ -14,11 +14,31 @@ function isMissingFile(error) {
         "code" in error &&
         error.code === "ENOENT");
 }
-function validateConfig(value, configPath) {
+function objectKeys(value) {
+    return Object.keys(value).sort();
+}
+export function parseGaslightConfig(content, configPath, options = {}) {
+    let parsed;
+    try {
+        parsed = parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid gaslight config at ${configPath}: ${message}`, { cause: error });
+    }
+    return validateConfig(parsed, configPath, options);
+}
+function validateConfig(value, configPath, options) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         throw new Error(`Invalid gaslight config at ${configPath}: expected a YAML object.`);
     }
     const config = value;
+    if (options.rejectExtraKeys) {
+        const extraKey = objectKeys(config).find((key) => key !== "prompt" && key !== "followups");
+        if (extraKey) {
+            throw new Error(`Invalid gaslight config at ${configPath}: unexpected key "${extraKey}".`);
+        }
+    }
     if (typeof config.prompt !== "string" || config.prompt.trim().length === 0) {
         throw new Error(`Invalid gaslight config at ${configPath}: prompt must be a non-empty string.`);
     }
@@ -32,7 +52,16 @@ function validateConfig(value, configPath) {
         followups: config.followups.map((followup) => followup.trim())
     };
 }
-export async function loadGaslightConfig(cwd, homeDir, fs = nodeFs) {
+export async function loadGaslightConfig(cwd, homeDir, fs = nodeFs, configPath) {
+    if (configPath) {
+        const absoluteConfigPath = path.isAbsolute(configPath)
+            ? configPath
+            : path.join(cwd, configPath);
+        return {
+            ...parseGaslightConfig(await fs.readFile(absoluteConfigPath, "utf8"), absoluteConfigPath),
+            path: absoluteConfigPath
+        };
+    }
     const paths = [
         path.join(cwd, ".poe-code", "gaslight.yaml"),
         path.join(homeDir, ".poe-code", "gaslight.yaml")
@@ -48,15 +77,7 @@ export async function loadGaslightConfig(cwd, homeDir, fs = nodeFs) {
             }
             throw error;
         }
-        let parsed;
-        try {
-            parsed = parse(content);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Invalid gaslight config at ${configPath}: ${message}`, { cause: error });
-        }
-        return { ...validateConfig(parsed, configPath), path: configPath };
+        return { ...parseGaslightConfig(content, configPath), path: configPath };
     }
     throw new Error(`No gaslight config found. Searched:\n- ${paths[0]}\n- ${paths[1]}\n\nCreate one with:\n${GASLIGHT_CONFIG_EXAMPLE}`);
 }

package/packages/agent-gaslight/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { GASLIGHT_CONFIG_EXAMPLE, loadGaslightConfig } from "./config.js";
+export { GASLIGHT_CONFIG_EXAMPLE, loadGaslightConfig, parseGaslightConfig } from "./config.js";
+export { ingestGaslight } from "./ingest.js";
 export { runGaslight } from "./run.js";
-export type { GaslightConfig, GaslightEvent, GaslightFileSystem, GaslightOptions, GaslightResult, GaslightRound, GaslightSpawn } from "./types.js";
+export type { GaslightConfig, GaslightCollectHumanPrompts, GaslightEvent, GaslightFileSystem, GaslightIngestEvent, GaslightIngestOptions, GaslightIngestResult, GaslightOptions, GaslightResult, GaslightRound, GaslightSpawn } from "./types.js";

package/packages/agent-gaslight/dist/index.js

@@ -1,2 +1,3 @@
-export { GASLIGHT_CONFIG_EXAMPLE, loadGaslightConfig } from "./config.js";
+export { GASLIGHT_CONFIG_EXAMPLE, loadGaslightConfig, parseGaslightConfig } from "./config.js";
+export { ingestGaslight } from "./ingest.js";
 export { runGaslight } from "./run.js";

package/packages/agent-gaslight/dist/ingest.d.ts

@@ -0,0 +1,2 @@
+import type { GaslightIngestOptions, GaslightIngestResult } from "./types.js";
+export declare function ingestGaslight(options: GaslightIngestOptions): Promise<GaslightIngestResult>;

package/packages/agent-gaslight/dist/ingest.js

@@ -0,0 +1,486 @@
+import { promises as nodeFs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import parseDuration from "parse-duration";
+import { collectHumanPromptsWithStats } from "@poe-code/agent-traces";
+import { spawn as defaultSpawn } from "@poe-code/agent-spawn";
+import { parseGaslightConfig } from "./config.js";
+function isMissingFile(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+async function exists(fs, filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function sanitizeAgentForFileName(agent) {
+    const parts = [];
+    let previousWasDash = false;
+    for (const char of agent.toLowerCase()) {
+        const code = char.charCodeAt(0);
+        const isLowercaseLetter = code >= 97 && code <= 122;
+        const isNumber = code >= 48 && code <= 57;
+        if (isLowercaseLetter || isNumber) {
+            parts.push(char);
+            previousWasDash = false;
+            continue;
+        }
+        if (!previousWasDash) {
+            parts.push("-");
+            previousWasDash = true;
+        }
+    }
+    while (parts[0] === "-") {
+        parts.shift();
+    }
+    while (parts[parts.length - 1] === "-") {
+        parts.pop();
+    }
+    return parts.join("") || "agent";
+}
+function resolvePath(cwd, filePath) {
+    return path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+}
+async function resolveOutputPath(fs, cwd, analysisAgent, outputPath) {
+    if (outputPath) {
+        const absolutePath = resolvePath(cwd, outputPath);
+        return { absolutePath, resultPath: outputPath };
+    }
+    const configDirectory = path.join(cwd, ".poe-code");
+    const defaultPath = path.join(configDirectory, "gaslight.yaml");
+    if (!(await exists(fs, defaultPath))) {
+        return { absolutePath: defaultPath, resultPath: ".poe-code/gaslight.yaml" };
+    }
+    const prefix = sanitizeAgentForFileName(analysisAgent);
+    let index = 1;
+    while (true) {
+        const basename = index === 1 ? `${prefix}-gaslight.yaml` : `${prefix}-gaslight-${index}.yaml`;
+        const candidate = path.join(configDirectory, basename);
+        if (!(await exists(fs, candidate))) {
+            return { absolutePath: candidate, resultPath: path.join(".poe-code", basename) };
+        }
+        index += 1;
+    }
+}
+function resolveSince(value) {
+    if (value === undefined) {
+        const milliseconds = parseDuration("30d");
+        return milliseconds === null ? undefined : new Date(Date.now() - milliseconds);
+    }
+    if (value instanceof Date) {
+        return value;
+    }
+    const milliseconds = parseDuration(value);
+    if (milliseconds === null || milliseconds <= 0) {
+        throw new Error(`Invalid since duration "${value}".`);
+    }
+    return new Date(Date.now() - milliseconds);
+}
+async function resolveDataPath(cwd, keepDataPath) {
+    if (keepDataPath) {
+        const absolutePath = resolvePath(cwd, keepDataPath);
+        return { absolutePath, resultPath: keepDataPath };
+    }
+    const resultPath = path.join(".poe-code", "ingest", `human-prompts-${process.pid}-${Date.now()}-${process.hrtime.bigint()}.md`);
+    return { absolutePath: path.join(cwd, resultPath), resultPath };
+}
+function buildAnalysisPrompt(dataPath) {
+    return [
+        "Read this curated Markdown file of human prompts from coding-agent traces:",
+        dataPath,
+        "",
+        "Generate a gaslight.yaml file that captures recurring follow-up prompts the human uses after agent work.",
+        "Be clever: infer workflow-level prompts from the evidence instead of copying frequent strings.",
+        "Return only YAML with this exact shape:",
+        "prompt: <string>",
+        "followups:",
+        "  - <string>",
+        "",
+        "Rules:",
+        "- Prefer concise followups that generalize across tasks.",
+        "- Do not produce two followups for the same workflow step; merge semantic duplicates.",
+        "- Repeated short prompts like \"commit\" are evidence for one well-placed workflow check, not multiple followups.",
+        "- Order followups as a useful review sequence: quality, verification, cleanup, then commit or release when supported by the evidence.",
+        "- Do not include project secrets, file paths, names, tokens, or one-off task details.",
+        "- Preserve the user's direct style when it is reusable.",
+        "- Use 3 to 8 followups."
+    ].join("\n");
+}
+function replaceEvery(value, search, replacement) {
+    if (search.length === 0) {
+        return value;
+    }
+    return value.split(search).join(replacement);
+}
+function redactKnownPaths(value, cwd, homeDir) {
+    const replacements = [
+        { value: cwd, label: "<workspace>" },
+        { value: homeDir, label: "<home>" }
+    ].sort((left, right) => right.value.length - left.value.length);
+    let redacted = value;
+    for (const replacement of replacements) {
+        redacted = replaceEvery(redacted, replacement.value, replacement.label);
+    }
+    return redacted;
+}
+function stripIdeSelection(value) {
+    let stripped = value;
+    const openTag = "<ide_selection>";
+    const closeTag = "</ide_selection>";
+    while (true) {
+        const startIndex = stripped.indexOf(openTag);
+        if (startIndex === -1) {
+            return stripped;
+        }
+        const endIndex = stripped.indexOf(closeTag, startIndex + openTag.length);
+        if (endIndex === -1) {
+            return stripped;
+        }
+        stripped =
+            stripped.slice(0, startIndex) + stripped.slice(endIndex + closeTag.length);
+    }
+}
+function normalizePromptText(value, cwd, homeDir) {
+    const normalizedLineEndings = stripIdeSelection(value)
+        .split("\r\n")
+        .join("\n")
+        .split("\r")
+        .join("\n");
+    const lines = [];
+    let blankLines = 0;
+    for (const line of normalizedLineEndings.split("\n")) {
+        const trimmedRight = line.trimEnd();
+        if (trimmedRight.trim().length === 0) {
+            blankLines += 1;
+            if (blankLines <= 1) {
+                lines.push("");
+            }
+            continue;
+        }
+        blankLines = 0;
+        lines.push(trimmedRight);
+    }
+    return redactKnownPaths(lines.join("\n").trim(), cwd, homeDir);
+}
+function truncateForAnalysis(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    const preferredCut = value.lastIndexOf("\n", maxLength);
+    const minimumUsefulCut = Math.floor(maxLength * 0.65);
+    const cutIndex = preferredCut >= minimumUsefulCut ? preferredCut : maxLength;
+    return `${value.slice(0, cutIndex).trimEnd()}\n[truncated]`;
+}
+function markdownBlock(value) {
+    return value
+        .split("\n")
+        .map((line) => `    ${line}`)
+        .join("\n");
+}
+function markdownInline(value) {
+    return value.split("\n").join(" ").split("`").join("'");
+}
+function groupPromptsByTrace(records) {
+    const groups = new Map();
+    for (const record of records) {
+        const key = `${record.source}:${record.traceId}`;
+        const existing = groups.get(key);
+        if (existing) {
+            existing.prompts.push(record);
+            if (!existing.title && record.title) {
+                existing.title = record.title;
+            }
+            continue;
+        }
+        groups.set(key, {
+            traceId: record.traceId,
+            source: record.source,
+            ...(record.title ? { title: record.title } : {}),
+            prompts: [record]
+        });
+    }
+    return [...groups.values()];
+}
+function shortPromptKey(record, cwd, homeDir) {
+    const text = normalizePromptText(record.text, cwd, homeDir);
+    if (text.length === 0 || text.length > 80 || text.includes("\n")) {
+        return undefined;
+    }
+    return text.toLowerCase();
+}
+function buildRepeatedShortPromptSection(records, cwd, homeDir) {
+    const counts = new Map();
+    for (const record of records) {
+        const key = shortPromptKey(record, cwd, homeDir);
+        if (!key) {
+            continue;
+        }
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const repeated = [...counts.entries()]
+        .filter((entry) => entry[1] > 1)
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, 12);
+    if (repeated.length === 0) {
+        return [
+            "## Repeated short prompts",
+            "",
+            "No repeated short prompts were found.",
+            ""
+        ];
+    }
+    return [
+        "## Repeated short prompts",
+        "",
+        "Treat these as frequency evidence. Do not copy them blindly or create duplicate followups.",
+        "",
+        ...repeated.map(([text, count]) => `- \`${markdownInline(text)}\` - ${count} occurrences`),
+        ""
+    ];
+}
+function buildAnalysisInput(records, cwd, homeDir) {
+    const groups = groupPromptsByTrace(records);
+    const lines = [
+        "# Gaslight ingest analysis input",
+        "",
+        "This file is curated evidence for generating a reusable gaslight.yaml.",
+        "Infer durable follow-up behavior from the prompts. Do not copy task-specific text.",
+        "",
+        "## Summary",
+        "",
+        `- Prompts: ${records.length}`,
+        `- Traces: ${groups.length}`,
+        "",
+        ...buildRepeatedShortPromptSection(records, cwd, homeDir),
+        "## Prompt evidence",
+        ""
+    ];
+    groups.forEach((group, groupIndex) => {
+        const title = group.title
+            ? truncateForAnalysis(markdownInline(normalizePromptText(group.title, cwd, homeDir)), 90)
+            : group.traceId;
+        lines.push(`### Trace ${groupIndex + 1}: ${title}`);
+        lines.push("");
+        lines.push(`- Source: ${group.source}`);
+        lines.push(`- Prompts in trace: ${group.prompts.length}`);
+        lines.push("");
+        group.prompts.forEach((record, promptIndex) => {
+            const text = truncateForAnalysis(normalizePromptText(record.text, cwd, homeDir), 1200);
+            lines.push(`#### Prompt ${promptIndex + 1}`);
+            lines.push("");
+            if (record.timestamp) {
+                lines.push(`- Timestamp: ${record.timestamp}`);
+                lines.push("");
+            }
+            lines.push(markdownBlock(text));
+            lines.push("");
+        });
+    });
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+async function writeAnalysisInput(fs, records, filePath, cwd, homeDir) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, buildAnalysisInput(records, cwd, homeDir), { encoding: "utf8" });
+}
+async function removeAnalysisInput(fs, filePath) {
+    if (!fs.unlink) {
+        return;
+    }
+    try {
+        await fs.unlink(filePath);
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function stripMarkdownFence(value) {
+    const lines = value.trim().split("\n");
+    if (lines.length >= 2 &&
+        lines[0]?.startsWith("```") &&
+        lines[lines.length - 1]?.startsWith("```")) {
+        return lines.slice(1, -1).join("\n").trim();
+    }
+    return value.trim();
+}
+function extractFencedYaml(value) {
+    const match = value.match(/```(?:yaml|yml)?\s*\n([\s\S]*?)\n```/i);
+    return match?.[1]?.trim();
+}
+function extractPromptSection(value) {
+    const lines = value.trim().split("\n");
+    const startIndex = lines.findIndex((line) => /^\s*prompt\s*:/.test(line));
+    if (startIndex === -1) {
+        return undefined;
+    }
+    const selected = [];
+    let sawFollowups = false;
+    for (const line of lines.slice(startIndex)) {
+        if (/^\s*followups\s*:/.test(line)) {
+            sawFollowups = true;
+            selected.push(line);
+            continue;
+        }
+        if (sawFollowups &&
+            line.trim().length > 0 &&
+            !line.startsWith(" ") &&
+            !line.startsWith("-") &&
+            !/^\s*-\s+/.test(line)) {
+            break;
+        }
+        selected.push(line);
+    }
+    return selected.join("\n").trim();
+}
+function extractYamlCandidate(value) {
+    const trimmed = value.trim();
+    return extractFencedYaml(trimmed) ?? extractPromptSection(trimmed) ?? stripMarkdownFence(trimmed);
+}
+function asRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function extractTextBlocks(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const blocks = [];
+    for (const item of value) {
+        if (typeof item === "string") {
+            blocks.push(item);
+            continue;
+        }
+        const record = asRecord(item);
+        if (record?.type === "text" &&
+            typeof record.text === "string" &&
+            record.text.trim().length > 0) {
+            blocks.push(record.text);
+        }
+    }
+    return blocks;
+}
+function extractAgentMessagesFromJsonl(value) {
+    const messages = [];
+    for (const rawLine of value.split("\n")) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1).trim() : rawLine.trim();
+        if (line.length === 0) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+        const record = asRecord(parsed);
+        const item = asRecord(record?.item);
+        if (record?.type === "item.completed" &&
+            item?.type === "agent_message" &&
+            typeof item.text === "string" &&
+            item.text.trim().length > 0) {
+            messages.push(item.text.trim());
+            continue;
+        }
+        const message = asRecord(record?.message);
+        if (record?.type === "assistant" && message) {
+            for (const text of extractTextBlocks(message.content)) {
+                if (text.trim().length > 0) {
+                    messages.push(text.trim());
+                }
+            }
+        }
+    }
+    return messages.length === 0 ? undefined : messages.join("\n");
+}
+function extractGeneratedConfigContent(stdout) {
+    return extractAgentMessagesFromJsonl(stdout) ?? stdout;
+}
+async function writeGeneratedConfig(fs, content, absoluteOutputPath) {
+    const yaml = extractYamlCandidate(extractGeneratedConfigContent(content));
+    parseGaslightConfig(yaml, "generated gaslight config", { rejectExtraKeys: true });
+    await fs.mkdir(path.dirname(absoluteOutputPath), { recursive: true });
+    const temporaryPath = `${absoluteOutputPath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(temporaryPath, `${yaml}\n`, { encoding: "utf8" });
+    if (fs.rename) {
+        await fs.rename(temporaryPath, absoluteOutputPath);
+        return;
+    }
+    await fs.writeFile(absoluteOutputPath, `${yaml}\n`, { encoding: "utf8" });
+}
+export async function ingestGaslight(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const homeDir = options.homeDir ?? os.homedir();
+    const fs = (options.fs ?? nodeFs);
+    const spawn = options.spawn ?? defaultSpawn;
+    const collectHumanPrompts = options.collectHumanPrompts ?? collectHumanPromptsWithStats;
+    const since = resolveSince(options.since);
+    const collection = await collectHumanPrompts({
+        sources: options.sources,
+        cwd,
+        homeDir,
+        since,
+        limit: options.limit ?? 200,
+        allWorkspaces: options.allWorkspaces,
+        fs
+    });
+    options.onEvent?.({ type: "traces.discovered", count: collection.traceCount });
+    options.onEvent?.({
+        type: "prompts.extracted",
+        traces: collection.traceCount,
+        prompts: collection.records.length
+    });
+    if (collection.records.length === 0) {
+        throw new Error("No human prompts found in selected traces.");
+    }
+    const dataPath = await resolveDataPath(cwd, options.keepDataPath);
+    await writeAnalysisInput(fs, collection.records, dataPath.absolutePath, cwd, homeDir);
+    const shouldRemoveAnalysisInput = options.keepDataPath === undefined;
+    try {
+        options.onEvent?.({
+            type: "analysis.started",
+            agent: options.analysisAgent,
+            dataPath: dataPath.absolutePath
+        });
+        const result = await spawn(options.analysisAgent, {
+            prompt: buildAnalysisPrompt(dataPath.absolutePath),
+            cwd,
+            mode: "read",
+            ...(options.model ? { model: options.model } : {})
+        });
+        if (result.exitCode !== 0) {
+            const message = result.stderr.trim() || result.stdout.trim() || `exit code ${result.exitCode}`;
+            throw new Error(`Gaslight ingest analysis failed: ${message}`);
+        }
+        const outputPath = await resolveOutputPath(fs, cwd, options.analysisAgent, options.outputPath);
+        await writeGeneratedConfig(fs, result.stdout, outputPath.absolutePath);
+        options.onEvent?.({ type: "config.written", path: outputPath.resultPath });
+        return {
+            outputPath: outputPath.resultPath,
+            dataPath: dataPath.resultPath,
+            promptCount: collection.records.length,
+            traceCount: collection.traceCount
+        };
+    }
+    finally {
+        if (shouldRemoveAnalysisInput) {
+            await removeAnalysisInput(fs, dataPath.absolutePath);
+        }
+    }
+}

package/packages/agent-gaslight/dist/run.js

@@ -54,7 +54,7 @@ export async function runGaslight(options) {
     await requirePlan(fs, cwd, options.planPath);
     const config = options.prompt !== undefined && options.followups !== undefined
         ? { prompt: options.prompt.trim(), followups: options.followups.map((value) => value.trim()) }
-        : await loadGaslightConfig(cwd, homeDir, fs);
+        : await loadGaslightConfig(cwd, homeDir, fs, options.configPath);
     const prompts = [`${config.prompt} ${options.planPath}`, ...config.followups];
     const rounds = [];
     let usage;