loopengine 0.1.90 → 0.1.92

package/dist/web/interview-admin.d.ts

@@ -0,0 +1,96 @@
+import type { Message, ModelCall } from '../core/run-agent.js';
+import { type AgentCandidate, type InterviewStage, type InterviewTools } from '../core/system-agents/interviewer.js';
+import type { AgentConfig } from '../core/agent-config.js';
+export declare class InterviewError extends Error {
+}
+export interface Interview {
+    id: string;
+    startedAt: string;
+    updatedAt: string;
+    stage: InterviewStage;
+    /** What the person sees: their answers and the interviewer's replies. */
+    display: {
+        role: 'user' | 'assistant';
+        text: string;
+    }[];
+    /** What the model sees, tool calls included. */
+    transcript: Message[];
+    candidates: AgentCandidate[];
+    /** Candidate index -> the agent created from it. */
+    created: Record<string, string>;
+}
+export declare function setInterviewProject(projectDir: string): void;
+export declare function getInterview(id: string): Interview;
+/** Newest first, without the transcripts. */
+export declare function listInterviews(): Omit<Interview, 'transcript' | 'display'>[];
+export declare function startInterview(): Interview;
+export declare function deleteInterview(id: string): void;
+/** The person's answer, and the interviewer's reply. */
+export declare function answerInterview(id: string, text: unknown, modelCall: ModelCall, tools: InterviewTools): Promise<Interview>;
+/** Ends early: the interviewer ranks what it has. */
+export declare function finishInterview(id: string, modelCall: ModelCall, tools: InterviewTools): Promise<Interview>;
+export interface ChecklistItem {
+    label: string;
+    /** A console page or tab where it's done. */
+    href?: string;
+}
+/** The first free agent name based on the candidate's. */
+export declare function freeAgentName(base: string, exists: (name: string) => boolean): string;
+export interface CreateDeps {
+    agentExists(name: string): boolean;
+    /** Scaffolds and registers the agent, as Agents → + New does. */
+    createAgent(name: string, systemPrompt: string): Promise<void>;
+}
+export interface CandidatePreview {
+    name: string;
+    systemPrompt: string;
+    /** What the permission default will be, and why. */
+    permissions: string;
+    schedule?: string;
+    checklist: ChecklistItem[];
+}
+/** What's still needed once the agent exists, each linked to where it's done. */
+export declare function setupChecklist(candidate: AgentCandidate, agentName: string): ChecklistItem[];
+export declare function previewCandidate(id: string, index: number, deps: Pick<CreateDeps, 'agentExists'>): CandidatePreview;
+/** What creating `candidate` would make, under the first free name.
+ * Shared with templates (web/templates-admin.ts). */
+export declare function describeCandidate(candidate: AgentCandidate, deps: Pick<CreateDeps, 'agentExists'>): CandidatePreview;
+export interface CreatedAgent {
+    name: string;
+    checklist: ChecklistItem[];
+    exampleMessage?: string;
+    /** Set when the schedule couldn't be created; the agent still was. */
+    scheduleError?: string;
+}
+/** Creates the agent: unmatched tools ask (a new agent's default is to
+ * deny), and a schedule, if any, is created paused until setup is done. */
+export declare function createFromCandidate(id: string, index: number, deps: CreateDeps): Promise<CreatedAgent>;
+/** Creates `candidate` as an agent under the first free name: the agent
+ * itself, its permission default switched to "ask", and a paused
+ * schedule when it runs on a timer. Shared with templates
+ * (web/templates-admin.ts). */
+export declare function createAgentFromCandidate(candidate: AgentCandidate, deps: CreateDeps): Promise<CreatedAgent>;
+/** A registered agent, as the adapter's registry has it. */
+export interface InterviewAgentSource {
+    name: string;
+    config: AgentConfig;
+    createModelCall: () => ModelCall;
+}
+export interface InterviewModel {
+    modelCall: ModelCall;
+    /** For the agents it creates: the same provider and model. */
+    model: {
+        provider: string;
+        model?: string;
+    };
+}
+/** The interviewer runs on the workspace's own model: borrowed from an
+ * agent that has one set, preferring one whose provider key is set.
+ * undefined when no agent names a model. */
+export declare function pickInterviewModel(agents: InterviewAgentSource[]): InterviewModel | undefined;
+/** The model a new agent should start on: the same one the interviewer
+ * would pick, without building a model call (which throws when its key
+ * isn't set). Templates use it. */
+export declare function pickAgentModel(agents: InterviewAgentSource[]): InterviewModel['model'] | undefined;
+/** The interviewer's read-only tools over this workspace. */
+export declare function interviewTools(agents: InterviewAgentSource[]): InterviewTools;

