@chloejs/core 0.2.3 → 0.3.0

package/core/steps.ts

@@ -19,7 +19,9 @@ import { randomUUID } from "node:crypto";
 import { z } from "zod";
 
 import { deliver, owner as whoOwns } from "#chloe/model/ask.ts";
+import { duringRun } from "#chloe/core/current.ts";
 import { db } from "#chloe/core/db.ts";
+import { afterRun, beforeRun } from "#chloe/services/historyService.ts";
 import { oneLineSummary } from "#chloe/core/markdown.ts";
 import type { Agent, Job } from "#chloe/load/load.ts";
 import { ask as askModel, type Message } from "#chloe/model/model.ts";
@@ -336,21 +338,29 @@ async function drive(ctx: Ctx): Promise<Result> {
     signal: ctx.signal,
   };
 
+  // Whatever the memory holds when the run stops, finished or waiting, is what it did.
+  const committed = (end: { summary?: string | null; error?: string }) =>
+    afterRun(ctx.agent, ctx.runId, { job: ctx.job.id, source: sourceOf(ctx.runId), ...end });
+  await beforeRun(ctx.agent, ctx.runId);
+
   try {
-    const value = await ctx.job.run!(api);
+    const value = await duringRun(ctx.runId, () => ctx.job.run!(api));
     ctx.parked = undefined;
     const reply = typeof value === "string" ? value : JSON.stringify(value ?? { ok: true }, null, 2);
     const summary = summarise(ctx.job, value);
     finish(ctx, reply, summary);
+    await committed({ summary });
     return { runId: ctx.runId, text: reply, summary, reply: chatReply(ctx.job, value) ?? summary ?? undefined, steps: ctx.lines.length, cost: ctx.cost, parked: false };
   } catch (error) {
     if (error instanceof Waiting) {
       save(ctx);
+      await committed({ summary: `waiting on ${ctx.parked?.who ?? "an answer"}` });
       return { runId: ctx.runId, text: error.message, steps: ctx.lines.length, cost: ctx.cost, parked: true };
     }
     ctx.parked = undefined;
     const why = error instanceof Error ? error.message : String(error);
     fail(ctx, why);
+    await committed({ error: why });
     if (error instanceof Unanswered || error instanceof Changed) {
       return { runId: ctx.runId, text: why, steps: ctx.lines.length, cost: ctx.cost, parked: false };
     }
@@ -358,6 +368,11 @@ async function drive(ctx: Ctx): Promise<Result> {
   }
 }
 
+/** The channel a run came in on, as its row says. */
+function sourceOf(runId: string): string {
+  return (db.prepare("select source from runs where id = ?").get(runId) as { source?: string } | undefined)?.source ?? "unknown";
+}
+
 /**
  * The replay. A step that is already in the record hands back what it returned
  * and does not run. The name is checked as well as the place, because a job

package/core/turn.ts

@@ -5,12 +5,14 @@ import { randomUUID } from "node:crypto";
 
 import { z } from "zod";
 
+import { duringRun } from "#chloe/core/current.ts";
 import { db } from "#chloe/core/db.ts";
 import { oneLineSummary } from "#chloe/core/markdown.ts";
 import type { Agent, ChatHistory, Skill } from "#chloe/load/load.ts";
 import { ask, type Attachment, type Message, type ToolCall } from "#chloe/model/model.ts";
 import { recall, remember } from "#chloe/model/memory.ts";
 import { describe, type Approve, type Call, type Tool, type Tools } from "#chloe/model/tool.ts";
+import { afterRun, beforeRun } from "#chloe/services/historyService.ts";
 
 export interface Ask {
   agent: Agent;
@@ -35,6 +37,11 @@ export interface Ask {
    * written. Never the final answer, which is what turn() returns.
    */
   said?: (text: string) => void;
+  /**
+   * The person on the other end of a channel, by name. The model is told it is
+   * talking to them, so it writes to them as "you" rather than about them.
+   */
+  talkingTo?: string;
   /** Who this run is for, as an address. One column, and the team version reads it. */
   owner?: string;
   /** Answer tools from here instead of running them. For evals. */
@@ -66,7 +73,7 @@ const MAX_STEPS = 40;
  * Runs a prompt: ask a model, run the tools it asked for, put the answers
  * back, ask again, until it stops asking.
  */
