bareloop 0.47.1 → 0.49.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +56 -0
- package/README.md +16 -9
- package/bareloop.context.md +70 -46
- package/bin/bareloop.mjs +2 -0
- package/package.json +3 -3
- package/src/bundle.js +36 -9
- package/src/bundleref.js +103 -0
- package/src/bundlerun.js +134 -17
- package/src/cli.js +138 -144
- package/src/config.js +1 -1
- package/src/draftspend.js +88 -34
- package/src/facts.js +1 -1
- package/src/interviewrun.js +11 -11
- package/src/invoke.js +3 -2
- package/src/launcher.js +122 -12
- package/src/learn.js +34 -20
- package/src/learnstore.js +30 -14
- package/src/pagedropwords.js +1 -0
- package/src/pagedry.js +77 -6
- package/src/pagemap.js +17 -3
- package/src/pagerules.js +2 -1
- package/src/panel/authorsession.js +7 -13
- package/src/panel/index.html +30 -7
- package/src/panel/runroutes.js +28 -14
- package/src/panel/server.js +69 -118
- package/src/prompts.js +50 -0
- package/src/reuse.js +1 -1
- package/src/runexport.js +162 -0
- package/src/runfiles.js +65 -0
- package/src/runlist.js +72 -0
- package/src/userrun.js +17 -13
- package/types/bundle.d.ts +16 -0
- package/types/bundleref.d.ts +63 -0
- package/types/bundlerun.d.ts +10 -3
- package/types/cli.d.ts +2 -1
- package/types/draftspend.d.ts +7 -23
- package/types/launcher.d.ts +67 -2
- package/types/learn.d.ts +29 -15
- package/types/learnstore.d.ts +31 -10
- package/types/pagedry.d.ts +26 -0
- package/types/pagemap.d.ts +1 -0
- package/types/panel/server.d.ts +7 -3
- package/types/prompts.d.ts +21 -0
- package/types/reuse.d.ts +3 -0
- package/types/runexport.d.ts +58 -0
- package/types/runfiles.d.ts +40 -0
- package/types/runlist.d.ts +55 -0
package/src/bundle.js
CHANGED
|
@@ -344,10 +344,18 @@ export function exportBundle({ spec, closeScripts, registryDir, outDir, bareloop
|
|
|
344
344
|
red('invalid-value', 'spec.job', 'a job spec with a job slug is required');
|
|
345
345
|
return fail();
|
|
346
346
|
}
|
|
347
|
-
|
|
348
|
-
|
|
347
|
+
// A panel job is signed with a declared close (`closeDecl`, no `close`): its checks are data the engine builds
|
|
348
|
+
// at run time, so there are no close scripts to relocate. `close` and `closeDecl` are alternatives (both is a red).
|
|
349
|
+
const declared = isObj(spec.closeDecl) && spec.close === undefined;
|
|
350
|
+
if (spec.close !== undefined && spec.closeDecl !== undefined) {
|
|
351
|
+
red('invalid-value', 'spec.closeDecl', 'close and closeDecl are alternatives — a spec declares one');
|
|
349
352
|
return fail();
|
|
350
353
|
}
|
|
354
|
+
if (!declared && (!Array.isArray(spec.close) || spec.close.length === 0)) {
|
|
355
|
+
red('invalid-value', 'spec.close', 'a non-empty ordered close stage list (or a closeDecl) is required to export');
|
|
356
|
+
return fail();
|
|
357
|
+
}
|
|
358
|
+
const closeStages = declared ? [] : spec.close;
|
|
351
359
|
const scripts = isObj(closeScripts) ? closeScripts : {};
|
|
352
360
|
|
|
353
361
|
// outDir: refuse a non-empty destination before any other check runs, since
|
|
@@ -389,7 +397,7 @@ export function exportBundle({ spec, closeScripts, registryDir, outDir, bareloop
|
|
|
389
397
|
const byPath = new Map();
|
|
390
398
|
/** @type {Map<string, string>} basename -> scriptPath (collision detection) */
|
|
391
399
|
const byName = new Map();
|
|
392
|
-
|
|
400
|
+
closeStages.forEach((/** @type {any} */ stage, /** @type {number} */ i) => {
|
|
393
401
|
const at = `close.${i}.cmd`;
|
|
394
402
|
const parsed = parseNodeCmd(isObj(stage) ? stage.cmd : undefined);
|
|
395
403
|
if (!parsed.ok) { red('close-cmd-unrelocatable', at, `must be "node <absolute path>.mjs …" — got ${JSON.stringify(isObj(stage) ? stage.cmd : stage)}`); return; }
|
|
@@ -465,7 +473,7 @@ export function exportBundle({ spec, closeScripts, registryDir, outDir, bareloop
|
|
|
465
473
|
relocatedSha.set(scriptPath, hash);
|
|
466
474
|
}
|
|
467
475
|
|
|
468
|
-
const specOut = { ...spec, close:
|
|
476
|
+
const specOut = declared ? spec : { ...spec, close: closeStages.map((/** @type {any} */ stage) => {
|
|
469
477
|
const parsed = parseNodeCmd(stage.cmd);
|
|
470
478
|
// unreachable: every stage's cmd already passed this same parse above, or
|
|
471
479
|
// the function returned before reaching this write pass at all
|
|
@@ -562,10 +570,10 @@ export function exportBundle({ spec, closeScripts, registryDir, outDir, bareloop
|
|
|
562
570
|
' Every run creates a FRESH detached worktree under',
|
|
563
571
|
' <repo>/.bareloop/wt/<runid> and never reuses or deletes one for you;',
|
|
564
572
|
' your checkout is never touched.',
|
|
565
|
-
'4. Budget/wall (optional) — --budget <usd> and --wall <minutes>
|
|
566
|
-
`
|
|
567
|
-
+ `${spec.maxWallMs != null ? `, maxWallMs ${spec.maxWallMs}` : ''}); raising either
|
|
568
|
-
'
|
|
573
|
+
'4. Budget/wall (optional) — --budget <usd> and --wall <minutes> set this run\'s caps.',
|
|
574
|
+
` Lowering the signed ceiling${spec.maxWallMs != null ? 's' : ''} (budgetUsd ${spec.budgetUsd ?? '?'}`
|
|
575
|
+
+ `${spec.maxWallMs != null ? `, maxWallMs ${spec.maxWallMs}` : ''}) needs nothing; raising either shows the raise and needs you to type yes`,
|
|
576
|
+
' (or pass --yes), and the approval is recorded in the run.',
|
|
569
577
|
'',
|
|
570
578
|
].join('\n');
|
|
571
579
|
writeFileSync(join(outDir, 'README.md'), readme);
|
|
@@ -697,12 +705,31 @@ export function checkEnvelope(spec, envelope = {}) {
|
|
|
697
705
|
continue;
|
|
698
706
|
}
|
|
699
707
|
if (typeof s[field] === 'number' && e[field] > s[field]) {
|
|
700
|
-
reds.push({ code: 'envelope-widen', path: field, detail: `${e[field]} exceeds the bundle's signed ${field} (${s[field]}) —
|
|
708
|
+
reds.push({ code: 'envelope-widen', path: field, detail: `${e[field]} exceeds the bundle's signed ${field} (${s[field]}) — a raise needs your yes: type yes when asked, or pass --yes` });
|
|
701
709
|
}
|
|
702
710
|
}
|
|
703
711
|
return { ok: reds.length === 0, reds };
|
|
704
712
|
}
|
|
705
713
|
|
|
714
|
+
/**
|
|
715
|
+
* The caps a typed envelope would RAISE above the bundle's signed ones (hamr 2026-10-25: a raise is allowed, but only signed by the
|
|
716
|
+
* person typing `yes` or passing `--yes`). Same fields and test as {@link checkEnvelope}'s widen red; a field the spec has no ceiling
|
|
717
|
+
* for cannot be raised. Pure.
|
|
718
|
+
* @param {any} spec the (already `$BARELOOP_BUNDLE`-resolved) bundle spec
|
|
719
|
+
* @param {{ budgetUsd?: number, maxWallMs?: number }} envelope
|
|
720
|
+
* @returns {{ field: 'budgetUsd'|'maxWallMs', old: number, new: number }[]}
|
|
721
|
+
*/
|
|
722
|
+
export function capRaises(spec, envelope = {}) {
|
|
723
|
+
/** @type {{ field: 'budgetUsd'|'maxWallMs', old: number, new: number }[]} */
|
|
724
|
+
const out = [];
|
|
725
|
+
const s = isObj(spec) ? spec : {};
|
|
726
|
+
const e = isObj(envelope) ? envelope : {};
|
|
727
|
+
for (const field of /** @type {const} */ (['budgetUsd', 'maxWallMs'])) {
|
|
728
|
+
if (typeof e[field] === 'number' && Number.isFinite(e[field]) && typeof s[field] === 'number' && e[field] > s[field]) out.push({ field, old: s[field], new: e[field] });
|
|
729
|
+
}
|
|
730
|
+
return out;
|
|
731
|
+
}
|
|
732
|
+
|
|
706
733
|
/**
|
|
707
734
|
* Write `blessing.json`: the FIRST GREEN RUN on the importer's own machine
|
|
708
735
|
* signs the bundle as trustworthy (hamr Q2), so later runs need no
|
package/src/bundleref.js
ADDED
|
@@ -0,0 +1,103 @@
|
|
|
1
|
+
// How the CLI finds a bundle: by the run name it was exported under, or by folder (PRD v1.114, one menu). Names come from the
|
|
2
|
+
// `exported` rows `bareloop export` appends to runs.jsonl, numbered by the panel's own `runNumbers`. Also: which stopped bundle runs
|
|
3
|
+
// can be resumed (the menu's Resume list). $0, read-only.
|
|
4
|
+
|
|
5
|
+
import { existsSync, statSync } from 'node:fs';
|
|
6
|
+
import { dirname, resolve } from 'node:path';
|
|
7
|
+
import { askRequired } from './prompts.js';
|
|
8
|
+
|
|
9
|
+
import { readRunList, readExported, runNumbers, runNameOf, runIsAlive } from './runlist.js';
|
|
10
|
+
import { parseJsonl } from './replayio.js';
|
|
11
|
+
import { legsOf } from './legs.js';
|
|
12
|
+
import { readResume, checkpointAgeGate, CHECKPOINT_OUTCOMES } from './reuse.js';
|
|
13
|
+
|
|
14
|
+
/** @param {string} p @returns {boolean} */
|
|
15
|
+
const isDir = (p) => { try { return statSync(p).isDirectory(); } catch { return false; } };
|
|
16
|
+
|
|
17
|
+
/** how many bundles a pick list shows; older ones stay reachable by typing their run name or folder */
|
|
18
|
+
export const RECENT_BUNDLES = 10;
|
|
19
|
+
|
|
20
|
+
/**
|
|
21
|
+
* Every bundle on this machine the CLI knows, NEWEST FIRST, one per folder: the exported ones (the `exported` rows) and any bundle that
|
|
22
|
+
* has `bareloop run` rows (spine `<bundle>/runs/<runid>/spine.jsonl`). `label` = the run name (or the job) and the folder.
|
|
23
|
+
* @param {{ home?: string }} [opts]
|
|
24
|
+
* @returns {{ name: string, dir: string, label: string, atMs: number }[]}
|
|
25
|
+
*/
|
|
26
|
+
export function knownBundles(opts = {}) {
|
|
27
|
+
const { rows } = readRunList(opts);
|
|
28
|
+
const nos = runNumbers(rows);
|
|
29
|
+
const ms = (/** @type {any} */ x) => { const t = typeof x === 'string' ? Date.parse(x) : NaN; return Number.isFinite(t) ? t : 0; };
|
|
30
|
+
/** @type {Map<string, { name: string, dir: string, label: string, atMs: number }>} */
|
|
31
|
+
const byDir = new Map();
|
|
32
|
+
const put = (/** @type {string} */ dir, /** @type {string} */ name, /** @type {number} */ atMs, /** @type {boolean} */ named) => {
|
|
33
|
+
if (!isDir(dir)) return;
|
|
34
|
+
const old = byDir.get(dir);
|
|
35
|
+
if (old && old.atMs > atMs && (old.name !== '' || !named)) return;
|
|
36
|
+
const keep = named ? name : (old ? old.name : '');
|
|
37
|
+
byDir.set(dir, { name: keep, dir, label: `${keep || name} ${dir}`, atMs: Math.max(atMs, old ? old.atMs : 0) });
|
|
38
|
+
};
|
|
39
|
+
for (const x of readExported(opts)) {
|
|
40
|
+
const n = nos.get(x.runid);
|
|
41
|
+
put(x.bundle, n === undefined ? `${x.job} (${x.runid})` : runNameOf(x.job, n), ms(x.at), true);
|
|
42
|
+
}
|
|
43
|
+
for (const r of rows) {
|
|
44
|
+
if (r.via !== 'bundle' || typeof r.spine !== 'string') continue;
|
|
45
|
+
put(dirname(dirname(dirname(r.spine))), r.job, ms(r.at), false);
|
|
46
|
+
}
|
|
47
|
+
return [...byDir.values()].sort((a, b) => b.atMs - a.atMs);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/**
|
|
51
|
+
* The shared bundle question of `run` and `history`: show the last {@link RECENT_BUNDLES} bundles, newest first, numbered; then ask. A number
|
|
52
|
+
* picks one shown; a run name or a folder reaches an older one. None known: one plain line and the command ends.
|
|
53
|
+
* @param {{ ask: (q: string) => Promise<string>, out: (s: string) => void, home?: string, none: string, cancelled: string }} o
|
|
54
|
+
* @returns {Promise<{ ref: string } | { end: true }>} `end` = the command ends cleanly (exit 0)
|
|
55
|
+
*/
|
|
56
|
+
export async function askBundle({ ask, out, home, none, cancelled }) {
|
|
57
|
+
const known = knownBundles(home === undefined ? {} : { home });
|
|
58
|
+
if (known.length === 0) { out(none); return { end: true }; }
|
|
59
|
+
const shown = known.slice(0, RECENT_BUNDLES);
|
|
60
|
+
out(known.length > shown.length ? `Bundles (the last ${shown.length} of ${known.length}; older ones by run name or folder):` : 'Bundles:');
|
|
61
|
+
shown.forEach((b, i) => out(` ${i + 1} ${b.label}`));
|
|
62
|
+
const pick = await askRequired(ask, 'Bundle (a number above, a run name, or a folder): ');
|
|
63
|
+
if (pick === null) { out(cancelled); return { end: true }; }
|
|
64
|
+
return { ref: /^\d+$/.test(pick) && shown[Number(pick) - 1] ? shown[Number(pick) - 1].dir : pick };
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
/**
|
|
68
|
+
* A bundle reference typed by a person: an existing folder (relative to `cwd`), else an exported run name.
|
|
69
|
+
* @param {string} ref @param {{ home?: string, cwd: string }} o
|
|
70
|
+
* @returns {{ ok: true, dir: string } | { ok: false, why: string }}
|
|
71
|
+
*/
|
|
72
|
+
export function resolveBundleRef(ref, { home, cwd }) {
|
|
73
|
+
const asPath = resolve(cwd, ref);
|
|
74
|
+
if (isDir(asPath)) return { ok: true, dir: asPath };
|
|
75
|
+
const hit = knownBundles(home === undefined ? {} : { home }).find((b) => b.name === ref);
|
|
76
|
+
if (hit) return { ok: true, dir: hit.dir };
|
|
77
|
+
return { ok: false, why: `"${ref}" is neither a bundle folder nor the name of a bundle you exported (bareloop export makes one)` };
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
/**
|
|
81
|
+
* The stopped / capped runs of `bareloop run` the engine would accept a resume for, newest first: not alive, no answer yet, an
|
|
82
|
+
* attempt to continue, checkpoint not expired, and the bundle folder still on disk.
|
|
83
|
+
* @param {{ home?: string }} [opts]
|
|
84
|
+
* @returns {{ runid: string, job: string, bundleDir: string, outcome: string, label: string }[]}
|
|
85
|
+
*/
|
|
86
|
+
export function listResumableBundleRuns(opts = {}) {
|
|
87
|
+
const { rows } = readRunList(opts);
|
|
88
|
+
/** @type {{ runid: string, job: string, bundleDir: string, outcome: string, label: string }[]} */
|
|
89
|
+
const out = [];
|
|
90
|
+
for (const row of rows) {
|
|
91
|
+
if (row.via !== 'bundle' || typeof row.spine !== 'string' || !existsSync(row.spine)) continue;
|
|
92
|
+
if (runIsAlive(row)) continue;
|
|
93
|
+
const bundleDir = dirname(dirname(dirname(row.spine))); // <bundle>/runs/<runid>/spine.jsonl
|
|
94
|
+
if (!isDir(bundleDir)) continue;
|
|
95
|
+
const records = parseJsonl(row.spine).records;
|
|
96
|
+
const dead = readResume(records, { direct: true, resumableOutcomes: CHECKPOINT_OUTCOMES });
|
|
97
|
+
if (!dead.started || dead.greened || dead.ended || !dead.restart) continue;
|
|
98
|
+
if (!checkpointAgeGate(records).ok) continue;
|
|
99
|
+
const outcome = legsOf(records).at(-1)?.outcome ?? 'stopped';
|
|
100
|
+
out.push({ runid: row.runid, job: row.job, bundleDir, outcome, label: `${row.job} run ${row.runid} (${outcome}) ${bundleDir}` });
|
|
101
|
+
}
|
|
102
|
+
return out.reverse(); // newest first
|
|
103
|
+
}
|
package/src/bundlerun.js
CHANGED
|
@@ -13,45 +13,81 @@
|
|
|
13
13
|
// spec — the equality stays a real check (the spec the engine sees is the spec hashed).
|
|
14
14
|
// `bundleHash` never changes when the runner tightens; `history.jsonl` records both hashes.
|
|
15
15
|
|
|
16
|
-
import { hostname } from 'node:os';
|
|
16
|
+
import { hostname, userInfo } from 'node:os';
|
|
17
17
|
import { execFileSync } from 'node:child_process';
|
|
18
|
-
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
|
|
18
|
+
import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
|
|
19
19
|
import { join, resolve } from 'node:path';
|
|
20
20
|
|
|
21
21
|
import {
|
|
22
|
-
readBundle, resolveBundleSpec, checkEnvelope, bless, verifyBlessing, appendHistory, checkBundleDeps,
|
|
22
|
+
readBundle, resolveBundleSpec, checkEnvelope, capRaises, bless, verifyBlessing, appendHistory, checkBundleDeps,
|
|
23
23
|
} from './bundle.js';
|
|
24
|
+
import { askRequired, isQuit } from './prompts.js';
|
|
25
|
+
import { askBundle, resolveBundleRef } from './bundleref.js';
|
|
26
|
+
import { rowsForHome, chatLines } from './providerrows.js';
|
|
24
27
|
import { jobSpecHash } from './job.js';
|
|
25
|
-
import { addWorktree, worktreePath } from './worktree.js';
|
|
28
|
+
import { addWorktree, worktreePath, commitWork } from './worktree.js';
|
|
26
29
|
import { parseJsonl } from './replayio.js';
|
|
27
30
|
import { legsOf } from './legs.js';
|
|
28
31
|
import { startRun, resumeRun } from './userrun.js';
|
|
29
32
|
|
|
33
|
+
/** the plain sentences for a raised cap (ONE spelling: the prompt, the refusal and the record's reader all read them) */
|
|
34
|
+
const raiseWords = (/** @type {{ field: string, old: number, new: number }} */ r) => (r.field === 'budgetUsd'
|
|
35
|
+
? `This raises the $ cap from $${r.old} to $${r.new}.`
|
|
36
|
+
: `This raises the time cap from ${r.old / 60_000} min to ${r.new / 60_000} min.`);
|
|
37
|
+
|
|
30
38
|
/**
|
|
31
|
-
* `bareloop run <
|
|
32
|
-
* `bareloop run <
|
|
39
|
+
* `bareloop run <bundle> --repo <path> [--model <id>] [--budget N] [--wall MIN] [--yes] [--approve <bundleHash>]`
|
|
40
|
+
* `bareloop run <bundle> --resume <runid> [--repo <path>] [--budget N] [--wall MIN] [--yes] [--approve <bundleHash>]`
|
|
41
|
+
* `<bundle>` is a bundle folder or the run name it was exported under (`job (run-N)`). A missing bundle, repo or model is asked for
|
|
42
|
+
* (when there is something to ask: `canAsk`); a required answer left empty twice ends the command cleanly (exit 0, nothing run).
|
|
43
|
+
* A cap typed ABOVE the signed one is shown back and needs `yes` (or `--yes`); the approval is recorded in the run's own folder.
|
|
33
44
|
* @param {string[]} args
|
|
34
45
|
* @param {{
|
|
35
46
|
* out: (s: string) => void, err: (s: string) => void, cwd: string,
|
|
36
47
|
* env: Record<string,string|undefined>, now: () => number, deps: any, keysHome?: string,
|
|
48
|
+
* ask?: (q: string) => Promise<string>, canAsk?: boolean, guided?: boolean,
|
|
37
49
|
* parseFlags: (a: string[]) => { positional: string[], flags: Record<string, string|true> },
|
|
38
50
|
* printReds: (reds: import('./bundle.js').Red[], err: (s: string) => void) => void,
|
|
39
51
|
* }} ctx
|
|
40
52
|
* @returns {Promise<number>}
|
|
41
53
|
*/
|
|
42
54
|
export async function bundleMain(args, {
|
|
43
|
-
out, err, cwd, env, now, deps, keysHome, parseFlags, printReds,
|
|
55
|
+
out, err, cwd, env, now, deps, keysHome, ask, canAsk = false, guided: guidedIn = false, parseFlags, printReds,
|
|
44
56
|
}) {
|
|
45
57
|
const { positional, flags } = parseFlags(args);
|
|
46
|
-
const
|
|
47
|
-
const
|
|
58
|
+
const askable = canAsk && typeof ask === 'function';
|
|
59
|
+
const home = deps?.runlistHome;
|
|
60
|
+
/** @type {string|undefined} */
|
|
61
|
+
let bundleDirArg = positional[0];
|
|
62
|
+
/** @type {string|undefined} */
|
|
63
|
+
let repoArg = typeof flags.repo === 'string' ? flags.repo : undefined;
|
|
48
64
|
const resumeArg = typeof flags.resume === 'string' ? flags.resume : undefined;
|
|
49
|
-
|
|
50
|
-
err('usage: bareloop run <
|
|
51
|
-
+ ' bareloop run <
|
|
65
|
+
const usage = () => {
|
|
66
|
+
err('usage: bareloop run <bundle> --repo <path> [--model <id>] [--budget N] [--wall MIN] [--yes] [--approve <bundleHash>]\n'
|
|
67
|
+
+ ' bareloop run <bundle> --resume <runid> [--repo <path>] [--budget N] [--wall MIN] [--yes] [--approve <bundleHash>]\n'
|
|
68
|
+
+ ' <bundle> is a bundle folder or the name you exported it under, e.g. "my-job (run-3)"');
|
|
52
69
|
return 1;
|
|
70
|
+
};
|
|
71
|
+
if (flags.resume === true) return usage();
|
|
72
|
+
/** set once any required value had to be asked: the guided run also offers the optional caps */
|
|
73
|
+
let guided = guidedIn;
|
|
74
|
+
if (bundleDirArg === undefined) {
|
|
75
|
+
if (!askable || !ask) return usage();
|
|
76
|
+
const r = await askBundle({ ask, out, ...(home === undefined ? {} : { home }), none: 'No exported bundles yet. Export one with 7.', cancelled: 'No bundle chosen, nothing run.' });
|
|
77
|
+
if ('end' in r) return 0;
|
|
78
|
+
bundleDirArg = r.ref;
|
|
79
|
+
guided = true;
|
|
80
|
+
}
|
|
81
|
+
const found = resolveBundleRef(bundleDirArg, { ...(home === undefined ? {} : { home }), cwd });
|
|
82
|
+
if (!found.ok) { err(found.why); return 1; }
|
|
83
|
+
const bundleDir = found.dir;
|
|
84
|
+
if (resumeArg === undefined && repoArg === undefined) {
|
|
85
|
+
if (!askable || !ask) return usage();
|
|
86
|
+
const r = await askRequired(ask, 'Repo (a folder that is a git repo with at least one commit): ');
|
|
87
|
+
if (r === null) { out('No repo chosen, nothing run.'); return 0; }
|
|
88
|
+
repoArg = r;
|
|
89
|
+
guided = true;
|
|
53
90
|
}
|
|
54
|
-
const bundleDir = resolve(cwd, bundleDirArg);
|
|
55
91
|
|
|
56
92
|
// 1. readBundle — this must complete, clean, before anything else touches the bundle or
|
|
57
93
|
// the repo. Any red (incl. bundle-tampered) stops here.
|
|
@@ -64,9 +100,20 @@ export async function bundleMain(args, {
|
|
|
64
100
|
const depsCheck = checkBundleDeps(bundleDir);
|
|
65
101
|
if (!depsCheck.ok) { printReds(depsCheck.reds, err); return 1; }
|
|
66
102
|
|
|
67
|
-
// 2.
|
|
103
|
+
// 2. the caps. Lowering needs nothing; a cap typed ABOVE the signed one is shown back and signed by `yes` (hamr 2026-10-25).
|
|
68
104
|
/** @type {{ budgetUsd?: number, maxWallMs?: number }} */
|
|
69
105
|
const envelope = {};
|
|
106
|
+
if (guided && askable && ask) {
|
|
107
|
+
// a guided run offers the caps; Enter keeps the signed value
|
|
108
|
+
const budgetAns = (await ask(`$ cap (Enter keeps $${bundle.spec.budgetUsd}${resumeArg === undefined ? '' : '; a higher number adds money'}): `)).trim();
|
|
109
|
+
if (isQuit(budgetAns)) { out('Nothing chosen, nothing run.'); return 0; }
|
|
110
|
+
if (budgetAns !== '') flags.budget = budgetAns;
|
|
111
|
+
if (typeof bundle.spec.maxWallMs === 'number') {
|
|
112
|
+
const wallAns = (await ask(`Time cap in minutes (Enter keeps ${bundle.spec.maxWallMs / 60_000}${resumeArg === undefined ? '' : '; a higher number adds time'}): `)).trim();
|
|
113
|
+
if (isQuit(wallAns)) { out('Nothing chosen, nothing run.'); return 0; }
|
|
114
|
+
if (wallAns !== '') flags.wall = wallAns;
|
|
115
|
+
}
|
|
116
|
+
}
|
|
70
117
|
if (flags.budget !== undefined) {
|
|
71
118
|
const n = Number(flags.budget);
|
|
72
119
|
if (!Number.isFinite(n)) { err(`--budget must be a number, got ${JSON.stringify(flags.budget)}`); return 1; }
|
|
@@ -77,10 +124,30 @@ export async function bundleMain(args, {
|
|
|
77
124
|
if (!Number.isFinite(n)) { err(`--wall must be a number of minutes, got ${JSON.stringify(flags.wall)}`); return 1; }
|
|
78
125
|
envelope.maxWallMs = n * 60_000;
|
|
79
126
|
}
|
|
80
|
-
const
|
|
127
|
+
const raises = capRaises(bundle.spec, envelope);
|
|
128
|
+
const tighten = { ...envelope };
|
|
129
|
+
for (const r of raises) delete tighten[r.field];
|
|
130
|
+
const envCheck = checkEnvelope(bundle.spec, tighten);
|
|
81
131
|
if (!envCheck.ok) { printReds(envCheck.reds, err); return 1; }
|
|
132
|
+
/** the raises the person signed, recorded in the run's own folder once the engine has accepted the run */
|
|
133
|
+
/** @type {{ field: string, old: number, new: number }[]} */
|
|
134
|
+
let signedRaises = [];
|
|
135
|
+
if (raises.length > 0) {
|
|
136
|
+
for (const r of raises) out(raiseWords(r));
|
|
137
|
+
if (flags.yes !== undefined) signedRaises = raises;
|
|
138
|
+
else if (askable && ask) {
|
|
139
|
+
const a = (await ask('Type yes to sign it: ')).trim().toLowerCase();
|
|
140
|
+
if (isQuit(a)) { out('Not signed, nothing run.'); return 0; }
|
|
141
|
+
if (a !== 'yes') { err('Not signed (only "yes" signs a raise) — the caps stay as signed. Nothing ran.'); return 1; }
|
|
142
|
+
signedRaises = raises;
|
|
143
|
+
} else {
|
|
144
|
+
printReds(raises.map((r) => ({ code: 'envelope-widen', path: r.field, detail: `${r.new} exceeds the bundle's signed ${r.field} (${r.old}) — a raise needs your yes: run it at a terminal and type yes, or pass --yes` })), err);
|
|
145
|
+
return 1;
|
|
146
|
+
}
|
|
147
|
+
}
|
|
82
148
|
|
|
83
149
|
// 3. blessing — BEFORE any key is read (the engine reads the key last).
|
|
150
|
+
let signedBundle = false;
|
|
84
151
|
const { manifest } = bundle;
|
|
85
152
|
if (!bundle.blessing) {
|
|
86
153
|
// The runid that ACTUALLY minted this bundle's own signed spec — the bridge VERSION
|
|
@@ -104,8 +171,17 @@ export async function bundleMain(args, {
|
|
|
104
171
|
out(mintRunid ? `minting run: ${mintRunid} (spine not bundled in v1)` : 'no version at this hash');
|
|
105
172
|
out(`bundleHash: ${manifest.bundleHash}`);
|
|
106
173
|
if (flags.approve !== manifest.bundleHash) {
|
|
107
|
-
|
|
108
|
-
|
|
174
|
+
// typed at a terminal (the menu): show the hash and sign it with a typed yes, the cap raise's own confirm style (hamr 2026-10-25).
|
|
175
|
+
// Flags only: `--approve <hash>` is still the way (`--yes` signs caps, not a bundle).
|
|
176
|
+
if (askable && ask && flags.approve === undefined) {
|
|
177
|
+
const a = (await ask('Type yes to sign it: ')).trim().toLowerCase();
|
|
178
|
+
if (isQuit(a)) { out('Not signed, nothing run.'); return 0; }
|
|
179
|
+
if (a !== 'yes') { err('Not signed (only "yes" signs a bundle) — nothing ran.'); return 1; }
|
|
180
|
+
signedBundle = true;
|
|
181
|
+
} else {
|
|
182
|
+
err(`--approve ${manifest.bundleHash} is required for the first run of an unblessed bundle`);
|
|
183
|
+
return 1;
|
|
184
|
+
}
|
|
109
185
|
}
|
|
110
186
|
} else {
|
|
111
187
|
const vb = verifyBlessing(bundle);
|
|
@@ -190,11 +266,37 @@ export async function bundleMain(args, {
|
|
|
190
266
|
addWorktree(repo, worktree);
|
|
191
267
|
}
|
|
192
268
|
mkdirSync(runDir, { recursive: true });
|
|
269
|
+
// a raised cap the person signed: who, old, new, at — appended beside the run's own records (never rewritten)
|
|
270
|
+
if (signedBundle) {
|
|
271
|
+
appendFileSync(join(runDir, 'approvals.jsonl'), `${JSON.stringify({
|
|
272
|
+
type: 'bundle-approve', who: userInfo().username, bundleHash: manifest.bundleHash, at: new Date(now()).toISOString(),
|
|
273
|
+
})}\n`);
|
|
274
|
+
}
|
|
275
|
+
for (const r of signedRaises) {
|
|
276
|
+
appendFileSync(join(runDir, 'approvals.jsonl'), `${JSON.stringify({
|
|
277
|
+
type: 'cap-raise', who: userInfo().username, field: r.field, old: r.old, new: r.new, at: new Date(now()).toISOString(), bundleHash: manifest.bundleHash, approveHash,
|
|
278
|
+
})}\n`);
|
|
279
|
+
}
|
|
193
280
|
writeFileSync(join(runDir, 'run.json'), `${JSON.stringify({
|
|
194
281
|
runid, worktree, seed, repo, at: firstAt ?? new Date(now()).toISOString(),
|
|
195
282
|
}, null, 2)}\n`);
|
|
196
283
|
};
|
|
197
284
|
|
|
285
|
+
// 5b. the model: the one the bundle's spec names. A spec that names none takes the one the person picks from the Settings lines.
|
|
286
|
+
if (!bundle.spec.model && typeof flags.model !== 'string' && askable && ask) {
|
|
287
|
+
const lines = chatLines(rowsForHome(keysHome, env));
|
|
288
|
+
if (lines.length > 0) {
|
|
289
|
+
out('This bundle names no model. Models ticked in Settings:');
|
|
290
|
+
lines.forEach((l, i) => out(` ${i + 1} ${l.label}`));
|
|
291
|
+
const pick = await askRequired(ask, 'Model (a number): ');
|
|
292
|
+
if (pick === null) { out('No model chosen, nothing run.'); return 0; }
|
|
293
|
+
const hit = /^\d+$/.test(pick) ? lines[Number(pick) - 1] : undefined;
|
|
294
|
+
if (!hit) { err(`"${pick}" is not one of the numbers above.`); return 1; }
|
|
295
|
+
flags.model = hit.model;
|
|
296
|
+
flags.provider = hit.slot;
|
|
297
|
+
}
|
|
298
|
+
}
|
|
299
|
+
|
|
198
300
|
// 6. the engine. `deps` passes through exactly as `bareloop run-u` passes it, so every
|
|
199
301
|
// test seam (provider/providerFor/judgeProvider/runlistHome/keysHome) is the same one.
|
|
200
302
|
let engineCode;
|
|
@@ -239,6 +341,18 @@ export async function bundleMain(args, {
|
|
|
239
341
|
const outcome = je.outcome;
|
|
240
342
|
const spentUsd = je.spentUsd ?? null;
|
|
241
343
|
const spendComplete = je.spendComplete ?? null;
|
|
344
|
+
// a green's work is committed on its work branch, like the panel does (the folder is kept; the merge stays yours)
|
|
345
|
+
let commitLine = null;
|
|
346
|
+
let commitFailed = false;
|
|
347
|
+
if (outcome === 'green' || outcome === 'already-green') {
|
|
348
|
+
try {
|
|
349
|
+
const fin = commitWork(worktree, `bareloop: ${runSpec.job} (run ${runid})`);
|
|
350
|
+
commitLine = fin.committed ? `final commit ${fin.sha}` : 'nothing left to commit';
|
|
351
|
+
} catch (e) {
|
|
352
|
+
commitFailed = true;
|
|
353
|
+
commitLine = `the final commit FAILED, the work is still in the worktree uncommitted: ${String(/** @type {Error} */ (e).message).split('\n')[0]}`;
|
|
354
|
+
}
|
|
355
|
+
}
|
|
242
356
|
let branch = null;
|
|
243
357
|
try { branch = execFileSync('git', ['-C', worktree, 'rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8' }).trim(); } catch { /* leave null — reported honestly below */ }
|
|
244
358
|
appendHistory(bundleDir, {
|
|
@@ -253,6 +367,7 @@ export async function bundleMain(args, {
|
|
|
253
367
|
branch,
|
|
254
368
|
bundleHash: manifest.bundleHash,
|
|
255
369
|
approveHash,
|
|
370
|
+
...(signedRaises.length > 0 ? { capsRaised: signedRaises } : {}),
|
|
256
371
|
// one row per LEG of the one run; the first leg's row keeps the shape it always had
|
|
257
372
|
...(legs.length > 1 ? { leg: legs.length } : {}),
|
|
258
373
|
});
|
|
@@ -265,10 +380,12 @@ export async function bundleMain(args, {
|
|
|
265
380
|
// 8. the merge hints (the engine printed the outcome/spend readout).
|
|
266
381
|
out(`branch ${branch ?? 'UNKNOWN (could not read the worktree branch)'}`);
|
|
267
382
|
out(`worktree ${worktree}`);
|
|
383
|
+
if (commitLine) out(`commit ${commitLine}`);
|
|
268
384
|
if (branch) out(`merge git merge ${branch} (merge stays human — this CLI never merges)`);
|
|
269
385
|
out(`the worktree is kept until you remove it: git worktree remove ${worktree}`);
|
|
270
386
|
// exit 0 ONLY for a real green — every other outcome exits 1 so a caller scripting
|
|
271
387
|
// `bareloop run` off its exit code cannot mistake a red for a success. The engine's own
|
|
272
388
|
// 2 (refusal) / 3 (spine leak) are preserved.
|
|
389
|
+
if (commitFailed) return engineCode || 1;
|
|
273
390
|
return engineCode || (outcome === 'green' || outcome === 'already-green' ? 0 : 1);
|
|
274
391
|
}
|