poe-code 3.0.270 → 3.0.272

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.270",
+  "version": "3.0.272",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/agent-eval/dist/check/check.js

@@ -7,6 +7,7 @@ import { loadEval } from "../source/registry.js";
 import { cloneTarget } from "../run/clone.js";
 import { runScorer } from "../run/scorer.js";
 import { assertCanonicalContainedPath, assertCanonicalDestinationPath, resolveContainedPath } from "../path-boundary.js";
+import { assertNoSymlinksInDirectoryTree } from "../run/fixture-copy.js";
 export async function evalCheck(opts) {
     const startedAt = Date.now();
     const source = await openSource(opts.sourceDir);
@@ -66,6 +67,7 @@ async function copyDirectoryIfPresent(sourceDir, destDir) {
         }
         throw error;
     }
+    await assertNoSymlinksInDirectoryTree(sourceDir, "starter");
     await cp(sourceDir, destDir, {
         recursive: true,
         force: true
@@ -75,6 +77,7 @@ async function copyOracleSolution(input) {
     const destDir = resolveCloneRelativePath(input.cloneDir, input.solutionDest);
     await assertCanonicalDestinationPath(input.cloneDir, destDir, "oracle.solution_dest");
     await mkdir(destDir, { recursive: true });
+    await assertNoSymlinksInDirectoryTree(input.solutionDir, "oracle.solution");
     await cp(input.solutionDir, destDir, {
         recursive: true,
         force: true

package/packages/agent-eval/dist/report/load.js

@@ -80,7 +80,7 @@ async function enrichAggregatedCell(cell, outDir) {
     }
 }
 async function enrichMatchedRunResult(runId, resultPath) {
-    const result = parseJson(await readFile(resultPath, "utf8"), resultPath);
+    const result = validateRunResult(parseJson(await readFile(resultPath, "utf8"), resultPath), resultPath);
     if (result.runId !== runId) {
         throw new Error(`Run result "${runId}" embeds mismatched runId "${result.runId}"`);
     }
@@ -158,7 +158,7 @@ async function enrichRunResult(result, runDir) {
 async function loadTraceSummary(tracePath, outDir) {
     try {
         await assertCanonicalOutputFile(outDir, tracePath);
-        const trace = parseJson(await readFile(tracePath, "utf8"), tracePath);
+        const trace = validateTrace(parseJson(await readFile(tracePath, "utf8"), tracePath), tracePath);
         return {
             available: true,
             eventCount: trace.events.length,
@@ -173,6 +173,120 @@ async function loadTraceSummary(tracePath, outDir) {
         throw error;
     }
 }
+function validateRunResult(value, filePath) {
+    const result = requireRecord(value, filePath, "result.json", []);
+    requireString(result.runId, filePath, "result.json", ["runId"]);
+    requireString(result.eval, filePath, "result.json", ["eval"]);
+    requireString(result.agent, filePath, "result.json", ["agent"]);
+    requireString(result.model, filePath, "result.json", ["model"]);
+    requireString(result.planKind, filePath, "result.json", ["planKind"]);
+    requireString(result.verdict, filePath, "result.json", ["verdict"]);
+    requireNonNegativeInteger(result.iterations, filePath, "result.json", ["iterations"]);
+    requireNonNegativeNumber(result.durationMs, filePath, "result.json", ["durationMs"]);
+    requireRange(result.correctness, 0, 1, filePath, "result.json", ["correctness"]);
+    const usage = requireRecord(result.usage, filePath, "result.json", ["usage"]);
+    requireNonNegativeInteger(usage.inputTokens, filePath, "result.json", ["usage", "inputTokens"]);
+    requireNonNegativeInteger(usage.outputTokens, filePath, "result.json", ["usage", "outputTokens"]);
+    if (usage.cachedTokens !== undefined) {
+        requireNonNegativeInteger(usage.cachedTokens, filePath, "result.json", [
+            "usage",
+            "cachedTokens"
+        ]);
+    }
+    if (usage.costUsd !== undefined) {
+        requireNonNegativeNumber(usage.costUsd, filePath, "result.json", ["usage", "costUsd"]);
+    }
+    const tests = requireRecord(result.tests, filePath, "result.json", ["tests"]);
+    const passed = requireNonNegativeInteger(tests.passed, filePath, "result.json", [
+        "tests",
+        "passed"
+    ]);
+    const total = requireNonNegativeInteger(tests.total, filePath, "result.json", ["tests", "total"]);
+    if (passed > total) {
+        throw invalidArtifactField(filePath, "result.json", ["tests", "passed"], "integer less than or equal to tests.total", passed);
+    }
+    requireRange(tests.pass_rate, 0, 1, filePath, "result.json", ["tests", "pass_rate"]);
+    if (!Array.isArray(tests.cases)) {
+        throw invalidArtifactField(filePath, "result.json", ["tests", "cases"], "array", tests.cases);
+    }
+    const scoring = requireRecord(result.scoring, filePath, "result.json", ["scoring"]);
+    validateScoringComponent(scoring.tests, filePath, ["scoring", "tests"]);
+    validateScoringComponent(scoring.judge, filePath, ["scoring", "judge"]);
+    requireBoolean(result.cheated, filePath, "result.json", ["cheated"]);
+    requireRecord(result.cheatReport, filePath, "result.json", ["cheatReport"]);
+    return result;
+}
+function validateScoringComponent(value, filePath, path) {
+    const component = requireRecord(value, filePath, "result.json", path);
+    requireBoolean(component.configured, filePath, "result.json", [...path, "configured"]);
+    requireBoolean(component.required, filePath, "result.json", [...path, "required"]);
+    requireRange(component.configuredWeight, 0, 1, filePath, "result.json", [
+        ...path,
+        "configuredWeight"
+    ]);
+    requireRange(component.effectiveWeight, 0, 1, filePath, "result.json", [
+        ...path,
+        "effectiveWeight"
+    ]);
+    requireString(component.status, filePath, "result.json", [...path, "status"]);
+}
+function validateTrace(value, filePath) {
+    const trace = requireRecord(value, filePath, "trace.json", []);
+    if (!Array.isArray(trace.events)) {
+        throw invalidArtifactField(filePath, "trace.json", ["events"], "array", trace.events);
+    }
+    return trace;
+}
+function requireRecord(value, filePath, artifact, path) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "object", value);
+}
+function requireString(value, filePath, artifact, path) {
+    if (typeof value === "string" && value.length > 0) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "non-empty string", value);
+}
+function requireBoolean(value, filePath, artifact, path) {
+    if (typeof value !== "boolean") {
+        throw invalidArtifactField(filePath, artifact, path, "boolean", value);
+    }
+}
+function requireNonNegativeInteger(value, filePath, artifact, path) {
+    if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "non-negative integer", value);
+}
+function requireNonNegativeNumber(value, filePath, artifact, path) {
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+        return value;
+    }
+    throw invalidArtifactField(filePath, artifact, path, "non-negative number", value);
+}
+function requireRange(value, min, max, filePath, artifact, path) {
+    if (typeof value === "number" && Number.isFinite(value) && value >= min && value <= max) {
+        return;
+    }
+    throw invalidArtifactField(filePath, artifact, path, `number from ${min} through ${max}`, value);
+}
+function invalidArtifactField(filePath, artifact, path, expected, received) {
+    return new Error(`Invalid ${artifact} in ${filePath} (${formatIssuePath(path)}): expected ${expected}, received ${formatReceived(received)}.`);
+}
+function formatIssuePath(path) {
+    return path.join(".") || "value";
+}
+function formatReceived(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "object" && value !== null) {
+        return Array.isArray(value) ? "array" : "object";
+    }
+    return String(value);
+}
 async function assertCanonicalOutputFile(outDir, filePath) {
     const canonicalOutDir = await realpath(path.resolve(outDir));
     const canonicalFilePath = await realpath(filePath);

package/packages/agent-eval/dist/run/fixture-copy.d.ts

@@ -0,0 +1 @@
+export declare function assertNoSymlinksInDirectoryTree(rootDir: string, label: string): Promise<void>;

package/packages/agent-eval/dist/run/fixture-copy.js

@@ -0,0 +1,24 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+export async function assertNoSymlinksInDirectoryTree(rootDir, label) {
+    await walkDirectoryTree(rootDir, label);
+}
+async function walkDirectoryTree(targetPath, label) {
+    const targetStat = await lstat(targetPath);
+    if (targetStat.isSymbolicLink()) {
+        throw new Error(`${label} must not contain symbolic links: ${targetPath}`);
+    }
+    if (!targetStat.isDirectory()) {
+        return;
+    }
+    const entries = await readdir(targetPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(targetPath, entry.name);
+        if (entry.isSymbolicLink()) {
+            throw new Error(`${label} must not contain symbolic links: ${entryPath}`);
+        }
+        if (entry.isDirectory()) {
+            await walkDirectoryTree(entryPath, label);
+        }
+    }
+}

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

@@ -19,6 +19,7 @@ import { verifyOracle } from "./oracle.js";
 import { runScorer } from "./scorer.js";
 import { createTraceNormalizer } from "./trace/normalize.js";
 import { writeRunCompletion, writeRunEvidence, writeRunResult } from "./result-writer.js";
+import { assertNoSymlinksInDirectoryTree } from "./fixture-copy.js";
 export class EvalFrameworkError extends Error {
     constructor(message) {
         super(message);
@@ -258,6 +259,7 @@ async function copyStarterIfPresent(starterDir, cloneDir) {
         }
         throw error;
     }
+    await assertNoSymlinksInDirectoryTree(starterDir, "starter");
     await cp(starterDir, cloneDir, {
         recursive: true,
         force: true

package/packages/agent-eval/dist/schema.js

@@ -1,5 +1,9 @@
 import { S, validate } from "toolcraft-schema";
 import path from "node:path";
+const nonEmptyString = S.String({ minLength: 1 });
+const positiveInteger = S.Number({ jsonType: "integer", minimum: 1 });
+const nonNegativeInteger = S.Number({ jsonType: "integer", minimum: 0 });
+const scoringWeight = S.Number({ minimum: 0, maximum: 1 });
 const metricEvaluatorSchema = S.OneOf({
     discriminator: "kind",
     branches: {
@@ -38,41 +42,41 @@ const metricSchema = S.Object({
  * oracle.solution_dest to copy it under a clone-root-relative subdirectory.
  */
 export const evalYamlSchema = S.Object({
-    id: S.String(),
-    title: S.String(),
+    id: nonEmptyString,
+    title: nonEmptyString,
     target: S.Object({
-        repo: S.String(),
-        ref: S.String(),
-        plan_dest: S.Optional(S.String({ default: "docs/plans/eval-task.md" }))
+        repo: nonEmptyString,
+        ref: nonEmptyString,
+        plan_dest: S.Optional(S.String({ default: "docs/plans/eval-task.md", minLength: 1 }))
     }),
     scorer: S.Optional(S.Object({
-        command: S.String(),
+        command: nonEmptyString,
         cwd: S.Optional(S.String({ default: "" })),
-        result_path: S.String(),
-        timeout_ms: S.Number()
+        result_path: nonEmptyString,
+        timeout_ms: nonNegativeInteger
     })),
     oracle: S.Object({
-        path: S.Optional(S.String({ default: "oracle" })),
-        solution_dest: S.Optional(S.String({ default: "." }))
+        path: S.Optional(S.String({ default: "oracle", minLength: 1 })),
+        solution_dest: S.Optional(S.String({ default: ".", minLength: 1 }))
     }),
     budget: S.Object({
-        max_iterations: S.Number(),
-        max_tokens: S.Number(),
-        wall_clock_ms: S.Number()
+        max_iterations: positiveInteger,
+        max_tokens: positiveInteger,
+        wall_clock_ms: positiveInteger
     }),
     judge: S.Object({
-        agent: S.String(),
-        model: S.String(),
-        rubric: S.Array(S.String())
+        agent: nonEmptyString,
+        model: nonEmptyString,
+        rubric: S.Array(nonEmptyString, { minItems: 1 })
     }),
     weights: S.Object({
-        tests: S.Number(),
-        judge: S.Number()
+        tests: scoringWeight,
+        judge: scoringWeight
     }),
     metrics: S.Optional(S.Array(metricSchema)),
     verify: S.Optional(S.Object({
-        command: S.String(),
-        timeout_ms: S.Number()
+        command: nonEmptyString,
+        timeout_ms: nonNegativeInteger
     }))
 });
 Object.freeze(evalYamlSchema.shape);
@@ -89,6 +93,7 @@ export function validateEvalYaml(value, filePath = "eval.yaml") {
     const result = validate(evalYamlSchema, value);
     if (result.ok) {
         const issues = [
+            ...validateNonBlankStrings(result.value),
             ...validateTarget(result.value.target),
             ...validateMetrics(result.value.metrics)
         ];
@@ -99,6 +104,42 @@ export function validateEvalYaml(value, filePath = "eval.yaml") {
     }
     throw new EvalYamlValidationError(formatIssues(filePath, result.issues), result.issues);
 }
+function validateNonBlankStrings(value) {
+    const issues = [];
+    const fields = [
+        [["id"], value.id],
+        [["title"], value.title],
+        [["target", "repo"], value.target.repo],
+        [["target", "ref"], value.target.ref],
+        [["target", "plan_dest"], value.target.plan_dest],
+        [["scorer", "command"], value.scorer?.command],
+        [["scorer", "result_path"], value.scorer?.result_path],
+        [["oracle", "path"], value.oracle.path],
+        [["oracle", "solution_dest"], value.oracle.solution_dest],
+        [["judge", "agent"], value.judge.agent],
+        [["judge", "model"], value.judge.model],
+        [["verify", "command"], value.verify?.command]
+    ];
+    for (const [fieldPath, fieldValue] of fields) {
+        if (fieldValue !== undefined && fieldValue.trim().length === 0) {
+            issues.push(blankStringIssue(fieldPath, fieldValue));
+        }
+    }
+    for (const [index, rubricLine] of value.judge.rubric.entries()) {
+        if (rubricLine.trim().length === 0) {
+            issues.push(blankStringIssue(["judge", "rubric", String(index)], rubricLine));
+        }
+    }
+    return issues;
+}
+function blankStringIssue(path, value) {
+    return {
+        path,
+        expected: "non-blank string",
+        received: JSON.stringify(value),
+        message: `${path.join(".")} must not be blank.`
+    };
+}
 function validateTarget(target) {
     const destination = target.plan_dest ?? "docs/plans/eval-task.md";
     if (path.isAbsolute(destination)) {

package/packages/agent-eval/dist/source/config.js

@@ -39,7 +39,9 @@ export async function loadSourceConfig(source, fs = nodeFs) {
     if (!isRecord(parsed)) {
         throw new Error(`${configPath} must contain a JSON object.`);
     }
-    return deepMerge(cloneDefaultConfig(), parsed);
+    const merged = deepMerge(cloneDefaultConfig(), parsed);
+    validateSourceConfig(merged, configPath);
+    return merged;
 }
 function cloneDefaultConfig() {
     return {
@@ -74,6 +76,46 @@ function deepMerge(base, patch) {
     }
     return result;
 }
+function validateSourceConfig(config, configPath) {
+    const judge = requireRecord(config.judge, configPath, "judge");
+    requireNonBlankString(judge.agent, configPath, "judge.agent");
+    requireNonBlankString(judge.model, configPath, "judge.model");
+    requireNonBlankString(config.out, configPath, "out");
+    const weights = requireRecord(config.weights, configPath, "weights");
+    requireWeight(weights.tests, configPath, "weights.tests");
+    requireWeight(weights.judge, configPath, "weights.judge");
+    if (config.clone_cache_dir !== null) {
+        requireNonBlankString(config.clone_cache_dir, configPath, "clone_cache_dir");
+    }
+}
+function requireRecord(value, configPath, fieldPath) {
+    if (isRecord(value)) {
+        return value;
+    }
+    throw invalidConfigField(configPath, fieldPath, "object", value);
+}
+function requireNonBlankString(value, configPath, fieldPath) {
+    if (typeof value !== "string") {
+        throw invalidConfigField(configPath, fieldPath, "string", value);
+    }
+    if (value.trim().length === 0) {
+        throw invalidConfigField(configPath, fieldPath, "non-blank string", value);
+    }
+}
+function requireWeight(value, configPath, fieldPath) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+        throw invalidConfigField(configPath, fieldPath, "number from 0 through 1", value);
+    }
+}
+function invalidConfigField(configPath, fieldPath, expected, received) {
+    return new Error(`${configPath} (${fieldPath}): expected ${expected}, received ${formatReceived(received)}.`);
+}
+function formatReceived(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/packages/agent-eval/dist/source/registry.js

@@ -34,6 +34,9 @@ export async function loadEval(source, id, fs = nodeFs) {
     await assertFsCanonicalContainedPath(fs, source.rootDir, evalYamlPath, "eval.yaml");
     await assertFsCanonicalContainedPath(fs, source.rootDir, planPath, "plan.md");
     const evalYaml = validateEvalYaml(parseYamlFile(await fs.readFile(evalYamlPath, "utf8"), evalYamlPath), evalYamlPath);
+    if (evalYaml.id !== id) {
+        throw new Error(`Eval id mismatch in ${evalYamlPath}: expected "${id}", found "${evalYaml.id}".`);
+    }
     const plan = parsePlanMarkdown(await fs.readFile(planPath, "utf8"), planPath);
     return {
         id: evalYaml.id,

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

@@ -50,10 +50,28 @@ function sanitizeAgentForFileName(agent) {
 function resolvePath(cwd, filePath) {
     return path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
 }
+function requireNonEmptyString(value, label) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return trimmed;
+}
+function resolveOptionalNonEmptyString(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must be a non-empty string when provided.`);
+    }
+    return trimmed;
+}
 async function resolveOutputPath(fs, cwd, analysisAgent, outputPath) {
-    if (outputPath) {
-        const absolutePath = resolvePath(cwd, outputPath);
-        return { absolutePath, resultPath: outputPath };
+    const normalizedOutputPath = resolveOptionalNonEmptyString(outputPath, "outputPath");
+    if (normalizedOutputPath) {
+        const absolutePath = resolvePath(cwd, normalizedOutputPath);
+        return { absolutePath, resultPath: normalizedOutputPath };
     }
     const configDirectory = path.join(cwd, ".poe-code");
     const defaultPath = path.join(configDirectory, "gaslight.yaml");
@@ -77,6 +95,9 @@ function resolveSince(value) {
         return milliseconds === null ? undefined : new Date(Date.now() - milliseconds);
     }
     if (value instanceof Date) {
+        if (!Number.isFinite(value.getTime())) {
+            throw new Error(`Invalid since date "${String(value)}".`);
+        }
         return value;
     }
     const milliseconds = parseDuration(value);
@@ -93,6 +114,13 @@ async function resolveDataPath(cwd, 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 resolveLimit(value) {
+    const limit = value ?? 200;
+    if (!Number.isInteger(limit) || limit <= 0) {
+        throw new Error("limit must be a positive integer.");
+    }
+    return limit;
+}
 function buildAnalysisPrompt(dataPath) {
     return [
         "Read this curated Markdown file of human prompts from coding-agent traces:",
@@ -111,7 +139,7 @@ function buildAnalysisPrompt(dataPath) {
         "- Do not put review questions, validation checks, cleanup checks, commit checks, or release checks in `prompt`; those belong in `followups`.",
         "- 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.",
+        '- 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.",
@@ -148,8 +176,7 @@ function stripIdeSelection(value) {
         if (endIndex === -1) {
             return stripped;
         }
-        stripped =
-            stripped.slice(0, startIndex) + stripped.slice(endIndex + closeTag.length);
+        stripped = stripped.slice(0, startIndex) + stripped.slice(endIndex + closeTag.length);
     }
 }
 function normalizePromptText(value, cwd, homeDir) {
@@ -234,12 +261,7 @@ function buildRepeatedShortPromptSection(records, cwd, homeDir) {
         .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", "", "No repeated short prompts were found.", ""];
     }
     return [
         "## Repeated short prompts",
@@ -418,7 +440,10 @@ function extractGeneratedConfigContent(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 outputDirectory = path.dirname(absoluteOutputPath);
+    await assertNotSymlink(fs, outputDirectory, "Output directory");
+    await fs.mkdir(outputDirectory, { recursive: true });
+    await assertNotSymlink(fs, outputDirectory, "Output directory");
     const temporaryPath = `${absoluteOutputPath}.tmp-${process.pid}-${Date.now()}`;
     await fs.writeFile(temporaryPath, `${yaml}\n`, { encoding: "utf8" });
     if (fs.rename) {
@@ -427,19 +452,40 @@ async function writeGeneratedConfig(fs, content, absoluteOutputPath) {
     }
     await fs.writeFile(absoluteOutputPath, `${yaml}\n`, { encoding: "utf8" });
 }
+async function assertNotSymlink(fs, targetPath, label) {
+    if (!fs.lstat) {
+        return;
+    }
+    try {
+        const stats = await fs.lstat(targetPath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`${label} cannot be a symbolic link: ${targetPath}`);
+        }
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return;
+        }
+        throw error;
+    }
+}
 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 analysisAgent = requireNonEmptyString(options.analysisAgent, "analysisAgent");
+    const model = resolveOptionalNonEmptyString(options.model, "model");
+    const limit = resolveLimit(options.limit);
+    const outputPathOption = resolveOptionalNonEmptyString(options.outputPath, "outputPath");
     const since = resolveSince(options.since);
     const collection = await collectHumanPrompts({
         sources: options.sources,
         cwd,
         homeDir,
         since,
-        limit: options.limit ?? 200,
+        limit,
         allWorkspaces: options.allWorkspaces,
         fs
     });
@@ -458,20 +504,20 @@ export async function ingestGaslight(options) {
     try {
         options.onEvent?.({
             type: "analysis.started",
-            agent: options.analysisAgent,
+            agent: analysisAgent,
             dataPath: dataPath.absolutePath
         });
-        const result = await spawn(options.analysisAgent, {
+        const result = await spawn(analysisAgent, {
             prompt: buildAnalysisPrompt(dataPath.absolutePath),
             cwd,
             mode: "read",
-            ...(options.model ? { model: options.model } : {})
+            ...(model ? { 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);
+        const outputPath = await resolveOutputPath(fs, cwd, analysisAgent, outputPathOption);
         await writeGeneratedConfig(fs, result.stdout, outputPath.absolutePath);
         options.onEvent?.({ type: "config.written", path: outputPath.resultPath });
         return {

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

@@ -91,6 +91,23 @@ async function archivePlan(fs, cwd, planPath) {
     }
     return archivedPath;
 }
+function archivePathForPlan(cwd, planPath) {
+    const absolutePath = path.resolve(cwd, planPath);
+    return path.join(path.dirname(absolutePath), "archive", path.basename(absolutePath));
+}
+async function assertArchiveDestinationAvailable(fs, cwd, planPath) {
+    const archivedPath = archivePathForPlan(cwd, planPath);
+    try {
+        await fs.readFile(archivedPath, "utf8");
+        throw new Error(`Archive destination already exists: ${archivedPath}`);
+    }
+    catch (error) {
+        if (!isMissingFile(error)) {
+            throw error;
+        }
+    }
+    await rejectArchiveSymlink(fs, path.dirname(archivedPath));
+}
 function validateInlineConfig(prompt, followups) {
     if ((prompt === undefined) !== (followups === undefined)) {
         throw new Error("prompt and followups must be provided together.");
@@ -103,6 +120,23 @@ function validateInlineConfig(prompt, followups) {
         throw new Error("followups must be a non-empty array of non-empty strings.");
     }
 }
+function requireNonEmptyString(value, label) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return trimmed;
+}
+function resolveModel(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error("model must be a non-empty string when provided.");
+    }
+    return trimmed;
+}
 function resolvePlanPaths(options) {
     if (options.planPaths.length === 0) {
         throw new Error("Provide at least one plan path.");
@@ -112,17 +146,30 @@ function resolvePlanPaths(options) {
             throw new Error("plan paths must be non-empty strings.");
         }
     }
-    return options.planPaths.map((planPath) => planPath.trim());
+    const planPaths = options.planPaths.map((planPath) => planPath.trim());
+    const seen = new Map();
+    for (const planPath of planPaths) {
+        const resolvedPath = path.resolve(options.cwd ?? process.cwd(), planPath);
+        const duplicate = seen.get(resolvedPath);
+        if (duplicate !== undefined) {
+            throw new Error(`Duplicate plan path: ${duplicate}`);
+        }
+        seen.set(resolvedPath, planPath);
+    }
+    return planPaths;
 }
 export async function runGaslight(options) {
     const cwd = options.cwd ?? process.cwd();
     const homeDir = options.homeDir ?? os.homedir();
     const fs = (options.fs ?? nodeFs);
     const spawn = options.spawn ?? defaultSpawn;
+    const agent = requireNonEmptyString(options.agent, "agent");
+    const model = resolveModel(options.model);
     validateInlineConfig(options.prompt, options.followups);
     const planPaths = resolvePlanPaths(options);
     for (const planPath of planPaths) {
         await requirePlan(fs, cwd, planPath);
+        await assertArchiveDestinationAvailable(fs, cwd, planPath);
     }
     const config = options.prompt !== undefined && options.followups !== undefined
         ? { prompt: options.prompt.trim(), followups: options.followups.map((value) => value.trim()) }
@@ -146,11 +193,11 @@ export async function runGaslight(options) {
                 planIndex: planIndex + 1,
                 totalPlans: planPaths.length
             });
-            const result = await spawn(options.agent, {
+            const result = await spawn(agent, {
                 prompt,
                 cwd,
                 mode: options.mode ?? "edit",
-                ...(options.model ? { model: options.model } : {}),
+                ...(model ? { model } : {}),
                 ...(resumeThreadId ? { resumeThreadId } : {}),
                 ...(options.signal ? { signal: options.signal } : {})
             });