@turri-dev/cli 0.1.8-next.e553476 → 0.1.8

package/dist/regenerate/diagnose.js

@@ -1,6 +1,7 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { ask, BEGIN, createExecutor } from "../pi.js";
+import { debugMode } from "../config.js";
 import { confinedTools } from "./confine.js";
 /** How many tool calls the diagnosis may make before it is told to decide. */
 export const DIAGNOSIS_CALLS = 40;
@@ -49,8 +50,10 @@ export async function diagnoseFailure(options) {
         if (diagnosis === undefined)
             await ask(session, "You have not called submit_diagnosis. Call it now, with what you know.");
     }
-    catch {
-        // Without a diagnosis the person still gets both failures, as they were.
+    catch (error) {
+        // Without a diagnosis the person still gets both failures, as they were - and the ledger why there is none.
+        if (diagnosis === undefined)
+            throw error;
     }
     finally {
         session.dispose();
@@ -75,6 +78,13 @@ export function diagnosisPrompt(options) {
         "Find the root cause, not the last symptom: read the failing run's output and the agents' logs around where it",
         "failed, and follow it to the spec line, the code, the test, the environment or the harness it comes from. Then",
         "call submit_diagnosis: what happened, why, whose it is to fix, and exactly what to do.",
+        ...(debugMode(options.projectDir)
+            ? []
+            : [
+                "",
+                "The logs and the full outputs are removed as the job ends - the project is not in debug mode - so never send",
+                "the person to one of them: quote what in them shows the cause.",
+            ]),
         "",
         ...options.failures.flatMap((failure, index) => [`<attempt ${index + 1}>`, failure.trim().slice(-12_000), `</attempt ${index + 1}>`, ""]),
     ].join("\n");

package/dist/regenerate/environment-error.d.ts

@@ -128,6 +128,12 @@ export declare function missingToolchainError(run: {
     script: string;
     kind: "unit" | "conformance";
 }): EnvironmentError | undefined;
+/**
+ * Work that passed could not be committed into the module's history: the next pulse, putting the module back to its last
+ * commit, would undo it while turri took it as built - so the pulse does not land, and is rolled back like any other that
+ * did not, and the person is told why. `said` is what git said.
+ */
+export declare function historyError(moduleDir: string, said: string): EnvironmentError;
 /**
  * Before a pulse in `moduleDir` starts any agent: a credential `agent-env:` names that is not there stops it - every
  * command that needs it would fail, and no agent may make one up. Nothing when all are there, or the folder is no

package/dist/regenerate/environment-error.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, sep } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { passedCredentials } from "./agent-env.js";
@@ -246,6 +246,24 @@ export function missingToolchainError(run, details) {
     const missing = missingToolchain(run);
     return missing !== undefined ? toolchainError(missing, details) : undefined;
 }
+/**
+ * Work that passed could not be committed into the module's history: the next pulse, putting the module back to its last
+ * commit, would undo it while turri took it as built - so the pulse does not land, and is rolled back like any other that
+ * did not, and the person is told why. `said` is what git said.
+ */
+export function historyError(moduleDir, said) {
+    const lock = /index\.lock/.test(said);
+    return new EnvironmentError({
+        moduleName: moduleNameOf(moduleDir),
+        missing: `a commit into the module's history, \`${join(moduleDir, ".plaingit")}\``,
+        neededBy: "the work that passed - without the commit, the next pulse would undo it",
+        shownBy: `git said: ${said.replace(/\s+/g, " ").trim().slice(0, 600)}`,
+        fix: lock
+            ? `if no git is still running on it, remove \`${join(moduleDir, ".plaingit", "index.lock")}\`, which a git stopped mid-commit left behind.`
+            : "fix what git said - a full disk, files it cannot read - so a commit can be made there.",
+        source: "harness",
+    });
+}
 /** The module a folder is part of, by name: `plain_modules/<module>/...`. */
 function moduleNameOf(moduleDir) {
     return basename(moduleDir);

package/dist/regenerate/job-log.d.ts

@@ -17,7 +17,9 @@ export interface JobLog {
     /** `agents`: a line per agent - its turns, compactions and cost. */
     end(status: string, report: string | undefined, agents?: string[]): void;
 }
-/** The folder a job's log goes in: the project of the first module it writes, from its lanes. */
+/** The project a job works in: the one of the first module it writes, from its lanes. */
+export declare function projectOfLanes(lanes: string[]): string | undefined;
+/** The folder a job's log goes in: `.turri/jobs` in its project. */
 export declare function jobLogDir(lanes: string[]): string | undefined;
 export declare function startJobLog(job: {
     id: string;

package/dist/regenerate/job-log.js

@@ -2,12 +2,15 @@ import { appendFileSync, existsSync } from "node:fs";
 import { maskSecrets } from "./masking.js";
 import { dirname, isAbsolute, join, sep } from "node:path";
 import { ensureInScratch, MODULES_DIR, projectRootOf, scratchDir } from "./paths.js";
-/** The folder a job's log goes in: the project of the first module it writes, from its lanes. */
-export function jobLogDir(lanes) {
+/** The project a job works in: the one of the first module it writes, from its lanes. */
+export function projectOfLanes(lanes) {
     const lane = lanes.find((candidate) => isAbsolute(candidate) && candidate.split(sep).includes(MODULES_DIR));
-    if (lane === undefined)
-        return undefined;
-    return join(scratchDir(join(projectRootOf(lane), MODULES_DIR)), "jobs");
+    return lane !== undefined ? projectRootOf(lane) : undefined;
+}
+/** The folder a job's log goes in: `.turri/jobs` in its project. */
+export function jobLogDir(lanes) {
+    const project = projectOfLanes(lanes);
+    return project !== undefined ? join(scratchDir(join(project, MODULES_DIR)), "jobs") : undefined;
 }
 export function startJobLog(job, lanes) {
     const dir = jobLogDir(lanes);

package/dist/regenerate/jobs-tree.d.ts

@@ -3,15 +3,17 @@ import type { TranscriptStyle } from "./transcript-view.ts";
 /**
  * The side panel's Jobs view: the queue as a tree, read one job at a time.
  *
- * Three sections - running, queued, finished - each opened and closed on its own, and under them one line per job:
+ * Four sections - running, queued, finished, and earlier sessions' from the ledger - each opened and closed on its own,
+ * and under them one line per job:
  * its module, its time and its cost. A job opened shows all of what it builds - the diff, or the spec - and, running,
- * what it is doing; finished, what went on in it. So what is planned can be read without every diff on the screen at once.
+ * what it is doing; finished, what went on in it; earlier, what the ledger says of it. So what is planned can be read
+ * without every diff on the screen at once.
  *
  * A cursor moves over the sections and the jobs; it stays on its row, whatever moves under it - a job that finishes
  * leaves its row to the one after it. A job opened stays open while it stays where it is: moving to another section
  * it closes, and turns up there collapsed. The state is the conversation's, kept while the panel is closed.
  */
-export type JobSection = "running" | "queued" | "finished";
+export type JobSection = "running" | "queued" | "finished" | "earlier";
 export declare const SECTIONS: JobSection[];
 export interface JobsTreeState {
     /** Which sections are open. */
@@ -24,6 +26,8 @@ export interface JobsTreeState {
     cursor: number;
     /** The first line shown. */
     top: number;
+    /** How many runs the ledger has beyond the earlier sessions shown: said under them. */
+    earlierMore?: number;
 }
 export declare function createJobsTreeState(): JobsTreeState;
 export declare function sectionOf(job: Job): JobSection;

package/dist/regenerate/jobs-tree.js

@@ -3,11 +3,15 @@ import { describeAgents } from "./activity.js";
 import { didNotPass, finishedMark, pulseCost, spinner } from "./job-panel.js";
 import { formatDuration, pulseName } from "./jobs.js";
 import { diffFiles, fileHeader, PLAIN_PAINT } from "./diff-view.js";
-export const SECTIONS = ["running", "queued", "finished"];
+export const SECTIONS = ["running", "queued", "finished", "earlier"];
+/** A section as its header says it. */
+const SECTION_NAMES = { running: "running", queued: "queued", finished: "finished", earlier: "earlier sessions" };
 export function createJobsTreeState() {
-    return { open: { running: true, queued: true, finished: false }, openJobs: new Map(), openFiles: new Map(), cursor: 0, top: 0 };
+    return { open: { running: true, queued: true, finished: false, earlier: false }, openJobs: new Map(), openFiles: new Map(), cursor: 0, top: 0 };
 }
 export function sectionOf(job) {
+    if (job.earlier !== undefined)
+        return "earlier";
     return job.status === "running" ? "running" : job.status === "queued" ? "queued" : "finished";
 }
 /** The files of a job's diff, in the order they are shown - read once for each diff, not on every frame. */
@@ -47,7 +51,7 @@ export function selectJob(jobs, state, id) {
     const job = jobs.find((entry) => entry.id === id);
     if (job === undefined)
         return false;
-    const section = job.status === "running" ? "running" : job.status === "queued" ? "queued" : "finished";
+    const section = sectionOf(job);
     state.open[section] = true;
     state.openJobs.set(id, section);
     const at = jobsTreeRows(jobs, state).findIndex((row) => row.kind === "job" && row.job.id === id);
@@ -60,13 +64,16 @@ export function jobsTreeRows(jobs, state) {
     const bySequence = jobs.filter((job) => job.replacedBy === undefined).sort((a, b) => a.sequence - b.sequence);
     const of = (section) => {
         const inSection = bySequence.filter((job) => sectionOf(job) === section);
-        return section === "finished" ? inSection.sort((a, b) => (b.finishedAt ?? b.sequence) - (a.finishedAt ?? a.sequence) || b.sequence - a.sequence) : inSection;
+        return section === "finished" || section === "earlier" ? inSection.sort((a, b) => (b.finishedAt ?? b.sequence) - (a.finishedAt ?? a.sequence) || b.sequence - a.sequence) : inSection;
     };
     // Forget what is open for jobs that moved on - they close as they leave.
     for (const job of jobs)
         isOpen(state, job);
     return SECTIONS.flatMap((section) => {
         const inSection = of(section);
+        // Earlier sessions are there only when the ledger has some.
+        if (section === "earlier" && inSection.length === 0)
+            return [];
         const jobRows = (job) => [
             { kind: "job", section, job },
             // An open job's diff, a row a file: each opens and closes on its own.
@@ -82,7 +89,8 @@ export function jobsTreeRows(jobs, state) {
 const MARK = { running: spinner, queued: () => "·", succeeded: () => "✓", failed: () => "✗", stopped: () => "■" };
 /** A pulse's mark: running or queued as it is; finished, in the colour of how it ended - green it passed, red it failed or did not pass, stopped amber. */
 function markOf(job, style) {
-    if (sectionOf(job) !== "finished")
+    const section = sectionOf(job);
+    if (section !== "finished" && section !== "earlier")
         return MARK[job.status]?.(Date.now()) ?? "·";
     return finishedMark(job, { success: style.success ?? style.added, error: style.error, warning: style.warning ?? style.accent });
 }
@@ -106,6 +114,9 @@ function named(jobs, id) {
 /** All of a job, opened: what it builds, and - running - what it is doing; waiting, what it waits on; done, how it ended. */
 function detailLines(job, jobs, width, style) {
     const indent = "        ";
+    // An earlier session's: what the ledger says of it - its transcript is its log's alone.
+    if (job.earlier !== undefined)
+        return job.earlier.lines.flatMap((line) => wrap(line, width, indent, /FAILED|ended with/.test(line) ? style.error : style.muted));
     const lines = [];
     // A diff is shown a file at a time, in rows of their own after these.
     if ((job.diff === undefined || job.diff.trim() === "") && job.building !== undefined) {
@@ -170,7 +181,7 @@ export function jobsTreeLines(jobs, state, width, style) {
                 lines.push("");
                 rowStarts[index] = lines.length;
             }
-            const header = `${pointer} ${state.open[row.section] ? "▾" : "▸"} ${row.section} (${row.count})`;
+            const header = `${pointer} ${state.open[row.section] ? "▾" : "▸"} ${SECTION_NAMES[row.section]} (${row.count})`;
             lines.push(here ? style.heading(header) : style.muted(header));
             return;
         }
@@ -197,6 +208,10 @@ export function jobsTreeLines(jobs, state, width, style) {
         if (open)
             lines.push(...detailLines(job, jobs, width, style));
     });
+    // The ledger has more than the runs shown: where to find them.
+    if (state.open.earlier && (state.earlierMore ?? 0) > 0) {
+        lines.push(style.muted(`      ${state.earlierMore} earlier run${state.earlierMore === 1 ? "" : "s"} in the ledger - turri ledger lists them`));
+    }
     return { lines, rowStarts, rows };
 }
 /** How far a job's files, and their lines, are indented under it. */

package/dist/regenerate/jobs.d.ts

@@ -84,6 +84,15 @@ export interface Job {
     announce?: string;
     error?: string;
     details?: unknown;
+    /**
+     * A pulse of an earlier session, as the ledger recorded it - not this session's registry's: shown, never run, halted or
+     * waited for. Its run, how and when that run was started, and what the ledger says of it, a line each.
+     */
+    earlier?: {
+        run: string;
+        runMode?: string;
+        lines: string[];
+    };
 }
 export interface JobOutcome {
     report: string;

package/dist/regenerate/jobs.js

@@ -3,8 +3,10 @@ import { availableParallelism } from "node:os";
 import { withPulse } from "./shell.js";
 import { describeEnvironmentError, EnvironmentError, missingCredentials } from "./environment-error.js";
 import { addAgentReport, describeAgents, JobStoppedError, withActivity } from "./activity.js";
-import { startJobLog } from "./job-log.js";
-import { chosenStack, withStack } from "../config.js";
+import { projectOfLanes, startJobLog } from "./job-log.js";
+import { firstLine, healing, record } from "./ledger.js";
+import { chosenStack, debugMode, withStack } from "../config.js";
+import { pulseEnded, pulseWrote } from "./pulse-files.js";
 const DEFAULT_TAIL_CHARS = 4000;
 const ACTIVITY_LINES = 10;
 /** A long render's full transcript is kept, up to about this much text. */
@@ -88,6 +90,20 @@ export function createJobRegistry(options) {
             };
             jobs.set(job.id, job);
             let transcriptChars = 0;
+            // Where what it does is recorded: its project, from the modules it writes.
+            const project = projectOfLanes(claimed);
+            const place = { job: id, ...(project !== undefined ? { project } : {}), ...(input.module !== undefined ? { module: input.module } : {}) };
+            record({
+                kind: "job.queued",
+                jobKind: input.kind,
+                summary: firstLine(input.summary, 300),
+                ...(input.pulse !== undefined ? { pulse: input.pulse } : {}),
+                ...(input.title !== undefined ? { title: input.title } : {}),
+                ...(input.model !== undefined ? { model: input.model } : {}),
+                ...(stack !== undefined ? { stack } : {}),
+                waitingOn: blockers,
+                ...(input.follows !== undefined ? { follows: input.follows } : {}),
+            }, place);
             const changed = () => {
                 // Like onFinish: a display that throws must not take the job down.
                 try {
@@ -105,6 +121,8 @@ export function createJobRegistry(options) {
             const sink = {
                 signal: controller.signal,
                 job: { id, kind: input.kind, summary: input.summary },
+                ...(project !== undefined ? { project } : {}),
+                ...(input.module !== undefined ? { module: input.module } : {}),
                 specConflict(conflict) {
                     job.specConflict = conflict;
                     this.transcript({ kind: "stage", text: `the spec contradicts itself: functionalities ${conflict.specs.map((spec) => `${spec.module} ${spec.frid}`).join(" and ")} cannot both hold` });
@@ -112,6 +130,7 @@ export function createJobRegistry(options) {
                 },
                 stage(label) {
                     job.stage = label;
+                    record({ kind: "job.stage", label: firstLine(label, 300) }, place);
                     this.transcript({ kind: "stage", text: label });
                     changed();
                 },
@@ -213,22 +232,24 @@ export function createJobRegistry(options) {
                     // and the person is told. What the harness found itself is worked out at once; what an agent said goes as it is.
                     if (error instanceof EnvironmentError) {
                         job.failedForGood = true;
+                        record({ kind: "environment.error", missing: firstLine(error.missing, 300), source: error.source, sandbox: error.sandbox !== undefined }, place);
                         if (error.source === "harness" && options?.diagnose !== undefined) {
                             sink.stage("the environment lacks something - working out what to do about it");
-                            job.diagnosis = await withActivity(sink, () => options.diagnose(job, [error.message, describeEnvironmentError(error, input.rerun)], log?.file)).catch(() => undefined);
+                            job.diagnosis = await withActivity(sink, () => healing("diagnosis", () => options.diagnose(job, [error.message, describeEnvironmentError(error, input.rerun)], log?.file), (found) => found));
                         }
                         job.environment = describeEnvironmentError(error, input.rerun);
                         throw new Error([job.environment, ...(job.diagnosis !== undefined ? ["", job.diagnosis] : [])].join("\n"));
                     }
                     failures.push(error !== undefined ? (error instanceof Error ? error.message : String(error)) : outcome.report);
                     if (attempt < retries) {
+                        record({ kind: "job.retried", attempt: attempt + 1, of: retries, failure: firstLine(failures.at(-1), 300) }, place);
                         sink.stage(`the pulse failed - trying it once more (${attempt + 1} of ${retries})`);
                         continue;
                     }
                     job.failedForGood = true;
                     if (options?.diagnose !== undefined) {
                         sink.stage("the pulse failed again - working out why, and what has to be done");
-                        job.diagnosis = await withActivity(sink, () => options.diagnose(job, failures, log?.file)).catch(() => undefined);
+                        job.diagnosis = await withActivity(sink, () => healing("diagnosis", () => options.diagnose(job, failures, log?.file), (found) => found));
                     }
                     throw new Error([
                         `Failed ${failures.length} time${failures.length === 1 ? "" : "s"}, so it and every pulse queued behind it have stopped.`,
@@ -241,6 +262,8 @@ export function createJobRegistry(options) {
             };
             /** It holds one of the run slots, to give back when it ends. */
             let holding = false;
+            /** It started, holding its lanes: what it wrote, and what its chain installed, are its to clear as it ends. */
+            let ran = false;
             const promise = turn
                 .then(async () => {
                 // Stopped while it waited: it never starts.
@@ -275,8 +298,14 @@ export function createJobRegistry(options) {
                     changed();
                 }
                 log = startJobLog(job, claimed);
-                if (log !== undefined)
+                ran = true;
+                if (log !== undefined) {
                     job.logFile = log.file;
+                    pulseWrote(log.file, id);
+                }
+                // Its log is named only where it is kept: otherwise it goes as the pulse ends.
+                const named = log !== undefined && project !== undefined && debugMode(project);
+                record({ kind: "job.started", waitedMs: job.startedAt - job.queuedAt, ...(named ? { logFile: log.file } : {}) }, place);
                 // What the job's agents start runs until it ends, and no longer (withPulse) - with the stack it was queued
                 // with, whatever is chosen while it waits or runs.
                 return withStack(stack, () => (guarded ? runGuarded() : runOnce()));
@@ -303,6 +332,23 @@ export function createJobRegistry(options) {
                 }
                 finished.finishedAt = Date.now();
                 log?.end(finished.status === "succeeded" ? "finished" : finished.status === "stopped" ? "stopped" : "finished - failed", finished.announce ?? finished.report ?? finished.error, describeAgents(finished.agents));
+                // What it wrote for a person goes now, outside debug mode - its log too, which nothing names from then on.
+                if (ran && project !== undefined && !pulseEnded({ job: id, project, ...(input.module !== undefined ? { module: input.module } : {}), lanes: claimed }))
+                    delete finished.logFile;
+                const outcome = finished.details;
+                const stopReason = stopReasons.get(id);
+                record({
+                    kind: "job.finished",
+                    status: finished.status,
+                    ...(typeof outcome?.landed === "boolean" ? { landed: outcome.landed } : {}),
+                    ...(typeof outcome?.passed === "boolean" ? { passed: outcome.passed } : {}),
+                    ms: finished.finishedAt - finished.startedAt,
+                    usage: finished.usage,
+                    ...(finished.failedForGood === true ? { failedForGood: true } : {}),
+                    ...(finished.status === "stopped" ? { stoppedBy: stopReason !== undefined ? "turri" : "person" } : {}),
+                    ...(finished.error !== undefined ? { error: firstLine(finished.error, 300) } : {}),
+                    ...(finished.logFile !== undefined ? { logFile: finished.logFile } : {}),
+                }, place);
                 // A failing listener must not take the job down with it; the result is
                 // already recorded and can still be collected by asking.
                 try {

package/dist/regenerate/ledger-view.d.ts

@@ -0,0 +1,92 @@
+import { type UsageReport } from "./activity.ts";
+import { type Job } from "./jobs.ts";
+import { type LedgerEntry } from "./ledger.ts";
+/**
+ * What the ledger says of pulses, read back: one pulse - from this session or an earlier one - as the chat and
+ * `turri ledger` are told it, and the runs a project has had, each with its pulses.
+ */
+type Of<K extends LedgerEntry["kind"]> = Extract<LedgerEntry, {
+    kind: K;
+}>;
+/** The projects whose ledgers a folder's pulses may be in: its own, and those of the projects in folders under it. */
+export declare function ledgerProjects(cwd: string, depth?: number): string[];
+/** One pulse, as its events tell it. */
+export interface PulseView {
+    id: string;
+    run: string;
+    /** How its run was started - chat, host, regenerate - and when. */
+    runMode?: string;
+    queued?: Of<"job.queued"> & {
+        module?: string;
+    };
+    started?: Of<"job.started">;
+    finished?: Of<"job.finished">;
+    stages: string[];
+    retried: Array<Of<"job.retried">>;
+    rounds: Map<string, {
+        round: number;
+        of: number;
+    }>;
+    scripts: Array<Of<"script.run">>;
+    judge: Map<string, number>;
+    reviews: Array<Of<"review.verdict">>;
+    healers: Array<Of<"healer.ended"> | Of<"healer.failed">>;
+    provider: {
+        retries: number;
+        stalls: number;
+        errors: string[];
+    };
+    refused: Map<string, number>;
+    stopped: string[];
+    history: Array<Of<"history.committed"> | Of<"history.failed"> | Of<"history.reset"> | Of<"history.rolledBack">>;
+    environment?: Of<"environment.error">;
+    usage?: UsageReport;
+}
+/** A pulse's events, gathered: undefined when the ledger has none of it. `entries` are its run's, oldest first. */
+export declare function pulseView(id: string, entries: LedgerEntry[]): PulseView | undefined;
+/** A pulse from the ledger, for the chat and `turri ledger <pulse>`: what happened in it, as facts. */
+export declare function describePulseView(view: PulseView): string;
+/** A pulse the ledger of any of these projects knows, described - or undefined. */
+export declare function describePastPulse(projects: string[], id: string): string | undefined;
+/** A run of the project's, and its pulses: the most recent first. */
+export interface RunView {
+    run: string;
+    started?: Of<"run.started">;
+    ended?: Of<"run.ended">;
+    pulses: PulseView[];
+}
+export declare function runViews(project: string): RunView[];
+/** The project's last runs, a line a pulse: what `turri ledger` prints. */
+export declare function describeRuns(runs: RunView[]): string;
+/**
+ * The pulses of earlier sessions, for a list beside this session's: the last `runs` runs of these projects that are not
+ * this one, the most recent first, each pulse as a job of its own marked `earlier` - none `known` to this session's
+ * registry. `more`: how many runs the ledger has beyond them.
+ */
+export declare function earlierPulses(projects: string[], known: Set<string>, runs?: number): {
+    jobs: Job[];
+    runs: RunView[];
+    more: number;
+};
+/** A pulse of the ledger's, as the lists show a job: finished as it ended, its time and cost - and nothing to run. */
+export declare function asJob(view: PulseView): Job;
+/** What to count in the ledger: kinds - whole, or a group by what comes before the dot - a module, since when. */
+export interface EventQuery {
+    /** `healer.failed`, or `healer` for every healer event. */
+    kinds?: string[];
+    module?: string;
+    /** Only events at or after this time. */
+    since?: Date;
+    /** How many of the most recent to list, a line each. */
+    limit?: number;
+}
+/** One event in a line: when, its pulse and module, its kind, its own fields - the agent's role when it has one. */
+export declare function eventLine(entry: LedgerEntry): string;
+/**
+ * The events of these projects' ledgers that `query` asks for: how many of each kind, and the most recent, a line each -
+ * or, when no kind asked for is in the ledger, the kinds it has.
+ */
+export declare function describeEvents(projects: string[], query?: EventQuery): string;
+/** `24h`, `7d`, `30m`, or a date and time: the moment it means, or undefined when it means none. */
+export declare function sinceOf(text: string, now?: number): Date | undefined;
+export {};