@alphacoder-v0/pi-loops 0.17.6 → 0.19.2

package/src/cli.ts

@@ -20,6 +20,8 @@ import { askHost, renderHostSnapshot } from "./host-control-channel.ts";
 import { liveHost, stopHost } from "./host-control.ts";
 import { type UiPrefs, readUiPrefs } from "./ui-prefs.ts";
 import { JobStore, defaultLoopsDir } from "./store.ts";
+import { automationBadge, previewText, readSessionHead } from "./session-head.ts";
+import { AUTONOMY_LEVELS, type AutonomyLevel, INSTALL_ROOT, TRACKER_FILE, addLineFor, ensureExcluded, installDirFor, installFiles, installedRecipes, listRecipes, loadRecipe, planInstall, playbookFiles, readRecord, resolveRecipeRef } from "./recipe.ts";
 import { TriggerStore } from "./triggers.ts";
 import { PI_LOOPS_VERSION } from "./version.ts";
 import { stamp } from "./schedule.ts";
@@ -97,13 +99,17 @@ export const CLI_USAGE = [
 	"    Imported automation stays disabled unless --activate-triggers=on (ask: prompt on a terminal).",
 	"",
 	"pi-loops sessions [--all] [--limit <n>]",
-	"    List session ids you can export, newest first.",
+	"    List sessions, newest first: short id, when it started, its automation, what was first said in it.",
 	"",
 	"pi-loops inspect <file>",
 	"    Show what an archive contains without writing anything.",
 	"",
 	"pi-loops host status | abort <run-id|trace-id> | stop",
 	"    Look in on the background host that keeps the clock while no pi is open, or interrupt it.",
+	"",
+	"pi-loops recipe list | show <name|path> | add <name|path> [--cwd <dir>] [--level report|propose|act] [--overwrite]",
+	"    The packaged recipes; what one installs; copy its playbooks into a project (.agents/skills/<name>/).",
+	"    The setup script and the jobs need a pi open in the project: /recipe add <name> finds the copies and finishes.",
 ].join("\n");
 
 /**
@@ -123,6 +129,10 @@ interface SessionFile {
 	file: string;
 	cwd: string;
 	mtimeMs: number;
+	/** The header's timestamp. */
+	startedAt?: string;
+	/** `/name`, or the first thing the person said — what tells two sessions apart. */
+	preview?: string;
 }
 
 /** pi keeps `<agentDir>/sessions/<encoded cwd>/<timestamp>_<uuid>.jsonl`; the header names the cwd. */
@@ -146,9 +156,9 @@ export function listSessions(sessionsRoot: string): SessionFile[] {
 			if (!name.endsWith(".jsonl")) continue;
 			const file = path.join(dir, name);
 			try {
-				const header = JSON.parse(fs.readFileSync(file, "utf8").split("\n", 1)[0] ?? "{}");
-				if (typeof header?.id !== "string") continue;
-				out.push({ id: header.id, file, cwd: typeof header.cwd === "string" ? header.cwd : "", mtimeMs: fs.statSync(file).mtimeMs });
+				const head = readSessionHead(file);
+				if (!head) continue;
+				out.push({ id: head.id, file, cwd: head.cwd, mtimeMs: fs.statSync(file).mtimeMs, startedAt: head.startedAt, preview: head.name ?? head.first });
 			} catch {
 				/* not a readable session */
 			}
@@ -239,6 +249,7 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 	if (command === "web" || command === "tui") return launch(argv, out);
 	if (command === "upgrade") return upgrade(flags.has("check"), out);
 	if (command === "install-launcher") return installLauncher(str("dir"), out);
+	if (command === "recipe") return recipeCommand(positional, { level: str("level"), overwrite: flags.has("overwrite") }, cwd, loopsDir, out);
 
 	if (command === "sessions") {
 		// `pickSession` refuses an unknown id, and there was no way to discover one.
@@ -248,7 +259,14 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 			out(flags.has("all") ? "no sessions recorded" : `no sessions recorded for ${cwd} (use --all)`);
 			return 1;
 		}
-		for (const s of here.slice(0, Number(str("limit") ?? 20))) out(`${s.id}  ${stamp(s.mtimeMs)}  ${s.cwd}`);
+		// One line a person can tell sessions apart by: short id, when it started, the automation the
+		// session has, what was first said in it. With --all the cwd sits after the id.
+		const jobs = new JobStore(loopsDir).load();
+		const rules = new TriggerStore(loopsDir).load();
+		for (const s of here.slice(0, Number(str("limit") ?? 20))) {
+			const badge = automationBadge(s.id, jobs, rules);
+			out(`${s.id.slice(0, 16)}  ${flags.has("all") ? `${s.cwd}  ` : ""}${(s.startedAt ?? stamp(s.mtimeMs)).slice(0, 16)}${badge ? `  [${badge}]` : ""}  ${s.preview ? previewText(s.preview) : ""}`.trimEnd());
+		}
 		return 0;
 	}
 
