ai-foreman 1.4.0 → 1.5.0

package/dist/adapters/codex.js

@@ -77,6 +77,7 @@ export class CodexAdapter {
         const args = [
             "exec",
             "--json",
+            "--skip-git-repo-check",
             "--sandbox",
             this.opts.sandboxMode ?? "workspace-write",
             "-C",

package/dist/agentRun.d.ts

@@ -43,6 +43,7 @@ export interface RoleInstructionRunResult {
     runtime: AgentRuntime;
     model?: string;
     effort?: EffortLevel;
+    sessionId?: string;
     logPath: string;
     roleBundle: RoleBundle;
     skills: string[];

package/dist/agentRun.js

@@ -133,6 +133,10 @@ export async function runRoleInstruction(opts) {
         if (opts.logEvent) {
             log.write(opts.logEvent, {
                 role: opts.role,
+                runtime,
+                model,
+                effort,
+                sessionId: builder.sessionId(),
                 statusKind: turn.status.kind,
                 summary: turn.status.summary,
                 reason: turn.status.reason,
@@ -140,7 +144,7 @@ export async function runRoleInstruction(opts) {
                 isError: turn.result.isError,
             });
         }
-        return { turn, runtime, model, effort, logPath, roleBundle, skills };
+        return { turn, runtime, model, effort, sessionId: builder.sessionId(), logPath, roleBundle, skills };
     }
     catch (err) {
         await builder.close().catch(() => { });

package/dist/cli/tickets.js

@@ -13,7 +13,8 @@ import { validateDocsRoot } from "../tickets/config.js";
 import { importExternalSources, importFromMarkdown, validateExternalSourceAccess } from "../tickets/importer.js";
 import { formatValidationIssues } from "../tickets/validate.js";
 import { assertEffortLevel, createRoleBuilder, makeLogPath, } from "../agentRun.js";
-import { DEFAULT_TICKET_SETUP, defaultAppName, ensureRafiConfigForTicketSetup, externalSources, hasTicketSetupConfig, loadTicketSetupConfig, loadTicketSetupConfigWithDefaults, localSourcePaths, mergeTicketSetup, recommendedBuildDefaults, saveTicketSetupConfig, } from "../tickets/setupConfig.js";
+import { DEFAULT_TICKET_SETUP, configuredPlanningSources, defaultAppName, ensureRafiConfigForTicketSetup, externalSources, hasTicketSetupConfig, loadTicketSetupConfig, loadTicketSetupConfigWithDefaults, localSourcePaths, mergeTicketSetup, recommendedBuildDefaults, saveTicketSetupConfig, } from "../tickets/setupConfig.js";
+import { checkpointInterview, completeInterview, createInterviewRecord, failInterview, } from "../interviews.js";
 function fail(msg) {
     console.error(`foreman tickets: ${msg}`);
     process.exit(1);
@@ -138,72 +139,113 @@ async function cmdSetupInitCli(opts) {
     const dir = cwd(opts);
     if (!existsSync(dir))
         fail(`project directory not found: ${dir}`);
+    let interview = beginTicketSetupInterview(dir, "tickets-setup-init", opts);
     if (hasTicketSetupConfig(dir)) {
         console.log("foreman tickets setup: existing setup found; opening setup:update");
         await cmdSetupUpdateCli(opts);
+        if (interview)
+            completeInterview(dir, interview);
         return;
     }
-    const answers = await collectTicketSetup(dir, opts, undefined);
-    ensureRafiConfigForTicketSetup(dir, {
-        appName: opts.appName ?? defaultAppName(dir),
-        docsRoot: opts.docsRoot,
-        targets: parseRuntimeTargets(opts.runtime),
-    });
-    saveTicketSetupConfig(dir, answers, {
-        appName: opts.appName ?? defaultAppName(dir),
-        docsRoot: opts.docsRoot,
-        targets: parseRuntimeTargets(opts.runtime),
-    });
-    console.log(`foreman tickets setup: saved ticket setup in ${join(dir, "rafi-config.yaml")}`);
-    await validateConfiguredSourcesIfRequested(answers, Boolean(opts.skipAccessCheck));
-    if (!isTicketsInitialized(dir)) {
-        cmdInit(dir, {
+    try {
+        const answers = await collectTicketSetup(dir, opts, undefined);
+        if (interview)
+            interview = checkpointInterview(dir, interview, { checkpoint: "save-setup", answers: { setup: answers } });
+        ensureRafiConfigForTicketSetup(dir, {
             appName: opts.appName ?? defaultAppName(dir),
-            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
             docsRoot: opts.docsRoot,
+            targets: parseRuntimeTargets(opts.runtime),
         });
-        console.log("foreman tickets setup: initialized .tickets/");
-    }
-    if (shouldPrompt(opts)) {
-        const populate = await confirm({
-            message: "Run ticket population now?",
-            initialValue: answers.sources.length > 0,
+        saveTicketSetupConfig(dir, answers, {
+            appName: opts.appName ?? defaultAppName(dir),
+            docsRoot: opts.docsRoot,
+            targets: parseRuntimeTargets(opts.runtime),
         });
-        if (isCancel(populate))
-            process.exit(0);
-        if (populate) {
-            await cmdPopulateCli({ project: dir, yes: true });
+        console.log(`foreman tickets setup: saved ticket setup in ${join(dir, "rafi-config.yaml")}`);
+        await validateConfiguredSourcesIfRequested(answers, Boolean(opts.skipAccessCheck));
+        if (!isTicketsInitialized(dir)) {
+            if (interview)
+                interview = checkpointInterview(dir, interview, { checkpoint: "initialize-tracker" });
+            cmdInit(dir, {
+                appName: opts.appName ?? defaultAppName(dir),
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                docsRoot: opts.docsRoot,
+            });
+            console.log("foreman tickets setup: initialized .tickets/");
+        }
+        if (shouldPrompt(opts)) {
+            if (interview)
+                interview = checkpointInterview(dir, interview, { checkpoint: "populate-confirmation" });
+            const populate = await confirm({
+                message: "Run ticket population now?",
+                initialValue: answers.sources.length > 0,
+            });
+            if (isCancel(populate))
+                return;
+            if (populate) {
+                await cmdPopulateCli({ project: dir, yes: true });
+            }
+        }
+        else {
+            console.log(`foreman tickets setup: next — run \`foreman tickets populate --project ${shellQuote(dir)}\``);
         }
+        if (interview)
+            completeInterview(dir, interview);
     }
-    else {
-        console.log(`foreman tickets setup: next — run \`foreman tickets populate --project ${shellQuote(dir)}\``);
+    catch (error) {
+        if (interview)
+            failInterview(dir, interview, interview.checkpoint, error);
+        throw error;
     }
 }
 async function cmdSetupUpdateCli(opts) {
     const dir = cwd(opts);
     if (!existsSync(dir))
         fail(`project directory not found: ${dir}`);
-    const current = loadTicketSetupConfigWithDefaults(dir);
-    const patch = await collectTicketSetupPatch(dir, opts, current);
-    const next = mergeTicketSetup(current, patch);
-    ensureRafiConfigForTicketSetup(dir, {
-        appName: opts.appName ?? defaultAppName(dir),
-        docsRoot: opts.docsRoot,
-        targets: parseRuntimeTargets(opts.runtime),
-    });
-    saveTicketSetupConfig(dir, next, {
-        appName: opts.appName ?? defaultAppName(dir),
-        docsRoot: opts.docsRoot,
-        targets: parseRuntimeTargets(opts.runtime),
-    });
-    console.log(`foreman tickets setup: updated ticket setup in ${join(dir, "rafi-config.yaml")}`);
-    await validateConfiguredSourcesIfRequested(next, Boolean(opts.skipAccessCheck));
-    if (isTicketsInitialized(dir)) {
-        const rows = cmdQueue(dir, 1);
-        if (rows.length === 0) {
-            console.log(`foreman tickets setup: queue is empty; run \`foreman tickets populate --project ${shellQuote(dir)}\` to import or refresh tickets.`);
+    let interview = beginTicketSetupInterview(dir, "tickets-setup-update", opts);
+    try {
+        const current = loadTicketSetupConfigWithDefaults(dir);
+        const patch = await collectTicketSetupPatch(dir, opts, current);
+        const next = mergeTicketSetup(current, patch);
+        if (interview)
+            interview = checkpointInterview(dir, interview, { checkpoint: "save-setup", answers: { setup: next } });
+        ensureRafiConfigForTicketSetup(dir, {
+            appName: opts.appName ?? defaultAppName(dir),
+            docsRoot: opts.docsRoot,
+            targets: parseRuntimeTargets(opts.runtime),
+        });
+        saveTicketSetupConfig(dir, next, {
+            appName: opts.appName ?? defaultAppName(dir),
+            docsRoot: opts.docsRoot,
+            targets: parseRuntimeTargets(opts.runtime),
+        });
+        console.log(`foreman tickets setup: updated ticket setup in ${join(dir, "rafi-config.yaml")}`);
+        await validateConfiguredSourcesIfRequested(next, Boolean(opts.skipAccessCheck));
+        if (isTicketsInitialized(dir)) {
+            const rows = cmdQueue(dir, 1);
+            if (rows.length === 0) {
+                console.log(`foreman tickets setup: queue is empty; run \`foreman tickets populate --project ${shellQuote(dir)}\` to import or refresh tickets.`);
+            }
         }
+        if (interview)
+            completeInterview(dir, interview);
     }
+    catch (error) {
+        if (interview)
+            failInterview(dir, interview, interview.checkpoint, error);
+        throw error;
+    }
+}
+function beginTicketSetupInterview(projectDir, workflow, opts) {
+    if (!shouldPrompt(opts))
+        return undefined;
+    const record = createInterviewRecord({
+        workflow,
+        invocation: { projectDir, ...opts },
+        checkpoint: "setup-section",
+        outputs: ["rafi-config.yaml", ".tickets/config.yaml"],
+    });
+    return checkpointInterview(projectDir, record, { checkpoint: "setup-section" });
 }
 async function collectTicketSetup(dir, opts, current) {
     const patch = await collectTicketSetupPatch(dir, opts, current ?? DEFAULT_TICKET_SETUP);
@@ -229,8 +271,11 @@ async function collectTicketSetupPatch(dir, opts, current) {
         buildPatch.auto_merge_timeout_minutes = parseOptionalPositiveInteger(opts.autoMergeTimeoutMinutes, "--auto-merge-timeout-minutes");
     }
     if (!shouldPrompt(opts)) {
+        const prefill = current.sources.length === 0
+            ? configuredPlanningSources(dir).map((path) => ({ type: "local", paths: [path] }))
+            : current.sources;
         return {
-            sources: nonInteractiveSources.length > 0 ? nonInteractiveSources : current.sources,
+            sources: nonInteractiveSources.length > 0 ? nonInteractiveSources : prefill,
             populate: populatePatch,
             build: Object.keys(buildPatch).length > 0 ? buildPatch : {},
         };
@@ -246,7 +291,12 @@ async function collectTicketSetupPatch(dir, opts, current) {
     });
     if (isCancel(section))
         process.exit(0);
-    let sources = nonInteractiveSources.length > 0 ? nonInteractiveSources : current.sources;
+    // Do not silently persist planning hints over a completed ticket setup. They
+    // are only the initial local-source suggestion for a fresh setup.
+    const planningPrefill = current.sources.length === 0
+        ? configuredPlanningSources(dir).map((path) => ({ type: "local", paths: [path] }))
+        : current.sources;
+    let sources = nonInteractiveSources.length > 0 ? nonInteractiveSources : planningPrefill;
     if (section === "sources" || section === "all") {
         sources = await promptTicketSources(dir, current.sources);
     }

package/dist/interviews.d.ts

@@ -0,0 +1,68 @@
+export declare const INTERVIEW_STATE_VERSION = 1;
+export declare const INTERVIEW_DIRECTORY = ".rafi/interviews";
+export type InterviewWorkflow = "create" | "plan" | "tickets-setup-init" | "tickets-setup-update";
+export type InterviewStatus = "in_progress" | "needs_review" | "completed" | "incompatible";
+export interface InterviewRuntimeState {
+    runtime?: "claude" | "codex";
+    model?: string;
+    sessionId?: string;
+    /** True when a session id could not be resumed and a fresh session is needed. */
+    continuityLost?: boolean;
+}
+export interface InterviewOutputFingerprint {
+    path: string;
+    sha256: string | null;
+}
+export interface InterviewFailure {
+    checkpoint: string;
+    summary: string;
+    at: string;
+}
+export interface InterviewRecord {
+    version: number;
+    id: string;
+    workflow: InterviewWorkflow;
+    status: InterviewStatus;
+    /** Arguments/context required to re-enter the runner. No environment secrets. */
+    invocation: Record<string, unknown>;
+    answers: Record<string, unknown>;
+    checkpoint: string;
+    runtime: InterviewRuntimeState;
+    outputs: InterviewOutputFingerprint[];
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+    failure?: InterviewFailure;
+}
+export interface InterviewRecordProblem {
+    path: string;
+    reason: string;
+}
+export interface InterviewReadResult {
+    records: InterviewRecord[];
+    problems: InterviewRecordProblem[];
+}
+export declare function interviewDirectory(projectDir: string): string;
+export declare function createInterviewRecord(input: {
+    workflow: InterviewWorkflow;
+    invocation: Record<string, unknown>;
+    answers?: Record<string, unknown>;
+    checkpoint: string;
+    outputs?: string[];
+    now?: Date;
+}): InterviewRecord;
+/** Ensure ignored local state exists without modifying unrelated gitignore text. */
+export declare function ensureInterviewGitignore(projectDir: string): void;
+export declare function saveInterviewRecord(projectDir: string, record: InterviewRecord, now?: Date): InterviewRecord;
+export declare function checkpointInterview(projectDir: string, record: InterviewRecord, update: Partial<Pick<InterviewRecord, "answers" | "checkpoint" | "runtime" | "outputs" | "invocation" | "status">>): InterviewRecord;
+export declare function failInterview(projectDir: string, record: InterviewRecord, checkpoint: string, error: unknown): InterviewRecord;
+export declare function completeInterview(projectDir: string, record: InterviewRecord, now?: Date): InterviewRecord;
+export declare function readInterviewRecords(projectDir: string): InterviewReadResult;
+export declare function unfinishedInterviews(projectDir: string): InterviewRecord[];
+export declare function findInterviewRecord(projectDir: string, id: string): InterviewRecord | undefined;
+export declare function discardInterview(projectDir: string, id: string): boolean;
+/** Remove only completed records past retention; malformed/incompatible files stay for explicit discard. */
+export declare function pruneCompletedInterviews(projectDir: string, now?: Date): string[];
+export declare function fingerprintOutputs(projectDir: string, paths: string[]): InterviewOutputFingerprint[];
+export declare function outputsChanged(projectDir: string, fingerprints: InterviewOutputFingerprint[]): string[];
+export declare function redactFailure(error: unknown): string;

package/dist/interviews.js

@@ -0,0 +1,184 @@
+/**
+ * Durable, local state for commands that ask a human questions.  This lives in
+ * ai-foreman (rather than a CLI package) because `rafi tickets` is implemented
+ * there too.  Records deliberately contain decisions and small diagnostics,
+ * never a transcript or command output.
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join, relative, resolve } from "node:path";
+export const INTERVIEW_STATE_VERSION = 1;
+export const INTERVIEW_DIRECTORY = ".rafi/interviews";
+const MAX_FAILURE_LENGTH = 1_000;
+const COMPLETE_RETENTION_MS = 30 * 24 * 60 * 60 * 1_000;
+export function interviewDirectory(projectDir) {
+    return join(resolve(projectDir), INTERVIEW_DIRECTORY);
+}
+export function createInterviewRecord(input) {
+    const stamp = (input.now ?? new Date()).toISOString();
+    return {
+        version: INTERVIEW_STATE_VERSION,
+        id: randomUUID(),
+        workflow: input.workflow,
+        status: "in_progress",
+        invocation: { ...input.invocation },
+        answers: { ...(input.answers ?? {}) },
+        checkpoint: input.checkpoint,
+        runtime: {},
+        outputs: fingerprintOutputs(String(input.invocation.projectDir ?? ""), input.outputs ?? []),
+        createdAt: stamp,
+        updatedAt: stamp,
+    };
+}
+/** Ensure ignored local state exists without modifying unrelated gitignore text. */
+export function ensureInterviewGitignore(projectDir) {
+    const root = resolve(projectDir);
+    const path = join(root, ".gitignore");
+    const line = ".rafi/interviews/";
+    const current = existsSync(path) ? readFileSync(path, "utf8") : "";
+    if (current.split(/\r?\n/).some((entry) => entry.trim() === line))
+        return;
+    const prefix = current && !current.endsWith("\n") ? "\n" : "";
+    writeFileSync(path, `${current}${prefix}${line}\n`, "utf8");
+}
+export function saveInterviewRecord(projectDir, record, now = new Date()) {
+    validateRecord(record);
+    const directory = interviewDirectory(projectDir);
+    mkdirSync(directory, { recursive: true });
+    ensureInterviewGitignore(projectDir);
+    const next = { ...record, updatedAt: now.toISOString() };
+    const path = interviewRecordPath(projectDir, next.id);
+    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    renameSync(temp, path);
+    return next;
+}
+export function checkpointInterview(projectDir, record, update) {
+    const next = {
+        ...record,
+        ...update,
+        answers: update.answers ? { ...update.answers } : record.answers,
+        runtime: update.runtime ? { ...update.runtime } : record.runtime,
+        invocation: update.invocation ? { ...update.invocation } : record.invocation,
+        outputs: update.outputs ? update.outputs.map((output) => ({ ...output })) : record.outputs,
+    };
+    return saveInterviewRecord(projectDir, next);
+}
+export function failInterview(projectDir, record, checkpoint, error) {
+    const at = new Date().toISOString();
+    return saveInterviewRecord(projectDir, {
+        ...record,
+        status: record.status === "needs_review" ? "needs_review" : "in_progress",
+        checkpoint,
+        failure: { checkpoint, at, summary: redactFailure(error) },
+    });
+}
+export function completeInterview(projectDir, record, now = new Date()) {
+    const stamp = now.toISOString();
+    return saveInterviewRecord(projectDir, {
+        ...record,
+        status: "completed",
+        completedAt: stamp,
+        failure: undefined,
+    }, now);
+}
+export function readInterviewRecords(projectDir) {
+    const directory = interviewDirectory(projectDir);
+    if (!existsSync(directory))
+        return { records: [], problems: [] };
+    const records = [];
+    const problems = [];
+    for (const name of readFileNames(directory)) {
+        const path = join(directory, name);
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf8"));
+            const record = parseInterviewRecord(parsed);
+            records.push(record);
+        }
+        catch (error) {
+            problems.push({ path, reason: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return { records, problems };
+}
+export function unfinishedInterviews(projectDir) {
+    return readInterviewRecords(projectDir).records.filter((record) => record.status === "in_progress" || record.status === "needs_review" || record.status === "incompatible");
+}
+export function findInterviewRecord(projectDir, id) {
+    return readInterviewRecords(projectDir).records.find((record) => record.id === id || record.id.startsWith(id));
+}
+export function discardInterview(projectDir, id) {
+    const record = findInterviewRecord(projectDir, id);
+    if (!record)
+        return false;
+    rmSync(interviewRecordPath(projectDir, record.id));
+    return true;
+}
+/** Remove only completed records past retention; malformed/incompatible files stay for explicit discard. */
+export function pruneCompletedInterviews(projectDir, now = new Date()) {
+    const removed = [];
+    for (const record of readInterviewRecords(projectDir).records) {
+        if (record.status !== "completed" || !record.completedAt)
+            continue;
+        if (now.getTime() - new Date(record.completedAt).getTime() <= COMPLETE_RETENTION_MS)
+            continue;
+        rmSync(interviewRecordPath(projectDir, record.id));
+        removed.push(record.id);
+    }
+    return removed;
+}
+export function fingerprintOutputs(projectDir, paths) {
+    if (!projectDir)
+        return paths.map((path) => ({ path, sha256: null }));
+    return paths.map((path) => ({ path, sha256: fingerprintFile(projectDir, path) }));
+}
+export function outputsChanged(projectDir, fingerprints) {
+    return fingerprints
+        .filter((fingerprint) => fingerprintFile(projectDir, fingerprint.path) !== fingerprint.sha256)
+        .map((fingerprint) => fingerprint.path);
+}
+export function redactFailure(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    return raw
+        .replace(/((?:api[_-]?key|token|password|secret)\s*[=:])\s*[^\s,;]+/gi, "$1<redacted>")
+        .replace(/\b(?:sk|rk|ghp|github_pat)_[A-Za-z0-9_-]+\b/g, "<redacted>")
+        .replace(/\s+/g, " ")
+        .slice(0, MAX_FAILURE_LENGTH);
+}
+function interviewRecordPath(projectDir, id) {
+    return join(interviewDirectory(projectDir), `${id}.json`);
+}
+function readFileNames(directory) {
+    return readdirSync(directory).filter((name) => name.endsWith(".json"));
+}
+function fingerprintFile(projectDir, path) {
+    const root = resolve(projectDir);
+    const absolute = resolve(root, path);
+    if (relative(root, absolute).startsWith(".."))
+        return null;
+    if (!existsSync(absolute))
+        return null;
+    return createHash("sha256").update(readFileSync(absolute)).digest("hex");
+}
+function parseInterviewRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid interview record");
+    const record = value;
+    if (record.version !== INTERVIEW_STATE_VERSION) {
+        // Preserve it on disk. The caller can show it and require an explicit discard.
+        if (typeof record.id === "string" && typeof record.workflow === "string") {
+            return { ...record, status: "incompatible" };
+        }
+        throw new Error(`unsupported interview record version: ${String(record.version)}`);
+    }
+    validateRecord(record);
+    return record;
+}
+function validateRecord(record) {
+    if (record.version !== INTERVIEW_STATE_VERSION)
+        throw new Error("unsupported interview record version");
+    if (!record.id || !record.workflow || !record.checkpoint || !record.createdAt || !record.updatedAt) {
+        throw new Error("invalid interview record");
+    }
+}

package/dist/runtimeAuth.js

@@ -25,7 +25,7 @@ export function checkRuntimeReady(projectDir, runtime) {
             });
         }
         else {
-            execFileSync("codex", ["exec", "-C", projectDir, "Return exactly OK"], {
+            execFileSync("codex", ["exec", "--skip-git-repo-check", "-C", projectDir, "Return exactly OK"], {
                 cwd: projectDir,
                 encoding: "utf8",
                 stdio: ["ignore", "pipe", "pipe"],

package/dist/tickets/setupConfig.d.ts

@@ -65,6 +65,12 @@ export declare function mergeTicketSetup(current: TicketsSetupConfig | undefined
     build: Partial<TicketBuildSetupConfig>;
 }>): TicketsSetupConfig;
 export declare function localSourcePaths(setup: TicketsSetupConfig | undefined): string[];
+/**
+ * Create records planning hints separately from completed ticket setup.  Use
+ * them only as a setup prefill so `tickets.sources` remains the source of
+ * truth once the user has configured ticket ingestion.
+ */
+export declare function configuredPlanningSources(projectDir: string): string[];
 export declare function externalSources(setup: TicketsSetupConfig | undefined): Extract<TicketSourceConfig, {
     type: "linear" | "jira";
 }>[];

package/dist/tickets/setupConfig.js

@@ -106,6 +106,18 @@ export function localSourcePaths(setup) {
         .filter((source) => source.type === "local")
         .flatMap((source) => source.paths));
 }
+/**
+ * Create records planning hints separately from completed ticket setup.  Use
+ * them only as a setup prefill so `tickets.sources` remains the source of
+ * truth once the user has configured ticket ingestion.
+ */
+export function configuredPlanningSources(projectDir) {
+    const raw = loadRafiConfigObject(projectDir);
+    const planning = raw?.planning;
+    if (!Array.isArray(planning?.sources))
+        return [];
+    return unique(planning.sources.filter((source) => typeof source === "string" && source.trim().length > 0).map((source) => source.trim()));
+}
 export function externalSources(setup) {
     return (setup?.sources ?? []).filter((source) => source.type === "linear" || source.type === "jira");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-foreman",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "An orchestrator that keeps Codex CLI / Claude Code builders moving through their step list unattended. Part of Rafi.",
   "license": "Apache-2.0",
   "type": "module",
@@ -21,6 +21,10 @@
       "types": "./dist/agentRun.d.ts",
       "default": "./dist/agentRun.js"
     },
+    "./interviews.js": {
+      "types": "./dist/interviews.d.ts",
+      "default": "./dist/interviews.js"
+    },
     "./cli/tickets.js": {
       "types": "./dist/cli/tickets.d.ts",
       "default": "./dist/cli/tickets.js"
@@ -69,7 +73,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.148"
   },
   "dependencies": {
-    "special-agents": "0.5.0",
+    "special-agents": "0.6.0",
     "@clack/prompts": "^1.4.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",