-export async function turn({ agent, prompt, attachments, model, thread, source, job, history, said, owner, instead, signal }: Ask): Promise<Result> {
+export async function turn({ agent, prompt, attachments, model, thread, source, job, history, said, talkingTo, owner, instead, signal }: Ask): Promise<Result> {
   const runId = randomUUID();
   const using = model ?? agent.model;
   const tools = { ...(agent.tools ?? {}), skill: skillTool(agent.skills) };
@@ -77,7 +84,7 @@ export async function turn({ agent, prompt, attachments, model, thread, source,
   ).run(runId, agent.name, started, source, job ?? null, using, prompt, owner ?? null);
 
   const messages: Message[] = [
-    { role: "system", content: systemPrompt(agent) },
+    { role: "system", content: systemPrompt(agent, talkingTo && { name: talkingTo, source, asYouGo: Boolean(said) }) },
     ...(thread ? recall(thread, { ...shown(history), tools: true }) : []),
     { role: "user", content: prompt, attachments },
   ];
@@ -87,33 +94,43 @@ export async function turn({ agent, prompt, attachments, model, thread, source,
   const calls: Result["calls"] = [];
   let cost = 0;
   let steps = 0;
+  // An eval answers every tool itself, so nothing it does is written anywhere.
+  const committed = (end: { summary?: string; error?: string }) =>
+    instead ? Promise.resolve() : afterRun(agent, runId, { job, source, ...end });
+  if (!instead) await beforeRun(agent, runId);
 
   try {
-    const done = await loop({
-      model: using,
-      messages,
-      tools,
-      maxSteps: agent.maxSteps ?? MAX_STEPS,
-      signal,
-      instead,
-      onStep: (line) => {
-        trace.push(line);
-        if (said && line.say?.trim() && line.wants?.length) said(line.say);
-        if (line.tool) calls.push({ tool: line.tool, args: line.args, result: line.result });
-        save(runId, trace.filter((one) => (one as { say?: string }).say !== undefined).length, costOf(trace), trace);
-      },
-    });
+    const done = await duringRun(runId, () =>
+      loop({
+        model: using,
+        messages,
+        tools,
+        maxSteps: agent.maxSteps ?? MAX_STEPS,
+        signal,
+        instead,
+        onStep: (line) => {
+          trace.push(line);
+          if (said && line.say?.trim() && line.wants?.length) said(line.say);
+          if (line.tool) calls.push({ tool: line.tool, args: line.args, result: line.result });
+          save(runId, trace.filter((one) => (one as { say?: string }).say !== undefined).length, costOf(trace), trace);
+        },
+      }),
+    );
     cost = done.cost;
     steps = done.steps;
     if (done.stopped) {
       fail(runId, done.text, steps, cost, trace);
+      await committed({ error: done.text });
       return { runId, text: done.text, steps, cost, calls };
     }
     finish(runId, done.text, steps, cost, trace);
+    await committed({ summary: oneLineSummary(done.text) });
     if (thread) remember(thread, "assistant", done.text, calls);
     return { runId, text: done.text, steps, cost, calls };
   } catch (error) {
-    fail(runId, String(error instanceof Error ? error.message : error), steps, cost, trace);
+    const why = String(error instanceof Error ? error.message : error);
+    fail(runId, why, steps, cost, trace);
+    await committed({ error: why });
     throw error;
   }
 }
@@ -276,8 +293,22 @@ function skillTool(skills: Skill[]): Tool {
   };
 }
 
-function systemPrompt(agent: Agent): string {
+/**
+ * The agent's own instructions talk about people in the third person, because
+ * they describe them. This is what stops that carrying over into a
+ * conversation with one of them.
+ */
+function talkingWith({ name, source, asYouGo }: { name: string; source: string; asYouGo: boolean }): string {
+  return (
+    `## Who you are talking to\n\n` +
+    `You are talking with ${name} on ${source}, directly. Write to them as "you", never by name or in the third person.` +
+    (asYouGo ? " What you write before calling a tool is sent to them straight away, so write that to them too." : "")
+  );
+}
+
+function systemPrompt(agent: Agent, person?: { name: string; source: string; asYouGo: boolean } | "" | undefined): string {
   const parts = [agent.instructions];
+  if (person) parts.push(talkingWith(person));
   if (agent.skills.length > 0) {
     parts.push(
       "## Your skills\n\n" +

package/index.ts

@@ -15,7 +15,7 @@
 // The server itself is `server.ts`, and it is run rather than imported.
 
 // An agent, and the jobs it runs.
-export { defineAgent, defineConfig, markdownJob, load, loadAll, names, type Agent, type Channel, type ChannelRoute, type Running, type Job, type Skill, type Binding, type Home, type Features, type ChatHistory } from "./load/load.ts";
+export { defineAgent, defineConfig, markdownJob, load, loadAll, names, type Agent, type Channel, type ChannelRoute, type Running, type Job, type Skill, type Binding, type Home, type Features, type SelfImprovement, type Memory, type ChatHistory } from "./load/load.ts";
 export { defineJob } from "./load/job.ts";
 export { prompt, isPrompt, oneLineSummary, type Prompt } from "./core/markdown.ts";
 
@@ -35,8 +35,8 @@ export { canReach, deliver, owner, reachBy, split, type Send } from "./model/ask
 
 // The floor: where things are, what the box was told, staying inside a
 // folder, a small file an agent keeps, the history.
-export { agentDir, ROOT, STATE } from "./core/paths.ts";
-export { readSettings, setting, settings, type Settings } from "./core/settings.ts";
+export { agentDir, MEMORIES, ROOT, STATE } from "./core/paths.ts";
+export { readSettings, reloadSettings, setting, settings, unclaimed, type Settings } from "./core/settings.ts";
 export { confine } from "./core/confine.ts";
 export { note, type Note } from "./core/notes.ts";
 export { copyDatabase, DATABASE, db, trim } from "./core/db.ts";

package/load/load.ts

@@ -1,24 +1,27 @@
 // An agent is declared, not found. Each one is a defineAgent(...) with a name,
-// and chloe.config.ts at the top of the repo lists them. Nothing is found by
-// looking in a folder except an agent's skills/.
-import { readFile, readdir } from "node:fs/promises";
+// and chloe.config.ts at the top of the repo lists them. Every job, tool and
+// channel is named in the definition. skills/ is the one folder read by
+// looking, because a skill is loaded only when the model asks for it.
+import { mkdir, readFile, readdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { registerHooks } from "node:module";
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { dirname, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { getCallSites } from "node:util";
 
 import type { z } from "zod";
 
-import { ROOT, STATE, setAgentDirs } from "#chloe/core/paths.ts";
-import { readPrompt, settingsAndBody, type Prompt } from "#chloe/core/markdown.ts";
+import { MEMORIES, ROOT, setAgentDirs } from "#chloe/core/paths.ts";
+import { isPrompt, readPrompt, settingsAndBody, type Prompt } from "#chloe/core/markdown.ts";
 import { parse } from "#chloe/timer/cron.ts";
 import type { Definition as JobFile } from "./job.ts";
 import type { Tool, Tools } from "#chloe/model/tool.ts";
 import { memoryTools } from "#chloe/model/tools/memory.ts";
+import { ownFiles } from "#chloe/model/tools/own_files.ts";
 import { runScripts } from "#chloe/model/tools/run_script.ts";
-import { selfImprovement } from "#chloe/model/tools/write_skill.ts";
+import { makeRepo } from "#chloe/services/historyService.ts";
+import { shareLogin } from "#chloe/serve/login.ts";
 import type { Work } from "#chloe/core/steps.ts";
 
 export const CONFIG = `${ROOT}/chloe.config.ts`;
@@ -52,7 +55,7 @@ export type Binding = (agent: Home) => Tools;
 
 /** What defineAgent is given. */
 export interface Definition {
-  /** What the run history, its data folder and its pages are filed under. Do not change it once it has run. */
+  /** What the run history, its memory and its pages are filed under. Do not change it once it has run. */
   name: string;
   /** What the page calls it, when that is not its name: "C.C.". Free to change. */
   label?: string;
@@ -70,11 +73,11 @@ export interface Definition {
    * runs, browsable and editable from the site.
    *
    * Every agent has one, and always has list_notes, read_notes, search_notes
-   * and write_notes on it. Left unsaid it is that agent's own folder under the
-   * state directory, so this is only worth writing down when the agent shares
-   * a folder with a person. Every file served out of it is written to that
-   * agent's own audit log first. See serve/memory.ts for why that log is not
-   * optional.
+   * and write_notes on it. Left unsaid it is its own folder inside `memory/`
+   * beside the agents, which is a git repository, so this is only worth writing
+   * down when the agent shares a folder with a person. Every file served out of it
+   * is written to that agent's own audit log first. See serve/memory.ts for
+   * why that log is not optional.
    */
   memory?: Memory;
   /** The tools the runtime can give any agent, each switched on or off here. */
@@ -86,7 +89,7 @@ export interface Definition {
    * its id. What `features` turns on is added to these and not listed here.
    */
   tools?: (Tool | Tools | Binding)[];
-  /** Each job, imported, or markdownJob("jobs/name.md") for one that is only words. */
+  /** Each job: one imported, or markdownJob("jobs/<id>.md") for one that is only a prompt. */
   jobs?: (JobFile<any, any> | MarkdownJob)[];
   /** Each way in: `[telegramChannel({ ... }), apiChannel()]`. Each one carries its own name. */
   channels?: Channel[];
@@ -113,6 +116,14 @@ export function defineAgent(definition: Definition): Defined {
 /** What chloe.config.ts exports: every agent this box runs. */
 export interface Config {
   agents: Defined[];
+  login?: {
+    /**
+     * A name like "example.com" makes the one login cover every site under
+     * it, so another app can ask GET /api/check whether its visitor is signed
+     * in. Leave it out and the login is for this site's own name only.
+     */
+    domain?: string;
+  };
 }
 
 /** The default export of chloe.config.ts: every agent to run. */
@@ -122,21 +133,51 @@ export function defineConfig(config: Config): Config {
 
 /**
  * A job that is only a prompt, kept whole in one markdown file with its
- * settings (`cron`, `description`, `timezone`, `model`) at the top. The path
- * is inside the agent's folder, and the file's name is the job's id.
+ * settings (`cron`, `description`, `timezone`, `model`) at the top. The path is
+ * inside the agent's folder, and the file's name is the job's id.
  */
 export interface MarkdownJob {
   markdownJob: string;
 }
 
 /**
- * A job that is words and nothing else, named in `agent.ts` as
- * `markdownJob("jobs/<id>.md")`. The file name is the job's id.
+ * A job that is words and nothing else: `markdownJob("jobs/<id>.md")` in
+ * `agent.ts`. The file name is the job's id.
  */
 export function markdownJob(file: string): MarkdownJob {
   return { markdownJob: file };
 }
 
+/** The settings a markdown job may have at its top, and no others. */
+export const MARKDOWN_JOB_SETTINGS = ["cron", "description", "timezone", "model"];
+
+/**
+ * What is wrong with a markdown job, in one sentence, or undefined when it
+ * would load. Stricter than the loader: a setting it does not know is refused
+ * here rather than ignored.
+ */
+export function markdownJobProblem(text: string): string | undefined {
+  const { settings, body } = settingsAndBody(text);
+  if (!body.trim()) return "it has no prompt under its settings";
+  const unknown = Object.keys(settings).filter((key) => !MARKDOWN_JOB_SETTINGS.includes(key));
+  if (unknown.length) return `it has ${unknown.join(", ")} at the top, and a job only reads ${MARKDOWN_JOB_SETTINGS.join(", ")}`;
+  if (settings.cron) {
+    try {
+      parse(settings.cron);
+    } catch (error) {
+      return `its cron line does not read: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+  if (settings.timezone) {
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: settings.timezone });
+    } catch {
+      return `${settings.timezone} is not a timezone, like America/New_York`;
+    }
+  }
+  return undefined;
+}
+
 /** One markdown file out of an agent's `skills/` folder. */
 export interface Skill {
   name: string;
@@ -184,8 +225,13 @@ export interface Job {
 export interface Features {
   /** list_notes, read_notes, search_notes and write_notes on its memory. On unless this says false. */
   memory?: boolean;
-  /** write_skill, to rewrite its own skills. Every write is a commit. Off unless this says true. */
-  selfImprovement?: boolean;
+  /**
+   * list_own_files, read_own_file and write_own_file, to change the plain text
+   * in its own folder: its instructions, its skills, its markdown jobs. Off
+   * unless this says. `true` is every ending in PLAIN_TEXT; an object narrows
+   * that or keeps a path back. Every write is a git commit under its name.
+   */
+  selfImprovement?: boolean | SelfImprovement;
   /**
    * run_script, to run a file in its own scripts/ folder. Off unless this says
    * true, and refused as it loads when that folder has no scripts.
@@ -193,17 +239,47 @@ export interface Features {
   runScripts?: boolean;
 }
 
+/** `selfImprovement` with its file endings worked out, which is what the tools are given. */
+export interface OwnFileRules extends SelfImprovement {
+  files: string[];
+}
+
+/** The plain text an agent may change when `selfImprovement` is `true`, without the dots. */
+export const PLAIN_TEXT = ["md", "txt", "html", "json", "yml", "yaml", "csv"];
+
+/**
+ * Which of its own files an agent may change: `{ except: ["PERMISSIONS.md"] }`,
+ * or `{ files: ["md"] }` for less than the plain text it would get from `true`.
+ *
+ * Code never, whatever `files` says: nothing in tools/, services/, channels/ or
+ * scripts/, and nothing ending in .ts or .js. Nor its evals/, which say what a
+ * good run of it looks like, nor its memory, which is write_notes.
+ */
+export interface SelfImprovement {
+  /** File endings it may write, without the dot. PLAIN_TEXT when it says none. */
+  files?: string[];
+  /** Paths inside its folder it may read and never write, like a file of permissions it obeys. */
+  except?: string[];
+}
+
 /** Where an agent remembers things, shown on the site beside its own pages. */
 export interface Memory {
   /**
-   * An absolute path. Unset, it is this agent's own folder under the state
-   * directory.
+   * An absolute path. Unset, it is the agent's own folder inside `memory/`
+   * beside the agents, which the runtime makes one git repository.
    */
   folder?: string;
   /** What the site calls it. "Memory" when nothing is said. */
   label?: string;
-  /** Make every write a git commit, from the site and from write_notes. For a folder that is a repo. */
-  commit?: boolean;
+  /**
+   * When a change becomes a git commit. `"each run"`: whatever a run changed
+   * is committed when it ends, under the agent's name, and the folder is made
+   * a repository of its own if it is not one. `true`: every write from the
+   * site and from write_notes is its own commit, with a message, for a folder
+   * shared with a person. `false`: never. Unsaid, it is "each run" for the
+   * folder the runtime keeps and false for one named here.
+   */
+  commit?: boolean | "each run";
 }
 
 /**
@@ -228,6 +304,12 @@ export interface Channel {
   name: string;
   /** How much of a conversation on this channel a turn is shown. */
   chatHistory?: ChatHistory;
+  /**
+   * The options it was made with, written out. A reload restarts a running
+   * channel when this changes, since what `start` was given is fixed for as
+   * long as it runs.
+   */
+  madeWith?: string;
   /** Starts listening. `agent` is read again for every message, so an edit is live. */
   start(agent: () => Agent | undefined): Running;
 }
@@ -262,12 +344,27 @@ export interface Agent extends Omit<Definition, "instructions" | "tools" | "jobs
 }
 
 /**
- * Where an agent remembers things: what it said, or its own folder under the
- * state directory. That default is where the memory tool has always written, so
- * an agent that never mentions memory still has one and it is not empty.
+ * Where the memories are kept: `memory/` beside the agents, which the runtime
+ * makes one git repository with a folder per agent inside it, so one history
+ * covers every agent and the agents' own folders stay source and nothing else.
+ * A memory that names its own folder keeps its history in that folder instead.
+ */
+export function memoryRoot(memory?: Memory): string {
+  return memory?.folder || MEMORIES;
+}
+
+/**
+ * Where one agent remembers things: what it said, or its own folder inside
+ * `memory/`. Named after the agent rather than its folder, so a folder that is
+ * renamed still finds the same memory.
  */
 export function memoryFolder(name: string, memory?: Memory): string {
-  return memory?.folder || `${STATE}/${name}`;
+  return memory?.folder || join(MEMORIES, name);
+}
+
+/** When a change to this memory becomes a commit. See Memory. */
+function commitsWhen(memory?: Memory): Memory["commit"] {
+  return memory?.commit ?? (memory?.folder ? false : "each run");
 }
 
 /** An agent's folder as the repo sees it, for saying where something is wrong. */
@@ -287,15 +384,18 @@ export async function loadAll(): Promise<Map<string, Agent>> {
   })) as { default?: Config };
   const listed = module.default?.agents;
   if (!Array.isArray(listed)) throw new Error("chloe.config.ts does not export defineConfig({ agents: [...] }) as its default.");
+  shareLogin(module.default?.login?.domain);
 
   const folders = new Map<string, string>();
+  const memories = new Map<string, string>();
   for (const one of listed) {
     if (!one?.name) throw new Error("chloe.config.ts lists an agent with no name.");
     if (folders.has(one.name)) throw new Error(`chloe.config.ts lists two agents called ${one.name}.`);
     folders.set(one.name, one.folder);
+    memories.set(one.name, memoryFolder(one.name, one.memory));
   }
   // Before anything is bound, so a tool that asks where its agent lives is told.
-  setAgentDirs(folders);
+  setAgentDirs(folders, memories);
 
   const all = new Map<string, Agent>();
   for (const one of listed) all.set(one.name, await resolveAgent(one));
@@ -324,12 +424,26 @@ async function resolveAgent(definition: Defined): Promise<Agent> {
   const { tools, jobs, channels, ...rest } = definition;
   // Worked out once, here, so the site, the memory tool and a job's
   // work.memory all mean the same folder without any of them saying it again.
-  const memory = { ...definition.memory, folder: memoryFolder(name, definition.memory) };
+  const memory = {
+    ...definition.memory,
+    folder: memoryFolder(name, definition.memory),
+    commit: commitsWhen(definition.memory),
+  };
+  // Made now, so committing what a run changed has a folder to name.
+  await mkdir(memory.folder, { recursive: true }).catch(() => undefined);
+  if (memory.commit === "each run") {
+    // Without git, or on a folder it cannot write, the agent still runs: it only
+    // has no history. The repository is the memory root, shared by every agent.
+    await makeRepo(memoryRoot(definition.memory), name).catch((error: unknown) =>
+      console.error(`${where}: its memory could not be made a git repository:`, error instanceof Error ? error.message : error),
+    );
+  }
+  const home = { name, folder, memory };
   return {
     ...rest,
     memory,
     instructions: await readPrompt(definition.instructions, { dir: folder, where }),
-    tools: toolsOf([...featureTools(definition.features, memory), ...(tools ?? [])], { name, folder, memory }, where),
+    tools: toolsOf([...featureTools(definition.features, where), ...(tools ?? [])], home, where),
     skills: await skillsIn(`${folder}/skills`),
     jobs: await jobsOf(name, folder, jobs ?? []),
     channels: channelsOf(channels ?? [], where),
@@ -357,10 +471,20 @@ export function hasChannel(agent: Pick<Agent, "channels">, name: string): boolea
 }
 
 /** What an agent's `features` turn on, as tools. The memory tools unless it says memory: false. */
-function featureTools(features: Features = {}, memory: Memory & { folder: string }): (Tools | Binding)[] {
+/** What `selfImprovement` comes to: `true` is the plain text, an object is itself. */
+export function ownFileRules(self: true | SelfImprovement): OwnFileRules {
+  const said = self === true ? {} : self;
+  return { ...said, files: said.files ?? PLAIN_TEXT };
+}
+
+function featureTools(features: Features = {}, where: string): (Tools | Binding)[] {
+  const self = features.selfImprovement;
+  if (typeof self === "object" && self.files && self.files.length === 0) {
+    throw new Error(`${where}: selfImprovement is true, or says which files it may change, like { files: ["md"] }.`);
+  }
   return [
-    ...(features.memory === false ? [] : [memoryTools(memory)]),
-    ...(features.selfImprovement ? [selfImprovement()] : []),
+    ...(features.memory === false ? [] : [memoryTools()]),
+    ...(self ? [ownFiles(ownFileRules(self))] : []),
     ...(features.runScripts ? [runScripts()] : []),
   ];
 }
@@ -393,13 +517,18 @@ async function skillsIn(dir: string): Promise<Skill[]> {
   return skills;
 }
 
-/** The jobs an agent names, in the order it names them. */
+/**
+ * The jobs an agent names, in the order it names them, then every markdown
+ * file in its jobs/ that is not already one of those or the words of one.
+ */
 export async function jobsOf(agent: string, dir: string, list: (JobFile<any, any> | MarkdownJob)[]): Promise<Job[]> {
   const jobs: Job[] = [];
-  for (const one of list) {
-    const job = "markdownJob" in one ? await fromMarkdown(agent, dir, one.markdownJob) : await fromCode(agent, dir, one);
+  const add = (job: Job) => {
     if (jobs.some((other) => other.id === job.id)) throw new Error(`${agent}: two jobs are called ${job.id}.`);
     jobs.push(job);
+  };
+  for (const one of list) {
+    add("markdownJob" in one ? await fromMarkdown(agent, dir, one.markdownJob) : await fromCode(agent, dir, one));
   }
   return jobs;
 }
@@ -457,7 +586,12 @@ async function fromCode(agent: string, dir: string, definition: JobFile<any, any
     cron: checked(definition.cron, where),
     timezone: definition.timezone ?? "UTC",
     model: definition.model,
-    files: [`jobs/${id}.md`, `jobs/${id}.ts`].filter((file) => existsSync(`${dir}/${file}`)),
+    files: [
+      ...new Set([
+        ...(isPrompt(definition.markdown) ? [relative(dir, join(dir, definition.markdown.file))] : []),
+        ...[`jobs/${id}.md`, `jobs/${id}.ts`].filter((file) => existsSync(`${dir}/${file}`)),
+      ]),
+    ],
   };
 
   // A job has no prompt, and the empty string is what says so everywhere else.

package/model/tools/files.ts

@@ -53,19 +53,33 @@ export function search_in({ root, what, id = "search_notes" }: Folder) {
   });
 }
 
-/** `commit` makes every write a git commit, for a folder that is a repo. */
-export function write_in({ root, what, id = "write_notes", commit = false }: Folder & { commit?: boolean }) {
+/**
+ * `commit` makes every write a git commit, for a folder that is a repo, under
+ * `author` when there is one. `memory` says this folder is the agent's memory,
+ * so the run writing it lists the commit.
+ */
+export function write_in({
+  root,
+  what,
+  id = "write_notes",
+  commit = false,
+  author,
+  memory = false,
+}: Folder & { commit?: boolean; author?: string; memory?: boolean }) {
   return tool({
     id,
     description:
       `Write one file in ${what}. This replaces the file, so include everything you want kept: ` +
-      `read it first unless it is new.` +
+      `read it first unless it is new. To add to the end of a file, such as a log or a list that only ` +
+      `grows, set append instead of writing it out again.` +
       (commit ? " Committed as it is written, so `message` is required." : ""),
     inputSchema: z.object({
       path: z.string(),
       content: z.string().min(1),
+      append: z.boolean().optional().describe("Add content to the end of the file instead of replacing it."),
       message: z.string().optional().describe("Commit message saying what changed. Required here."),
     }),
-    execute: ({ path, content, message }) => writeFiles(root, path, content, { commit, message }),
+    execute: ({ path, content, append, message }) =>
+      writeFiles(root, path, content, { commit, message, append, author, in: memory ? "memory" : undefined }),
   });
 }

package/model/tools/gmail.ts

@@ -4,7 +4,7 @@
 // write. All the model chooses is how far back and how many.
 import { z } from "zod";
 
-import { messages, oneMessage } from "#chloe/services/gmailService.ts";
+import { readEmailMessages, readOneEmailMessage } from "#chloe/services/gmailService.ts";
 import { tool } from "#chloe/model/tool.ts";
 
 interface Options {
@@ -46,7 +46,7 @@ export function read_mail({
     }),
     execute: ({ days: back, limit, messageId }) =>
       messageId
-        ? oneMessage({ search, what, days: back ?? days, limit: limit ?? 10, messageId })
-        : messages({ search, days: back ?? days, limit: limit ?? 10 }),
+        ? readOneEmailMessage({ search, what, days: back ?? days, limit: limit ?? 10, messageId })
+        : readEmailMessages({ search, days: back ?? days, limit: limit ?? 10 }),
   });
 }

package/model/tools/index.ts

@@ -7,8 +7,8 @@
 //
 //   import { read_mail, read_web } from "@chloejs/core/tools";
 //
-// The notes tools, write_skill and run_script are not here: an agent turns
-// them on with `features` in its definition.
+// The notes tools, the own-file tools and run_script are not
+// here: an agent turns them on with `features` in its definition.
 //
 // The work itself is in services/, published as "@chloejs/core/services", and a job calls it
 // from a step rather than coming through here. If a job imports this file,