bareloop 0.39.0 → 0.41.0

package/types/source.d.ts

@@ -304,6 +304,32 @@ export function frontDoorFromManifest(read: {
  * @returns {string}
  */
 export function nonRepoSourceMessage(kind: string): string;
+/**
+ * P7 (docs/product/PANEL-BUILD.md, "Inputs"): prove the NUMBERED INPUTS at $0, before any token. Line 1 is the repo
+ * (an absolute path to an existing folder); lines 2+ are files or folders INSIDE that repo, repo-relative. A line
+ * that is not one of those is a named red naming its line number — never a throw, never a silent skip:
+ *   - a `search:` line or a URL, and a path that leaves the repo: "only files inside the repo for now" (search and
+ *     outside-the-repo inputs arrive with the plain-folder piece);
+ *   - a path that does not exist, or that git does not track (a repo job would not see it);
+ *   - the front door's own refusals for a file: an environment file by NAME, a symlink, a non-text file, an oversize
+ *     file. A known secret shape in its content is NOT a refusal (masked where recorded, as the P6 worktree door does).
+ * A folder value is checked for existence and tracking only (its files are the repo's own, which the worktree door
+ * already masks). Reads the tree; writes nothing.
+ * @param {{n: number, label: string, value: string}[]} inputs the parsed Inputs (`parseInputs`)
+ * @returns {Promise<{ok: true, repo: string, root: string|null}|{ok: false, error: string}>} `repo` = line 1's absolute path; `root` = the git root it sits in (null when line 1 alone was given and it is not in a git repo)
+ */
+export function proveInputFiles(inputs: {
+    n: number;
+    label: string;
+    value: string;
+}[]): Promise<{
+    ok: true;
+    repo: string;
+    root: string | null;
+} | {
+    ok: false;
+    error: string;
+}>;
 /**
  * a named, non-throwing stop
  */

package/types/thinking.d.ts

@@ -0,0 +1,90 @@
+/**
+ * What bare-agent knows about switching this model's thinking. A missing kind, a non-function `impl`, or a throw all read
+ * `'unverified'` — never a guess in either direction.
+ * @param {string} shape an API shape id (src/providershapes.js)
+ * @param {string} model
+ * @param {{ baseUrl?: string|null, impl?: Function }} [o] `impl` is a test seam; production uses bare-agent's own
+ * @returns {true|false|'unverified'}
+ */
+export function thinkingSupport(shape: string, model: string, { baseUrl, impl }?: {
+    baseUrl?: string | null;
+    impl?: Function;
+}): true | false | "unverified";
+/**
+ * The per-call options for one support answer and one tick (`true` = "Thinking on"). The table (PANEL-BUILD.md P8, ruling Q1):
+ *   tick on : true -> on | false -> {} (the box is greyed, cannot be on) | 'unverified' -> on
+ *   tick off: true -> off | false -> {} (the model thinks as it would) | 'unverified' -> off (bare-agent decides; plain request on failure)
+ * @param {true|false|'unverified'} support
+ * @param {boolean} tick
+ * @returns {{ thinkingMode: 'on'|'off' } | {}}
+ */
+export function thinkingOptions(support: true | false | "unverified", tick: boolean): {
+    thinkingMode: "on" | "off";
+} | {};
+/**
+ * Throw unless `mode` is one of {@link THINKING_MODES} — an operator-param guard, so a typo never silently means a mode.
+ * @param {unknown} mode
+ * @returns {'on'|'off'}
+ */
+export function assertThinkingMode(mode: unknown): "on" | "off";
+/**
+ * The API shape of a constructed bare-agent provider (the three client classes only); `null` for a test double or a clipipe.
+ * @param {any} provider
+ * @returns {string|null}
+ */
+export function shapeOfProvider(provider: any): string | null;
+/**
+ * The per-call options every DRAFTING and JUDGING model call on this provider instance carries for this mode. A provider that is
+ * not one of the three client classes (a test double, a clipipe) is never sent the switch.
+ * @param {any} provider a constructed bare-agent provider
+ * @param {unknown} [mode] 'on' | 'off' (default 'off')
+ * @returns {{ thinkingMode: 'on'|'off' } | {}}
+ */
+export function thinkingCallOptions(provider: any, mode?: unknown): {
+    thinkingMode: "on" | "off";
+} | {};
+/**
+ * What the drafting calls will carry for a model the caller has only NAMED (shape, model id, Base URL) — no key, no network. The
+ * first drafting row is shown from this, before the key is read.
+ * @param {{providerName: string, model: string, baseUrl?: string|null}} o
+ * @param {unknown} [mode] 'on' | 'off'
+ * @returns {{ support: true|false|'unverified', mode: 'on'|'off', options: {thinkingMode?: 'on'|'off'} }}
+ */
+export function thinkingPlanFor({ providerName, model, baseUrl }: {
+    providerName: string;
+    model: string;
+    baseUrl?: string | null;
+}, mode?: unknown): {
+    support: true | false | "unverified";
+    mode: "on" | "off";
+    options: {
+        thinkingMode?: "on" | "off";
+    };
+};
+/**
+ * The server's answer for one Model-menu line: whether the "Thinking on" box can change and the words under it. `false` greys and
+ * unticks the box (the note reads {@link THINKING_FIXED_SAY}); `'unverified'` leaves it enabled with no note.
+ * @param {string} shape @param {string} model @param {string|null|undefined} baseUrl
+ * @returns {{ support: true|false|'unverified', canChange: boolean, say: string }}
+ */
+export function thinkingForLine(shape: string, model: string, baseUrl: string | null | undefined): {
+    support: true | false | "unverified";
+    canChange: boolean;
+    say: string;
+};
+/**
+ * The first drafting row's words — code-owned, ALWAYS starting "thinking on" or "thinking off". `status` is bare-agent's own
+ * `thinkingStatus` for a call that has run ('applied' | 'unsupported' | 'ignored' | 'unknown'); undefined = before any call, read from
+ * the plan (`support`, `mode`).
+ * @param {{ mode: 'on'|'off', support?: true|false|'unverified', status?: string }} s
+ * @returns {string}
+ */
+export function thinkingRowText({ mode, support, status }: {
+    mode: "on" | "off";
+    support?: true | false | "unverified";
+    status?: string;
+}): string;
+/** The words under a greyed "Thinking on" box (the server's `thinking.canChange` decides; the page decides nothing). */
+export const THINKING_FIXED_SAY: "can't change this for this model";
+/** The enumerated operator knob a drafting call is built with: 'on' | 'off' (the tick, spelled as a word). */
+export const THINKING_MODES: readonly string[];

package/types/userrun.d.ts

@@ -136,9 +136,13 @@ export type RunOpts = {
      */
     into?: string | undefined;
     /**
-     * the raw `--model` tier name (`sonnet`/`haiku`), or null for the default
+     * the raw `--model <id>` (a model id of a ticked Settings line), or null
      */
     model?: string | null | undefined;
+    /**
+     * the raw `--provider <KEY>` (a key's env name), or null
+     */
+    providerKey?: string | null | undefined;
     /**
      * the raw `--read-shim` arm name, or null for the default
      */
@@ -205,6 +209,7 @@ export type RunCtx = {
      */
     into?: string | undefined;
     model: string | null;
+    providerKey: string | null;
     readShim: string | null;
     scout: string | null;
     draftSpentUsd: string | null;