@@ -375,7 +393,66 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 	return asked ? 2 : 0;
 }
 
-const SUBCOMMANDS = new Set(["export", "import", "sessions", "inspect", "host", "web", "upgrade", "install-launcher", "help"]);
+const SUBCOMMANDS = new Set(["export", "import", "sessions", "inspect", "host", "recipe", "web", "upgrade", "install-launcher", "help"]);
+
+/**
+ * `pi-loops recipe`: the deterministic part of `/recipe`, for a shell with no pi open. `add` copies
+ * the playbooks, lists the directory in `.git/info/exclude` and writes the record — and stops there:
+ * the setup script is shown to a person before it runs and the jobs are created after a
+ * confirmation, both of which need the pi that `/recipe add` runs in. It finds the copies in place.
+ */
+async function recipeCommand(positional: string[], opts: { level?: string; overwrite: boolean }, cwd: string, loopsDir: string, out: (line: string) => void): Promise<number> {
+	const sub = positional[0] ?? "list";
+	if (sub === "list") {
+		const packaged = listRecipes();
+		const installed = new Map(installedRecipes(cwd).map((r) => [r.recipe, r]));
+		const jobs = new JobStore(loopsDir).load().filter((j) => j.recipe && j.cwd === cwd);
+		for (const r of packaged) {
+			const rec = installed.get(r.manifest.name);
+			const n = jobs.filter((j) => j.recipe === r.manifest.name).length;
+			out(`${r.manifest.name.padEnd(17)} ${(rec ? `installed: ${rec.level}, ${n} job(s)` : "—").padEnd(28)} ${r.manifest.summary}`);
+		}
+		for (const rec of installed.values()) if (!packaged.some((r) => r.manifest.name === rec.recipe)) out(`${rec.recipe.padEnd(17)} installed from ${rec.source} (${rec.level})`);
+		if (!packaged.length && !installed.size) out("no recipes packaged, none installed here");
+		return 0;
+	}
+	if (sub === "show" || sub === "add") {
+		const ref = positional[1];
+		if (!ref) throw new Error(`recipe ${sub} needs a recipe name or a directory`);
+		const resolved = resolveRecipeRef(ref, { cwd });
+		const recipe = loadRecipe(resolved.dir);
+		const m = recipe.manifest;
+		const rel = path.join(INSTALL_ROOT, m.name);
+		if (sub === "show") {
+			out(`${m.name} (${recipe.dir})`);
+			out(`  ${m.summary}`);
+			out(`  levels: ${m.levels.join(", ")}   tracker: ${m.needsTracker ? "needs docs/agents/issue-tracker.md" : "not needed"}${m.setup ? `   setup: ${m.setup}` : ""}`);
+			out(`  files → ${rel}/: ${playbookFiles(m).join(", ")}`);
+			for (const j of m.jobs) out(`  /cron add ${addLineFor(j, rel)}`);
+			const record = readRecord(installDirFor(cwd, m.name));
+			if (record) out(`  installed in ${cwd}: ${record.level}, ${record.installedAt}, pi-loops ${record.version}`);
+			return 0;
+		}
+		let level = m.levels[0];
+		if (opts.level) {
+			if (!m.levels.includes(opts.level as AutonomyLevel)) throw new Error(`${m.name} supports ${m.levels.join(", ")}, not "${opts.level}" (levels are ${AUTONOMY_LEVELS.join(", ")})`);
+			level = opts.level as AutonomyLevel;
+		}
+		const plan = planInstall(recipe, cwd, level);
+		const record = installFiles(recipe, cwd, level, { overwrite: opts.overwrite, source: resolved.source });
+		const excluded = ensureExcluded(cwd, rel);
+		if (m.needsTracker && fs.existsSync(path.join(cwd, TRACKER_FILE))) ensureExcluded(cwd, TRACKER_FILE, "file");
+		out(`copied ${record.files.length} file(s) → ${plan.targetDir}/ (level ${level}${opts.level ? "" : ", the lowest; --level to choose"})`);
+		for (const f of plan.changed) out(`  ${f}: ${opts.overwrite ? "overwritten" : "kept as edited (--overwrite replaces it)"}`);
+		out(excluded === "no-git" ? "not a git repository: nothing to exclude" : `.git/info/exclude: ${excluded === "added" ? "added" : "already listed"}`);
+		if (m.needsTracker && !fs.existsSync(path.join(cwd, TRACKER_FILE))) out(`${m.name} reads docs/agents/issue-tracker.md and this project has none: /recipe add ${m.name} in pi writes it with you first`);
+		out(`no jobs created: open pi in ${cwd} and run /recipe add ${m.name} — it shows ${m.setup ? `${m.setup} and ` : ""}these lines, then creates them:`);
+		for (const line of plan.addLines) out(`  /cron add ${line}`);
+		return 0;
+	}
+	out(`unknown recipe command ${JSON.stringify(sub)}: pi-loops recipe list | show <name|path> | add <name|path>`);
+	return 2;
+}
 
 /** `v1.2.3` → comparable parts; anything else is not a release and is ignored. */
 function semver(tag: string): [number, number, number] | undefined {

package/src/job-edit.ts

@@ -20,7 +20,6 @@ export interface JobEdit {
 	timeoutMs?: number | null;
 	name?: string | null;
 	/** "here" pins the job to this machine; null lets any machine run it. */
-	host?: string | null;
 	prompt?: string;
 	schedule?: Schedule;
 }
@@ -38,7 +37,6 @@ export interface AppliedJobEdit {
 
 export interface JobEditContext {
 	now: number;
-	hostName: string;
 	maxPromptBytes: number;
 	/** Called with the requested name and the other jobs; throws if it is not usable as a reference. */
 	checkName: (name: string, others: LoopJob[]) => void;
@@ -66,7 +64,6 @@ export function applyJobEdit(job: LoopJob, edit: JobEdit, ctx: JobEditContext):
 	if (edit.thinking !== undefined) patch.thinking = edit.thinking ?? undefined;
 	if (edit.timeoutMs !== undefined) patch.timeoutMs = edit.timeoutMs ?? undefined;
 	if (edit.name !== undefined) patch.name = edit.name ?? undefined;
-	if (edit.host !== undefined) patch.host = edit.host === "here" ? ctx.hostName : undefined;
 	if (edit.prompt !== undefined) {
 		patch.prompt = edit.prompt;
 		// The old wording is otherwise unrecoverable, and it is what ties "this loop started

package/src/job-health.ts

@@ -10,18 +10,17 @@ import { FAILURE_BACKOFF_AFTER } from "./scheduler.ts";
 import type { LoopJob } from "./store.ts";
 
 /**
- * Jobs failing on `hostName`, worst first. The threshold is the scheduler's backoff threshold, which
+ * Jobs failing, worst first. The threshold is the scheduler's backoff threshold, which
  * is the honest place to draw the line: below it a failure is a bad night, at it the scheduler has
- * already started widening the gap. A job pinned to another host (a shared $HOME) is that host's to
- * report, not ours.
+ * already started widening the gap.
  */
-export function failingJobs(jobs: LoopJob[], hostName: string): LoopJob[] {
-	return jobs.filter((j) => j.enabled && (!j.host || j.host === hostName) && (j.consecutiveFailures ?? 0) >= FAILURE_BACKOFF_AFTER).sort((a, b) => (b.consecutiveFailures ?? 0) - (a.consecutiveFailures ?? 0));
+export function failingJobs(jobs: LoopJob[]): LoopJob[] {
+	return jobs.filter((j) => j.enabled && (j.consecutiveFailures ?? 0) >= FAILURE_BACKOFF_AFTER).sort((a, b) => (b.consecutiveFailures ?? 0) - (a.consecutiveFailures ?? 0));
 }
 
 /** `2 job(s) failing (check-issues ×7)` — one clause, the worst one named, whatever the count. */
-export function failingSummary(jobs: LoopJob[], hostName: string): string | undefined {
-	const failing = failingJobs(jobs, hostName);
+export function failingSummary(jobs: LoopJob[]): string | undefined {
+	const failing = failingJobs(jobs);
 	const worst = failing[0];
 	if (!worst) return undefined;
 	const label = worst.name ?? worst.id;

package/src/job-owner.ts

@@ -0,0 +1,29 @@
+/**
+ * Where a job runs, as one question the scheduler, the lists and `/cron run` all ask the same way.
+ *
+ * A stateful loop belongs to the machine: whichever process holds the clock runs it. A plain job
+ * belongs to the session that created it — its result is a message in that conversation, so it
+ * fires only in the process holding that session. Another session sees it, and sees that it is
+ * asleep; it is not broken, and nothing here promises it a next run it will not get.
+ */
+import type { LoopJob } from "./store.ts";
+
+/** Would the process holding `sessionId` dispatch this job? (For a loop, only if it is also the leader.) */
+export function runsIn(job: Pick<LoopJob, "stateful" | "sessionId">, sessionId: string | undefined): boolean {
+	if (job.stateful) return true;
+	return !!sessionId && job.sessionId === sessionId;
+}
+
+/** The short form of the session a plain job belongs to. */
+export function ownerSession(job: Pick<LoopJob, "stateful" | "sessionId">): string | undefined {
+	return job.stateful ? undefined : (job.sessionId ?? "?").slice(0, 8);
+}
+
+/**
+ * The line a list shows for a plain job that will not run here — worded as what to do, because
+ * "not open here" was read as an error. Undefined when the job runs here.
+ */
+export function asleepNote(job: Pick<LoopJob, "stateful" | "sessionId">, sessionId: string | undefined): string | undefined {
+	if (runsIn(job, sessionId)) return undefined;
+	return `session ${ownerSession(job)} — resume it to run`;
+}