package/dist/web/interview-admin.js

@@ -0,0 +1,258 @@
+// Backs the console's "Find your first agent": saving interviews in the
+// project (.interviews/<id>.json, next to .sessions), running each turn
+// through the interviewer (core/system-agents/interviewer.ts), and
+// turning a chosen candidate into a real agent — the same pieces a
+// person would set up by hand: the agent itself (through the adapter's
+// own create, passed in), its permission default switched to "ask", and
+// a paused schedule when it runs on a timer. Abilities aren't installed
+// here: installing one restarts the server, so they head the Finish
+// setup checklist instead, each one click away.
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createScheduledTask, pauseScheduledTask } from '../core/scheduler.js';
+import { KeyedMutex } from '../core/session-store.js';
+import { INTERVIEW_OPENING, agentNameFrom, runInterviewTurn, } from '../core/system-agents/interviewer.js';
+import { describeNotifier } from '../core/http-notifier.js';
+import { listInstalledAbilities } from '../bin/ability-manager.js';
+import { searchPublicAbilities } from './abilities-admin.js';
+import { setDefaultDecision } from './actauth-admin.js';
+import { modelKeyEnvVar } from './global-config.js';
+export class InterviewError extends Error {
+}
+// The project the interviews are saved in. The adapter sets it from its
+// own registry's projectDir() (a create-loopengine project's registry is
+// the project's own file, not this package's); the working directory
+// until then.
+let interviewProject = process.cwd();
+export function setInterviewProject(projectDir) {
+    interviewProject = projectDir;
+}
+function dir() {
+    return join(interviewProject, '.interviews');
+}
+function pathFor(id) {
+    if (!/^[a-f0-9-]{8,40}$/.test(id))
+        throw new InterviewError('No such interview');
+    return join(dir(), `${id}.json`);
+}
+function save(interview) {
+    mkdirSync(dir(), { recursive: true });
+    interview.updatedAt = new Date().toISOString();
+    writeFileSync(pathFor(interview.id), JSON.stringify(interview, null, 2));
+    return interview;
+}
+export function getInterview(id) {
+    const path = pathFor(id);
+    if (!existsSync(path))
+        throw new InterviewError('No such interview');
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+/** Newest first, without the transcripts. */
+export function listInterviews() {
+    if (!existsSync(dir()))
+        return [];
+    return readdirSync(dir())
+        .filter((f) => f.endsWith('.json'))
+        .flatMap((f) => {
+        try {
+            const { transcript: _t, display: _d, ...rest } = JSON.parse(readFileSync(join(dir(), f), 'utf8'));
+            return [rest];
+        }
+        catch {
+            return [];
+        }
+    })
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+export function startInterview() {
+    const now = new Date().toISOString();
+    return save({ id: randomUUID(), startedAt: now, updatedAt: now, stage: 'work', display: [{ role: 'assistant', text: INTERVIEW_OPENING }], transcript: [], candidates: [], created: {} });
+}
+export function deleteInterview(id) {
+    rmSync(pathFor(id), { force: true });
+}
+const locks = new KeyedMutex();
+async function turn(id, userText, shown, modelCall, tools) {
+    return locks.run(id, async () => {
+        const interview = getInterview(id);
+        const result = await runInterviewTurn(modelCall, interview.transcript, userText, tools);
+        if (shown !== undefined)
+            interview.display.push({ role: 'user', text: shown });
+        interview.display.push({ role: 'assistant', text: result.reply });
+        interview.transcript.push(...result.newMessages);
+        if (result.stage)
+            interview.stage = result.stage;
+        if (result.candidates) {
+            interview.candidates = result.candidates;
+            interview.stage = 'done';
+        }
+        return save(interview);
+    });
+}
+/** The person's answer, and the interviewer's reply. */
+export async function answerInterview(id, text, modelCall, tools) {
+    if (typeof text !== 'string' || !text.trim())
+        throw new InterviewError('Write an answer first');
+    if (text.length > 4000)
+        throw new InterviewError('That answer is too long; keep it under 4,000 characters');
+    return turn(id, text.trim(), text.trim(), modelCall, tools);
+}
+/** Ends early: the interviewer ranks what it has. */
+export async function finishInterview(id, modelCall, tools) {
+    return turn(id, '[The person chose to finish now. Rank what you have so far: call save_candidates with up to three, then set_stage("done"), then tell them briefly.]', undefined, modelCall, tools);
+}
+function candidateAt(interview, index) {
+    const candidate = interview.candidates[index];
+    if (!candidate)
+        throw new InterviewError('No such candidate');
+    return candidate;
+}
+/** The first free agent name based on the candidate's. */
+export function freeAgentName(base, exists) {
+    const name = agentNameFrom(base);
+    if (!exists(name))
+        return name;
+    for (let n = 2; n < 100; n++)
+        if (!exists(`${name}-${n}`))
+            return `${name}-${n}`;
+    return `${name}-${Date.now()}`;
+}
+/** What's still needed once the agent exists, each linked to where it's done. */
+export function setupChecklist(candidate, agentName) {
+    const tab = (t) => `/agents/config?agent=${encodeURIComponent(agentName)}&tab=${t}`;
+    const items = candidate.needs.map((need) => {
+        switch (need.kind) {
+            case 'ability':
+                return { label: `Install the ${need.name ?? need.description} ability`, href: tab('abilities') };
+            case 'api':
+                return { label: `Connect ${need.description} (an HTTP tool, or an MCP server)`, href: tab('tools') };
+            case 'key':
+                return { label: `Add ${need.description}`, href: tab('env') };
+            case 'messaging':
+                return { label: `Connect ${need.name ?? 'Slack'} so it can ask you before acting`, href: tab('messaging') };
+            default:
+                return { label: need.description };
+        }
+    });
+    if (candidate.trigger.kind === 'schedule')
+        items.push({ label: `Check when it runs (${candidate.trigger.description}), then turn its schedule on`, href: tab('schedules') });
+    return items;
+}
+export function previewCandidate(id, index, deps) {
+    return describeCandidate(candidateAt(getInterview(id), index), deps);
+}
+/** What creating `candidate` would make, under the first free name.
+ * Shared with templates (web/templates-admin.ts). */
+export function describeCandidate(candidate, deps) {
+    const name = freeAgentName(candidate.agent.name, deps.agentExists);
+    return {
+        name,
+        systemPrompt: candidate.agent.systemPrompt,
+        permissions: `Every tool asks you first until you change it${candidate.asksFirst.length ? `, including ${candidate.asksFirst.join(', ')}` : ''}.`,
+        ...(candidate.trigger.kind === 'schedule' ? { schedule: `${candidate.trigger.description} (created paused)` } : {}),
+        checklist: setupChecklist(candidate, name),
+    };
+}
+/** Creates the agent: unmatched tools ask (a new agent's default is to
+ * deny), and a schedule, if any, is created paused until setup is done. */
+export async function createFromCandidate(id, index, deps) {
+    return locks.run(id, async () => {
+        const interview = getInterview(id);
+        const candidate = candidateAt(interview, index);
+        if (interview.created[String(index)] && deps.agentExists(interview.created[String(index)])) {
+            throw new InterviewError(`Already created as ${interview.created[String(index)]}`);
+        }
+        const created = await createAgentFromCandidate(candidate, deps);
+        interview.created[String(index)] = created.name;
+        save(interview);
+        return created;
+    });
+}
+/** Creates `candidate` as an agent under the first free name: the agent
+ * itself, its permission default switched to "ask", and a paused
+ * schedule when it runs on a timer. Shared with templates
+ * (web/templates-admin.ts). */
+export async function createAgentFromCandidate(candidate, deps) {
+    const name = freeAgentName(candidate.agent.name, deps.agentExists);
+    await deps.createAgent(name, candidate.agent.systemPrompt);
+    setDefaultDecision(name, 'ask');
+    let scheduleError;
+    if (candidate.trigger.kind === 'schedule') {
+        try {
+            const task = await createScheduledTask({
+                agent: name,
+                message: candidate.agent.scheduleMessage ?? candidate.summary,
+                schedule: { every: candidate.trigger.every ?? '1d' },
+                task_name: candidate.title,
+            });
+            await pauseScheduledTask(task.task_id);
+        }
+        catch (err) {
+            scheduleError = err instanceof Error ? err.message : String(err);
+        }
+    }
+    return { name, checklist: setupChecklist(candidate, name), ...(candidate.agent.exampleMessage ? { exampleMessage: candidate.agent.exampleMessage } : {}), ...(scheduleError ? { scheduleError } : {}) };
+}
+/** The interviewer runs on the workspace's own model: borrowed from an
+ * agent that has one set, preferring one whose provider key is set.
+ * undefined when no agent names a model. */
+export function pickInterviewModel(agents) {
+    const chosen = pickModelAgent(agents);
+    if (!chosen)
+        return undefined;
+    return { modelCall: chosen.agent.createModelCall(), model: chosen.model };
+}
+/** The model a new agent should start on: the same one the interviewer
+ * would pick, without building a model call (which throws when its key
+ * isn't set). Templates use it. */
+export function pickAgentModel(agents) {
+    return pickModelAgent(agents)?.model;
+}
+function pickModelAgent(agents) {
+    const withModel = agents.filter((a) => a.config.model && typeof a.config.model === 'object' && 'provider' in a.config.model);
+    const keyed = withModel.find((a) => {
+        const envVar = modelKeyEnvVar(a.config.model.provider);
+        return envVar ? Boolean(process.env[envVar]) : false;
+    });
+    const chosen = keyed ?? withModel[0];
+    if (!chosen)
+        return undefined;
+    const m = chosen.config.model;
+    return { agent: chosen, model: { provider: m.provider, ...(m.model ? { model: m.model } : {}) } };
+}
+/** The interviewer's read-only tools over this workspace. */
+export function interviewTools(agents) {
+    return {
+        async listInstalledAbilities() {
+            return agents.flatMap((a) => {
+                try {
+                    return listInstalledAbilities(a.name).map((ability) => ({ agent: a.name, name: ability.name }));
+                }
+                catch {
+                    return [];
+                }
+            });
+        },
+        async searchPublicAbilities(query) {
+            const results = await searchPublicAbilities(query);
+            return results.slice(0, 10).map((r) => ({ name: r.name, ...(r.description ? { description: r.description } : {}) }));
+        },
+        async listConnections() {
+            const providers = ['anthropic', 'openai', 'deepseek', 'kimi', 'glm', 'gemini'].filter((p) => {
+                const envVar = modelKeyEnvVar(p);
+                return envVar ? Boolean(process.env[envVar]) : false;
+            });
+            const messaging = agents.flatMap((a) => {
+                try {
+                    const n = describeNotifier(a.config);
+                    return n.source === 'none' ? [] : [{ agent: a.name, app: n.channel }];
+                }
+                catch {
+                    return [];
+                }
+            });
+            return { modelProvidersWithKey: providers, messaging, agents: agents.map((a) => a.name) };
+        },
+    };
+}

package/dist/web/interview-page.d.ts

@@ -0,0 +1 @@
+export declare const interviewPageHtml: string;

package/dist/web/interview-page.js

@@ -0,0 +1,247 @@
+// The console's "Find your first agent" page (/interview): a chat with the
+// built-in interviewer (core/system-agents/interviewer.ts), the ranked
+// candidates it finds, and Create this agent (web/interview-admin.ts
+// behind /interviews/*). Same shell and styles as the other console
+// pages. Like them, its inline script avoids backslashes and template
+// placeholders, since it lives inside a template literal.
+import { devUiCss } from './dev-ui-styles.js';
+import { consoleShellScript, consoleSidebarHtml } from './console-shell.js';
+export const interviewPageHtml = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Find your first agent</title>
+<style>${devUiCss}
+  .iv-steps { display: flex; gap: 6px; flex-wrap: wrap; font-size: 12px; color: var(--ink-faint); }
+  .iv-steps span { padding: 2px 8px; border-radius: 999px; background: var(--surface); }
+  .iv-steps span.on { background: var(--accent-soft); color: var(--accent-ink); font-weight: 600; }
+  .iv-chat { display: grid; gap: 10px; max-width: 760px; }
+  .iv-msg { padding: 10px 14px; border-radius: 12px; white-space: pre-wrap; line-height: 1.5; font-size: 14px; max-width: 85%; }
+  .iv-msg.assistant { background: var(--surface); justify-self: start; }
+  .iv-msg.user { background: var(--accent-soft); justify-self: end; }
+  .iv-compose { display: grid; gap: 8px; max-width: 760px; }
+  .iv-compose textarea { min-height: 72px; font: inherit; padding: 10px; border: 1px solid var(--line); border-radius: var(--radius); background: var(--bg); color: var(--ink); }
+  .iv-compose .row { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
+  .iv-cards { display: grid; gap: 12px; max-width: 760px; }
+  .iv-card { border: 1px solid var(--line); border-radius: var(--radius); padding: 14px 16px; display: grid; gap: 8px; }
+  .iv-card h3 { margin: 0; font-size: 15px; }
+  .iv-card .meta { font-size: 12.5px; color: var(--ink-muted); display: grid; gap: 4px; }
+  .iv-card .row { display: flex; gap: 8px; flex-wrap: wrap; }
+  .iv-preview { border-top: 1px solid var(--line); padding-top: 10px; display: grid; gap: 8px; font-size: 13px; }
+  .iv-preview pre { white-space: pre-wrap; max-height: 180px; overflow: auto; margin: 0; }
+  .iv-list { display: grid; gap: 6px; max-width: 760px; }
+  .iv-list a { display: flex; justify-content: space-between; gap: 12px; padding: 10px 12px; border: 1px solid var(--line); border-radius: var(--radius); text-decoration: none; color: var(--ink); font-size: 13.5px; }
+  .iv-btn { display: inline-block; padding: 6px 12px; border-radius: 6px; text-decoration: none; font-size: 13px; font-weight: 500; background: var(--accent); color: var(--on-accent); }
+  .iv-btn.plain { background: none; color: var(--ink); border: 1px solid var(--line); }
+  .hint { font-size: 12px; color: var(--ink-muted); }
+  .error { font-size: 13px; color: var(--bad); }
+</style>
+</head>
+<body data-le-page="interview">
+<div class="le-app">
+${consoleSidebarHtml}
+<main class="le-main">
+  <div class="le-head plain">
+    <div class="le-head-row">
+      <div class="le-title"><button type="button" class="le-menu-btn" data-le-menu aria-label="Open navigation">&#9776;</button>
+        <div><h1>Find your first agent</h1><p>A short interview about your work. It suggests up to three agents worth building, and creates the one you pick. Every agent it creates asks you before it sends, pays, changes or deletes anything.</p></div>
+      </div>
+    </div>
+  </div>
+  <div class="le-scroll"><div class="le-page" id="ivPage"><p class="hint">Loading&hellip;</p></div></div>
+</main>
+</div>
+${consoleShellScript}
+<script>
+(function () {
+  var page = document.getElementById('ivPage');
+  var STAGES = [['work', 'Your work'], ['tools', 'Your tools'], ['tasks', 'Repeat tasks'], ['details', 'Details'], ['done', 'Results']];
+  var ELLIPSIS = String.fromCharCode(8230);
+  var current = null;
+  var busy = false;
+
+  function esc(s) {
+    return String(s == null ? '' : s).replace(/[&<>"']/g, function (c) {
+      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c];
+    });
+  }
+  function api(method, path, body) {
+    return fetch(path, { method: method, headers: body ? { 'content-type': 'application/json' } : {}, body: body ? JSON.stringify(body) : undefined, cache: 'no-store' })
+      .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); });
+  }
+  function setUrl(id) {
+    var url = new URL(location.href);
+    if (id) url.searchParams.set('id', id); else url.searchParams.delete('id');
+    history.replaceState(null, '', url.pathname + url.search);
+  }
+
+  // ---- Start page: past interviews and a Start button ----
+  function showStart(message) {
+    current = null;
+    setUrl(null);
+    api('GET', '/interviews').then(function (r) {
+      var list = (r.ok && r.body.interviews) || [];
+      var ready = r.ok && r.body.ready;
+      page.innerHTML =
+        '<section style="max-width:760px"><p>About 10 minutes, a few questions at a time, in any language. Nothing is created until you choose to.</p>' +
+        (ready ? '<button type="button" class="primary" id="ivStart">Start the interview</button>'
+               : '<p class="error">The interviewer uses the model of one of your agents, and none has a model set yet. Set one on an agent (Overview, then Model) and add its key under Models.</p>') +
+        (message ? '<p class="error">' + esc(message) + '</p>' : '') + '</section>' +
+        (list.length ? '<section><h3>Your interviews</h3><div class="iv-list">' + list.map(function (iv) {
+          var made = Object.keys(iv.created || {}).length;
+          var label = iv.candidates && iv.candidates.length ? iv.candidates.length + ' suggestion' + (iv.candidates.length === 1 ? '' : 's') + (made ? ', ' + made + ' created' : '') : 'In progress';
+          return '<a href="?id=' + esc(iv.id) + '" data-id="' + esc(iv.id) + '"><span>' + esc(new Date(iv.startedAt).toLocaleString()) + '</span><span class="hint">' + esc(label) + '</span></a>';
+        }).join('') + '</div></section>' : '');
+      var start = document.getElementById('ivStart');
+      if (start) start.addEventListener('click', function () {
+        start.disabled = true;
+        api('POST', '/interviews').then(function (r2) {
+          if (!r2.ok) { showStart(r2.body.error || 'Could not start'); return; }
+          showInterview(r2.body);
+        });
+      });
+      Array.prototype.forEach.call(page.querySelectorAll('.iv-list a'), function (a) {
+        a.addEventListener('click', function (ev) { ev.preventDefault(); load(a.getAttribute('data-id')); });
+      });
+    });
+  }
+
+  function load(id) {
+    api('GET', '/interviews/' + encodeURIComponent(id)).then(function (r) {
+      if (!r.ok) { showStart(r.body.error || 'Could not open that interview'); return; }
+      showInterview(r.body);
+    });
+  }
+
+  // ---- The interview: steps, chat, answer box, results ----
+  function stepsHtml(stage) {
+    var at = STAGES.map(function (s) { return s[0]; }).indexOf(stage);
+    return '<div class="iv-steps">' + STAGES.map(function (s, i) {
+      return '<span class="' + (i === at ? 'on' : '') + '">' + s[1] + '</span>';
+    }).join('') + '</div>';
+  }
+
+  function cardHtml(c, i, iv) {
+    var made = iv.created && iv.created[String(i)];
+    var needs = (c.needs || []).map(function (n) { return esc(n.name || n.description); }).join(', ');
+    return '<div class="iv-card" data-index="' + i + '">' +
+      '<h3>' + (i + 1) + '. ' + esc(c.title) + ' <span class="hint">' + String.fromCharCode(183) + ' saves about ' + esc(Math.round(c.hoursPerWeek * 10) / 10) + ' h a week</span></h3>' +
+      '<div>' + esc(c.summary) + '</div>' +
+      '<div class="meta">' +
+        '<div><strong>Starts:</strong> ' + esc(c.trigger.description) + '</div>' +
+        (c.asksFirst && c.asksFirst.length ? '<div><strong>Asks you first:</strong> ' + esc(c.asksFirst.join(', ')) + '</div>' : '') +
+        (needs ? '<div><strong>Needs:</strong> ' + needs + '</div>' : '') +
+      '</div>' +
+      '<div class="row">' + (made
+        ? '<a class="iv-btn" href="/agents/config?agent=' + encodeURIComponent(made) + '">Open ' + esc(made) + '</a>'
+        : '<button type="button" class="primary iv-preview-btn">Create this agent</button>') +
+      '</div><div class="iv-slot"></div></div>';
+  }
+
+  function showInterview(iv) {
+    current = iv;
+    setUrl(iv.id);
+    var done = iv.stage === 'done' && iv.candidates && iv.candidates.length;
+    page.innerHTML =
+      stepsHtml(iv.stage) +
+      '<div class="iv-chat" id="ivChat">' + iv.display.map(function (m) {
+        return '<div class="iv-msg ' + (m.role === 'user' ? 'user' : 'assistant') + '">' + esc(m.text) + '</div>';
+      }).join('') + '</div>' +
+      (done ? '<section><h3>Agents worth building</h3><div class="iv-cards">' + iv.candidates.map(function (c, i) { return cardHtml(c, i, iv); }).join('') + '</div></section>' : '') +
+      '<form class="iv-compose" id="ivCompose"><textarea name="text" placeholder="' + (done ? 'Ask about a suggestion, or for a change' : 'Your answer') + '"></textarea>' +
+        '<div class="row"><button type="submit" class="primary">Send</button>' +
+        (done ? '' : '<button type="button" id="ivFinish">Finish now</button>') +
+        '<a href="/interview" id="ivBack" class="hint" style="margin-left:auto">All interviews</a></div>' +
+        '<div id="ivStatus" class="hint"></div></form>';
+    var chat = document.getElementById('ivChat');
+    var last = chat.lastElementChild;
+    if (last && !done) last.scrollIntoView({ block: 'end' });
+    var form = document.getElementById('ivCompose');
+    var status = document.getElementById('ivStatus');
+    form.addEventListener('submit', function (ev) {
+      ev.preventDefault();
+      var text = form.querySelector('textarea').value.trim();
+      if (!text || busy) return;
+      busy = true;
+      chat.insertAdjacentHTML('beforeend', '<div class="iv-msg user">' + esc(text) + '</div><div class="iv-msg assistant hint" id="ivTyping">' + ELLIPSIS + '</div>');
+      form.querySelector('textarea').value = '';
+      document.getElementById('ivTyping').scrollIntoView({ block: 'end' });
+      api('POST', '/interviews/' + encodeURIComponent(iv.id) + '/messages', { text: text }).then(function (r) {
+        busy = false;
+        if (!r.ok) { var t = document.getElementById('ivTyping'); if (t) t.remove(); status.textContent = r.body.error || 'Something went wrong'; return; }
+        showInterview(r.body);
+      }).catch(function () { busy = false; status.textContent = 'Could not reach the server; try again.'; });
+    });
+    form.querySelector('textarea').addEventListener('keydown', function (ev) {
+      if (ev.key === 'Enter' && (ev.metaKey || ev.ctrlKey)) form.requestSubmit();
+    });
+    var finish = document.getElementById('ivFinish');
+    if (finish) finish.addEventListener('click', function () {
+      if (busy) return;
+      busy = true;
+      finish.disabled = true;
+      status.textContent = 'Ranking what it has' + ELLIPSIS;
+      api('POST', '/interviews/' + encodeURIComponent(iv.id) + '/finish').then(function (r) {
+        busy = false;
+        if (!r.ok) { finish.disabled = false; status.textContent = r.body.error || 'Something went wrong'; return; }
+        showInterview(r.body);
+      });
+    });
+    document.getElementById('ivBack').addEventListener('click', function (ev) { ev.preventDefault(); showStart(); });
+    Array.prototype.forEach.call(page.querySelectorAll('.iv-preview-btn'), function (btn) {
+      btn.addEventListener('click', function () { preview(btn.closest('.iv-card')); });
+    });
+  }
+
+  // ---- Create this agent: preview, then create, then Finish setup ----
+  function checklistHtml(items) {
+    if (!items.length) return '<p>Nothing else to set up.</p>';
+    return '<ul style="margin:0;padding-left:18px">' + items.map(function (it) {
+      return '<li>' + (it.href ? '<a href="' + esc(it.href) + '">' + esc(it.label) + '</a>' : esc(it.label)) + '</li>';
+    }).join('') + '</ul>';
+  }
+
+  function preview(card) {
+    var i = card.getAttribute('data-index');
+    var slot = card.querySelector('.iv-slot');
+    slot.innerHTML = '<p class="hint">Loading' + ELLIPSIS + '</p>';
+    api('GET', '/interviews/' + encodeURIComponent(current.id) + '/candidates/' + i + '/preview').then(function (r) {
+      if (!r.ok) { slot.innerHTML = '<p class="error">' + esc(r.body.error || 'Could not prepare it') + '</p>'; return; }
+      var p = r.body;
+      slot.innerHTML = '<div class="iv-preview">' +
+        '<div><strong>Agent:</strong> <code>' + esc(p.name) + '</code></div>' +
+        '<div><strong>Instructions:</strong><pre>' + esc(p.systemPrompt) + '</pre></div>' +
+        '<div><strong>Permissions:</strong> ' + esc(p.permissions) + '</div>' +
+        (p.schedule ? '<div><strong>Schedule:</strong> ' + esc(p.schedule) + '</div>' : '') +
+        '<div><strong>Then, to finish setup:</strong>' + checklistHtml(p.checklist) + '</div>' +
+        '<div class="row"><button type="button" class="primary iv-create">Create it</button><button type="button" class="iv-cancel">Cancel</button></div>' +
+        '<div class="hint iv-create-status"></div></div>';
+      slot.querySelector('.iv-cancel').addEventListener('click', function () { slot.innerHTML = ''; });
+      slot.querySelector('.iv-create').addEventListener('click', function (ev) {
+        var btn = ev.currentTarget;
+        btn.disabled = true;
+        slot.querySelector('.iv-create-status').textContent = 'Creating' + ELLIPSIS;
+        api('POST', '/interviews/' + encodeURIComponent(current.id) + '/candidates/' + i + '/create').then(function (r2) {
+          if (!r2.ok) { btn.disabled = false; slot.querySelector('.iv-create-status').textContent = r2.body.error || 'Could not create it'; return; }
+          var c = r2.body;
+          slot.innerHTML = '<div class="iv-preview">' +
+            '<div><strong>Created <code>' + esc(c.name) + '</code>.</strong> It asks you before every tool until you change that in its Permissions tab.</div>' +
+            (c.scheduleError ? '<div class="error">Its schedule wasn' + String.fromCharCode(8217) + 't created: ' + esc(c.scheduleError) + '. Add one in its Schedules tab.</div>' : '') +
+            '<div><strong>Finish setup:</strong>' + checklistHtml(c.checklist) + '</div>' +
+            (c.exampleMessage ? '<div><strong>Try it</strong> in Chat with: <em>' + esc(c.exampleMessage) + '</em></div>' : '') +
+            '<div class="row"><a class="iv-btn" href="/agents/config?agent=' + encodeURIComponent(c.name) + '">Open ' + esc(c.name) + '</a>' +
+            '<a class="iv-btn plain" href="' + esc(leShell.tabHref(c.name, 'chat')) + '">Try it in Chat</a></div></div>';
+          current.created = current.created || {};
+          current.created[String(i)] = c.name;
+        });
+      });
+    });
+  }
+
+  var initial = new URLSearchParams(location.search).get('id');
+  if (initial) load(initial); else showStart();
+})();
+</script>
+</body>
+</html>`;

package/dist/web/templates-admin.d.ts

@@ -0,0 +1,19 @@
+import { type CandidatePreview, type CreateDeps, type CreatedAgent } from './interview-admin.js';
+export declare class TemplateError extends Error {
+}
+/** A template as the page's cards show it. */
+export interface TemplateSummary {
+    id: string;
+    category: string;
+    title: string;
+    summary: string;
+    trigger: string;
+    asksFirst: string[];
+    needs: string[];
+    schedule: boolean;
+}
+export declare function listTemplates(): TemplateSummary[];
+export declare function previewTemplate(id: string, deps: Pick<CreateDeps, 'agentExists'>): CandidatePreview;
+/** Creates a new agent from the template, under the first free name, so
+ * the same template can be used more than once. */
+export declare function createFromTemplate(id: string, deps: CreateDeps): Promise<CreatedAgent>;