@turri-dev/cli 0.1.28-next.d5f2680 → 0.2.1-next.47b578c

package/dist/extension.js

@@ -17,6 +17,7 @@ import { sandboxAvailable, sandboxSummary } from "./regenerate/os-sandbox.js";
 import { findTestScripts, scriptKindOfSkill } from "./regenerate/test-scripts.js";
 import { writingScript } from "./regenerate/scripts-being-written.js";
 import { applyBedrockRegion } from "./bedrock-region.js";
+import { bannerWarnings } from "./turri-versions.js";
 import { conformanceBlock, conformanceTestsOnIn, CONFORMANCE_TOOLS, TURN_ON_TOOL, turnOnConformanceTests, turnOnConformanceTestsTool } from "./conformance-switch.js";
 import { BACKGROUND_NOTE, doneLine, failedTask, ownChanges, runDetails, skillRunDelivery, startedText } from "./background-skills.js";
 import { createAskUserTool } from "./tools.js";
@@ -26,7 +27,8 @@ import { describeGates, interruptedRun, runSkill } from "./genome.js";
 import { unqueue } from "./chat-waiting.js";
 import { skillStatus } from "./skill.js";
 import { runningDeployed, stopDeployed } from "./regenerate/release.js";
-import { createDeployState, createDeployTools } from "./release-tools.js";
+import { createDeployState, createDeployTools, currentRelease } from "./release-tools.js";
+import { checkedSpecs } from "./sentinel-check.js";
 import { runReleaseAgent } from "./release-agent.js";
 import { createSteeringStore, EVERY_MODULE, moduleNameOf, queueSectionOf, steeringFor } from "./regenerate/steer.js";
 import { askedForCommandLine, refusal, selfInvocation, TOOLS_NOT_CLI } from "./self-invocation.js";
@@ -61,6 +63,8 @@ import { doctorTool } from "./doctor-tool.js";
 import { ledgerTool } from "./ledger-tools.js";
 import { describeSpecConflict } from "./regenerate/stop-report.js";
 import { inheritProviders, inheritThinkingLevel } from "./pi.js";
+import { LOADING_PROVIDERS } from "./installed-providers.js";
+import { machineChange, machineChangeReason, writesPlain } from "./regenerate/command-check.js";
 import { beginCapture, captureConsole, describeCaptured, dropNoise } from "./quiet.js";
 import { loadRules, renderRulesBlock } from "./rules.js";
 import { registerTurriConfig, ruleNames } from "./config-command.js";
@@ -74,7 +78,7 @@ import { supersededByTurri } from "./chat-skills.js";
 import { conversationIdentity } from "./identity.js";
 import { setSurface, surfaceOf } from "./surface.js";
 import { createChats, scopedToChat } from "./chats.js";
-import { ignoredGuidance, keepGuidance, landedNote, pulseEndsBlock, SENTINEL, SENTINEL_TOOLS, sentinelBrief, sentinelPrompt, sentinelSetting, sentinelStartNotice, specConflictNotice } from "./sentinel.js";
+import { ignoredGuidance, keepGuidance, landedNote, pulseEndsBlock, SENTINEL, SENTINEL_TOOLS, sentinelBrief, sentinelCheckBrief, sentinelPrompt, sentinelSetting, sentinelStartNotice, specConflictNotice } from "./sentinel.js";
 import { noticeDialogs, registerSentinel } from "./sentinel-chat.js";
 import { currentChat } from "./chat-scope.js";
 import { registerChats } from "./chat-commands.js";
@@ -404,7 +408,9 @@ export function processSession(make = () => createTurriCore()) {
     const global = globalThis;
     return (global[SESSION] ??= make());
 }
-const extension = (pi) => processSession().extension(pi);
+// Loaded as nothing while the person's pi extensions are loaded only for their providers (installed-providers.ts): an older
+// turri installed into every pi is among them, and would start a session of its own.
+const extension = (pi) => (process.env[LOADING_PROVIDERS] === "1" ? undefined : processSession().extension(pi));
 export default extension;
 /**
  * The session's work loop, for a host to read: made with the first chat's context - the models it plans with - when no
@@ -431,8 +437,10 @@ function turriExtension(api, session, link) {
     const isSentinel = link.role === SENTINEL;
     const hostSentinelTools = isSentinel ? (host.sentinel?.tools ?? []) : [];
     const sentinelAllowed = new Set([...SENTINEL_TOOLS, ...hostSentinelTools.map((tool) => tool.name)]);
+    // Its resume: the module brought up again on the session's work loop, as regenerate brings it up.
+    const resumeModule = async (plainFile) => describeModules(await sessionLoop(session).bringUp(resolve(cwd, plainFile)));
     if (isSentinel)
-        registerSentinel(pi, session, cwd, hostSentinelTools, sentinelAllowed);
+        registerSentinel(pi, session, cwd, hostSentinelTools, sentinelAllowed, resumeModule);
     const dialogs = link.dialogs ?? host.dialogs;
     // turri's own skills, and the project's - .turri/skills, .agents/skills (skills.ts).
     const discoveredSkills = discoverSkills(PACKAGE_ROOT, cwd);
@@ -491,6 +499,39 @@ function turriExtension(api, session, link) {
         });
         void pi.sendMessage({ customType: "turri_sentinel_pulse", content, display: false, details: { jobId: job.id, status: job.status } }, { triggerTurn: true });
     };
+    // The sentinel's: functional specs a host asked it to check. The module is released first - as release-after-pulse
+    // releases it - unless what runs is its own codebase's last commit; then told, in a conversation of its own for the
+    // check, its hidden first message `turri_sentinel_check`. Why not, when the release failed: its agent is told nothing.
+    const briefCheck = async (check, context) => {
+        const state = deployStates.get(jobs) ?? createDeployState();
+        let releasedNow = false;
+        if (currentRelease(state, check.plainFile, check.module) === undefined) {
+            // Behind, never made, or what it started died: released afresh - the release tool would say it shipped that already.
+            state.released.delete(check.module);
+            let said;
+            try {
+                const ctx = contextNow();
+                const model = ctx !== undefined ? releaseModel(ctx, check.plainFile) : undefined;
+                said = await runReleaseAgent({ plainFile: check.plainFile, cwd, state, inModule: check.module, forCheck: { moduleName: check.module }, ...(model !== undefined ? { model } : {}) });
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+            if (currentRelease(state, check.plainFile, check.module) === undefined)
+                return said.trim() || "its last commit was not released";
+            releasedNow = true;
+        }
+        const commit = state.released.get(check.module)?.commit;
+        const content = sentinelCheckBrief(check, {
+            specs: checkedSpecs(check),
+            released: runningDeployed(check.module),
+            releasedNow,
+            ...(commit !== undefined ? { commit } : {}),
+            ...(context.focused !== undefined ? { focused: context.focused } : {}),
+        });
+        void pi.sendMessage({ customType: "turri_sentinel_check", content, display: false, details: { checkId: check.id, module: check.module, funcIds: check.funcIds } }, { triggerTurn: true });
+        return undefined;
+    };
     // A pulse ended, with the sentinel on: said in the chat. One that landed is told to its agent too, to tell the person
     // it landed and what the sentinel does with it - and nothing more: the pulse is the sentinel's. ***plain that
     // contradicts itself is put to the person at once, by turri itself, as the chat would have been started on it.
@@ -500,7 +541,9 @@ function turriExtension(api, session, link) {
             session.notice(specConflictNotice(job, specConflictTask(job.specConflict)));
         if (options.tell !== true)
             return;
-        void pi.sendMessage({ customType: "turri_job_landed", content: landedNote(job, runningDeployed(job.module)), display: false, details: { jobId: job.id, status: job.status } }, { triggerTurn: true, deliverAs: "followUp" });
+        // A host that shows the person the pulse's end itself: the chat knows of it - in order, with no turn of its own.
+        const shown = host.pulseEndsShown === true;
+        void pi.sendMessage({ customType: "turri_job_landed", content: landedNote(job, runningDeployed(job.module), { shown }), display: false, details: { jobId: job.id, status: job.status } }, shown ? { triggerTurn: false } : { triggerTurn: true, deliverAs: "followUp" });
     };
     const notices = noticeDialogs(pi, session, link, contextNow);
     // The test advisor's verdicts, once the chat is idle: a yes starts a turn that writes its scenarios, a no is a line.
@@ -509,6 +552,7 @@ function turriExtension(api, session, link) {
         announce,
         landed,
         brief,
+        briefCheck,
         notice: notices.put,
         noticeOver: notices.over,
         concluded: notices.concluded,
@@ -545,10 +589,9 @@ function turriExtension(api, session, link) {
     // pi's skills that turri has already - its own and the project's, run with cultivate, and any about ***plain from
     // another tool - are left out of the list the conversation is offered (chat-skills.ts); the person is told once.
     const turriRuns = new Set(discoveredSkills.skills.map((skill) => skill.name));
-    // What the modules need of this machine: worked out once the chat is up, and after a turn when a spec changed - never
-    // while a message waits to be sent.
+    // What the modules need of this machine: worked out when a turn first asks, and after a turn when a spec changed - never
+    // as the session starts, which a host would wait on, and never while a message waits to be sent once it is known.
     const machine = machineNeeds(cwd);
-    pi.on("session_start", () => machine.refreshSoon());
     pi.on("agent_settled", () => machine.refreshSoon());
     pi.on("before_agent_start", (event, ctx) => {
         const offered = event.systemPromptOptions.skills;
@@ -598,9 +641,20 @@ function turriExtension(api, session, link) {
     pi.on("tool_call", (event) => {
         // The sentinel reads, and puts what it finds to the person: whatever else it calls is refused.
         if (isSentinel && !sentinelAllowed.has(event.toolName)) {
-            return { block: true, reason: `The sentinel changes nothing: ${event.toolName} is not one of its tools. Put what needs doing to the person with notify_person.` };
+            return { block: true, reason: `${event.toolName} is not one of the sentinel's tools: it fixes the project's testing scripts and their config, and nothing else. Put what needs doing to the person with notify_person.` };
         }
         const command = event.input.command;
+        // turri changes nothing of the machine's - no install, no system setting - asked or not, through any tool that runs a
+        // command: its own bash, and a host's - a terminal in its window. The person does that.
+        if (typeof command === "string") {
+            const changes = machineChange(command);
+            if (changes !== undefined)
+                return { block: true, reason: machineChangeReason(changes) };
+            // The sentinel's write and edit reach its tooling alone: a host's command does not write ***plain for it.
+            const plain = isSentinel ? writesPlain(command) : undefined;
+            if (plain !== undefined)
+                return { block: true, reason: `${plain} is ***plain: the sentinel never changes it - put what it needs to the person with notify_person.` };
+        }
         if (event.toolName === "bash" && typeof command === "string") {
             const what = selfInvocation(command);
             if (what !== undefined && !askedForCommandLine(lastUserMessage))
@@ -1183,7 +1237,7 @@ function registerRegenerate(pi, cwd, jobs) {
             // Said at once, and kept in the chat: what follows takes a while - the planner is an agent - and the person sees it
             // began, not a chat that stays empty until the first pulse starts. The plan is said under it once it is made.
             say(scratch
-                ? `Deleting ${module}'s code${chain ? " and its whole chain's" : ""}, then planning all of it again…`
+                ? `Deleting ${module}'s code${chain ? " and its whole chain's" : ""} and then starting regeneration…`
                 : again.length > 0
                     ? `Planning ${again.join(", ")} again…`
                     : `Planning ${module}'s pulses…`, "info");
@@ -1444,8 +1498,9 @@ export function machineBlock(cwd, modules = stackOnMachine(cwd)) {
 }
 /**
  * What the project's modules need of this machine, kept between turns - working it out parses every spec, seconds on a
- * project of long requires chains, and a message is never kept waiting for it. Worked out once the chat is up, and again
- * when a turn has settled and a spec changed since: a turn is told what was known last, at most a turn behind.
+ * project of long requires chains. Worked out when the first turn asks - not as the session starts: a host's thread
+ * would be held up opening a chat no one may write in - and again, once known, when a turn has settled and a spec
+ * changed since: a turn is told what was known last, at most a turn behind.
  */
 export function machineNeeds(cwd, work = stackOnMachine) {
     let known;
@@ -1475,8 +1530,10 @@ export function machineNeeds(cwd, work = stackOnMachine) {
                 refresh();
             return known.modules;
         },
-        /** Worked out again, if a spec changed - once the chat has drawn what it is drawing. */
+        /** Worked out again, if it is known and a spec changed - once the chat has drawn what it is drawing. */
         refreshSoon() {
+            if (known === undefined)
+                return;
             setTimeout(() => {
                 try {
                     refresh();
@@ -1598,6 +1655,10 @@ function conversationModel(ctx, override) {
  * The chat's model, read now - it can change while a skill runs - or, from a context that has
  * gone stale since, the model it had when it was last readable.
  */
+/** The model a release runs on - a pulse's last stage, and a check's: the one that regenerated the module. A release follows steps, and a small model thinking little does that well. */
+function releaseModel(ctx, plainFile) {
+    return modelFor(chosenModels, "spec_changes", projectModel(ctx, plainFile) ?? chatModelOf(ctx));
+}
 function chatModelOf(ctx) {
     try {
         const now = conversationModel(ctx);
@@ -1833,7 +1894,7 @@ function workLoopFor(jobs, cwd, ctx) {
             // Under release-after-pulse, a pulse releases what it landed itself, before the next starts - on the model that
             // regenerated it: a release follows steps, and a small model thinking little does that well.
             release: ({ plainFile, moduleName, title, onDelta }) => {
-                const model = modelFor(chosenModels, "spec_changes", projectModel(from.ctx, plainFile) ?? chatModelOf(from.ctx));
+                const model = releaseModel(from.ctx, plainFile);
                 return runReleaseAgent({
                     plainFile,
                     cwd,
@@ -2173,15 +2234,15 @@ export const JOB_FINISHED_REACTION = [
     "  `toolchains:` does not - never add it there, and never resume before the fix. Do what the report says if it is the",
     "  project's to change - a tool told to use `$HOME` in the build's own files - say so, and resume; otherwise tell the",
     "  person, in a line or two, what the report says and that \"resume\" picks it up once it is done.",
-    "- the machine lacks a toolchain or a tool - a JDK, Maven, Gradle, Go, uv, Node, a system library: first find out, in your",
-    "  shell, whether it is installed somewhere off the PATH (`command -v`, Homebrew's opt folders, /Library/Java/",
-    "  JavaVirtualMachines, a version manager the person uses - mise, asdf, sdkman, nvm). Then ask the person with ask_user",
-    "  to let you put it in place the way this machine installs things - the exact command, `brew install openjdk@21`,",
-    "  `mise use -g java@21`, `sdk install maven` - and on yes run it in your shell, check that the command is found now as",
-    "  the testing script would find it (`command -v`, then the doctor tool, which looks on turri's own PATH), and resume. A tool installed where the PATH turri",
-    "  was started with does not reach needs turri restarted: say so, with the line for the shell profile. On no, or when it",
-    "  needs what you cannot do - sudo with a password, a licence, a download behind a login - tell the person exactly what",
-    "  to do, and that \"resume\" picks it up once it is in.",
+    "- the machine lacks a toolchain or a tool - a JDK, Maven, Gradle, Go, uv, Node, a system library: you install nothing,",
+    "  and change no setting of the machine's or the person's shell - never, even when asked: your shell refuses it. First",
+    "  find out, in your shell, whether it is there after all: off the PATH (`command -v`, Homebrew's opt folders,",
+    "  /Library/Java/JavaVirtualMachines, a version manager's folder - mise, asdf, sdkman, nvm), or under another name - python",
+    "  where the testing script runs python3, of the version the ***plain names. When it is there, the testing script calling",
+    "  it the way this machine has it is the fix: change the script, say so in a line, and resume. When it is not, tell the",
+    "  person exactly what to run themselves - `brew install openjdk@21`, `mise use -g java@21` - and the line for their",
+    "  shell profile when the PATH needs it, and that \"resume\" picks it up once it is in. A tool the person installs where the",
+    "  PATH turri was started with does not reach needs turri restarted: say so.",
     "- a credential `agent-env:` names that is not there: never make one up - tell the person where it is read from.",
 ].join("\n");
 const sidePanels = new WeakMap();
@@ -2688,6 +2749,8 @@ function registerDeploy(pi, cwd, jobs, state) {
     });
 }
 const MILESTONE_ENTRY = "turri_milestone";
+/** A newer turri out, found once turri had started (turri-versions.ts). */
+const VERSION_ENTRY = "turri_version";
 const JOB_ENTRY = "turri_job";
 const JOBS_LIST_ENTRY = "turri_jobs";
 const HISTORY_ENTRY = "turri_history";
@@ -2901,6 +2964,8 @@ function registerBranding(pi, skills) {
         const lines = [
             `${brandPink(theme)("turri")}  ${theme.fg("muted", `v${data.version}`)}` +
                 (data.commit !== undefined ? theme.fg("dim", `  from a clone, ${data.commit}${data.changed ? " with changes" : ""}`) : ""),
+            // A newer turri out, or one installed and hidden behind this one: said first, under the version it is about.
+            ...(data.versions ?? []).map((line) => theme.fg("warning", line)),
             `${theme.fg("text", "the first coding agent with the power of ")}${brandPink(theme)("regenerative software")}`,
             // Where the settings are changed, without leaving the chat.
             theme.fg("muted", "configure with /turri-config"),
@@ -2912,6 +2977,15 @@ function registerBranding(pi, skills) {
         // where the terminal shows images, drawn in text where it does not.
         return new Banner(lines, (rule) => theme.fg("borderMuted", rule), jellyfishArt(theme.appearance, (theme.getColorMode?.() ?? "truecolor") === "truecolor"));
     });
+    // A newer turri, found once turri had started: a line, as the banner would have said it.
+    pi.registerEntryRenderer(VERSION_ENTRY, (entry, _options, theme) => {
+        const data = entry.data;
+        if (data === undefined)
+            return undefined;
+        const box = new Box(1, 0);
+        box.addChild(new Text(theme.fg("warning", data.text), 0, 0));
+        return box;
+    });
     let bannered = false;
     pi.on("session_start", (_event, ctx) => {
         if (ctx.hasUI) {
@@ -2924,12 +2998,25 @@ function registerBranding(pi, skills) {
         bannered = true;
         try {
             const identity = turriIdentity();
+            const versions = bannerWarnings();
+            // A newer turri npm says is out only now - the banner read what it said last time: said under the banner once it does.
+            void versions.later.then((line) => {
+                if (line === undefined)
+                    return;
+                try {
+                    pi.appendEntry(VERSION_ENTRY, { text: line });
+                }
+                catch {
+                    /* the chat let go meanwhile: the next start's banner says it */
+                }
+            });
             pi.appendEntry(BANNER_ENTRY, {
                 version: identity.version ?? "0.0.0",
                 commit: identity.git_commit?.slice(0, 7),
                 changed: identity.git_dirty === true,
                 pending: skills.pending.length,
                 sandbox: sandboxSummary(),
+                versions: versions.lines,
             });
         }
         catch {

package/dist/host-session.d.ts

@@ -5,6 +5,7 @@ import { type EvaluateOutcome } from "./advisor-chat.ts";
 import type { JobRegistry } from "./regenerate/jobs.ts";
 import type { WorkLoop } from "./regenerate/loop.ts";
 import type { Notice, NoticeAnswer } from "./notice.ts";
+import { type CheckRequest } from "./sentinel-check.ts";
 /**
  * turri's session for a host that runs its chats itself - a desktop app, an editor: the chats, each a pi session with
  * turri in it, on one job registry and work loop. The host shows each chat in its own way - subscribes to its session,
@@ -67,6 +68,19 @@ export interface Turri {
      * hears each as it is put (`onNotice`) and as it ends (`onNoticeOver`).
      */
     notices(): Notice[];
+    /**
+     * The sentinel asked to check functional specs in a module's release - `funcIds` each `module:func-id`, of the module or
+     * of any module its requires chain builds on (a bare func-id is the module's own) - in the module's release, as it tests a release after a pulse: the module's own codebase's last
+     * commit, which holds every module its chain builds on, released first unless that is what runs. Queued behind the
+     * sentinel's work, in a conversation of its own. Returns the check's id - its notices and its conclusion carry it - or
+     * why it was refused: the sentinel off or not started this session, a module not there or that does not parse, a
+     * module outside its chain, a func-id a module does not have, one not built in its codebase as its ***plain has it now.
+     */
+    check(request: CheckRequest): {
+        check: string;
+    } | {
+        refused: string;
+    };
     /**
      * The test advisor asked to evaluate functional specs, as the chat's `evaluate_tests` does - for a host's own way in,
      * a button on a functional spec: `module:func-id`s, or func-ids of `plainFile`'s module, even a text judged already and

package/dist/host-session.js

@@ -6,6 +6,7 @@ import { reachable, ruleNames, settingCandidates } from "./config-command.js";
 import { settingOf } from "./config-edit.js";
 import { createTurriCore, sessionAdvisor, sessionLoop, turnOnConformance } from "./extension.js";
 import { stopDeployed } from "./regenerate/release.js";
+import { prepareCheck } from "./sentinel-check.js";
 /** turri's session in a host, in the process's working folder - the project's. */
 export async function createTurri(options = {}) {
     const { dialogs, uiContext, extensions = [], agentDir = getAgentDir(), sessionDir, restore, ...host } = options;
@@ -71,6 +72,7 @@ export async function createTurri(options = {}) {
         },
         decline: async (id) => core.decline(id),
         notices: () => core.notices(),
+        check: (request) => core.check(() => prepareCheck(cwd, request)),
         evaluateTests: (funcIds, options) => evaluateTests(cwd, sessionAdvisor(core), funcIds, options),
         turnOnConformanceTests: (plainFile) => turnOnConformance(core, plainFile),
         settingChoices: (key, typed = "") => {

package/dist/host.d.ts

@@ -6,7 +6,8 @@
  */
 export { createTurri, type Turri, type TurriOptions } from "./host-session.ts";
 export { MAX_CHATS, type ChatInfo, type ChatStatus, type TurriHost } from "./chats.ts";
-export { SENTINEL, SENTINEL_START, type Conclusion, type Notice, type NoticeAction, type NoticeAnswer, type NoticeSeverity, type NoticeState } from "./notice.ts";
+export { SENTINEL, SENTINEL_START, type Conclusion, type Notice, type NoticeAction, type NoticeAnswer, type NoticeSeverity, type NoticeState, type SentinelCheck } from "./notice.ts";
+export type { CheckRequest } from "./sentinel-check.ts";
 export type { AskUserIO } from "./ask.ts";
 /** pi itself, as turri is built against it: a host's own extensions and UI are made with this one, not another copy. */
 export * as pi from "@earendil-works/pi-coding-agent";
@@ -16,6 +17,8 @@ export { configSettings, currentValue, EFFECT_TEXT, overriddenBy, readConfigText
 export { bedrockRegionFor, type BedrockRegion, type BedrockRegionSource } from "./bedrock-region.ts";
 export { BEDROCK_DEFAULT, BEDROCK_GEOGRAPHIES, BEDROCK_IN_REGION, BEDROCK_REGIONS, bedrockAwsRegion, bedrockDefaultModels, bedrockMakers, bedrockModels, bedrockModelsIn, bedrockNeedsAwsRegion, bedrockPlaceOf, initConfig, makerLabel, VENDORS, type BedrockChoice, type BedrockMaker, type BedrockOffer, type InitConfigOptions, type ModelChoice, type ModelSet, type Vendor, } from "./init-config.ts";
 export { piModelCatalogue, type CatalogueModel, type ModelCatalogue } from "./model-check.ts";
+export { EXTENSION_PROVIDERS, installedModelRuntime } from "./installed-providers.ts";
+export { machineChange, machineChangeReason } from "./regenerate/command-check.ts";
 export { doctor, type Check, type DoctorOptions, type Level } from "./setup.ts";
 export { checkPlainFile, type CheckResult } from "./plain/check.ts";
 export { plainFileParser } from "./plain/parser.ts";
@@ -26,6 +29,8 @@ export { conceptBeingTyped, findConcepts } from "./plain/concepts.ts";
 export { plainGraph, type PlainConceptNode, type PlainGraph, type PlainItemNode, type PlainLink, type PlainModuleNode, type PlainScenario, type PlainSection, type PlainTestPlainFileNode } from "./plain/graph.ts";
 export { isStack, STDLIB_KINDS, stdlibTemplates, type StdlibKind, type StdlibTemplate } from "./stdlib.ts";
 export { createWorkLoop, describeModules, functionalityCompletion, promptOf, type DriftReport, type ModuleStatus, type WorkLoop } from "./regenerate/loop.ts";
+export { projectStanding, type ModuleStanding, type StandingOptions } from "./regenerate/standing.ts";
+export { requiresOrder } from "./regenerate/requires.ts";
 export { createJobRegistry, defaultParallelJobs, type Job, type JobRegistry, type PulseCases, type PulseSpec } from "./regenerate/jobs.ts";
 export { describeTurnIncident, onModelEvent, type TranscriptEntry } from "./regenerate/activity.ts";
 export { sweepOrphanedGroups } from "./regenerate/shell.ts";

package/dist/host.js

@@ -7,7 +7,7 @@
 // The session and its chats.
 export { createTurri } from "./host-session.js";
 export { MAX_CHATS } from "./chats.js";
-// The sentinel's notices: what it puts to the person, and how they answer.
+// The sentinel's notices: what it puts to the person, and how they answer - and the checks a host asks of it.
 export { SENTINEL, SENTINEL_START } from "./notice.js";
 /** pi itself, as turri is built against it: a host's own extensions and UI are made with this one, not another copy. */
 export * as pi from "@earendil-works/pi-coding-agent";
@@ -24,6 +24,8 @@ export { bedrockRegionFor } from "./bedrock-region.js";
 export { BEDROCK_DEFAULT, BEDROCK_GEOGRAPHIES, BEDROCK_IN_REGION, BEDROCK_REGIONS, bedrockAwsRegion, bedrockDefaultModels, bedrockMakers, bedrockModels, bedrockModelsIn, bedrockNeedsAwsRegion, bedrockPlaceOf, initConfig, makerLabel, VENDORS, } from "./init-config.js";
 // pi's model catalogue, read without a request: what initConfig checks the models given against, and what a host offers.
 export { piModelCatalogue } from "./model-check.js";
+export { EXTENSION_PROVIDERS, installedModelRuntime } from "./installed-providers.js";
+export { machineChange, machineChangeReason } from "./regenerate/command-check.js";
 // Whether this machine, and a project on it, is ready for turri - as `turri doctor` checks it, printing nothing.
 export { doctor } from "./setup.js";
 // A spec: parsed, checked, coloured.
@@ -41,6 +43,8 @@ export { plainGraph } from "./plain/graph.js";
 export { isStack, STDLIB_KINDS, stdlibTemplates } from "./stdlib.js";
 // The work: what is built, what is left, and the jobs that build it.
 export { createWorkLoop, describeModules, functionalityCompletion, promptOf } from "./regenerate/loop.js";
+export { projectStanding } from "./regenerate/standing.js";
+export { requiresOrder } from "./regenerate/requires.js";
 export { createJobRegistry, defaultParallelJobs } from "./regenerate/jobs.js";
 export { describeTurnIncident, onModelEvent } from "./regenerate/activity.js";
 export { sweepOrphanedGroups } from "./regenerate/shell.js";

package/dist/init-config.d.ts

@@ -16,7 +16,7 @@ import { type CatalogueModel, type ModelCatalogue } from "./model-check.ts";
  * new one takes from a config.yaml beside it the keys turri reads too.
  */
 /** A vendor whose models the quick start config is filled in with. */
-export type Vendor = "anthropic" | "openai" | "google" | "amazon-bedrock" | "other";
+export type Vendor = "anthropic" | "openai" | "google" | "amazon-bedrock" | "claude-code" | "other";
 /** Whose models Amazon Bedrock serves: the maker a model's id names after its geography - anthropic, openai, xai, meta... */
 export type BedrockMaker = string;
 /**

package/dist/init-config.js

@@ -7,6 +7,7 @@ import { adoptLegacyConfig, CONFIG_FILE, CONFIG_KEYS, LEGACY_CONFIG_FILE, ROLE_T
 import { withTopLevelValue } from "./config-edit.js";
 import { brand } from "./brand.js";
 import { closestModels, piModelCatalogue } from "./model-check.js";
+import { EXTENSION_PROVIDERS } from "./installed-providers.js";
 /** The geographies turri's own pair for each maker is served in - the first the default. Every other: bedrockMakers. */
 export const BEDROCK_REGIONS = {
     anthropic: ["global", "us", "eu", "jp", "au"],
@@ -152,6 +153,14 @@ export const VENDORS = {
         ...bedrockModels({ maker: "anthropic", region: BEDROCK_DEFAULT.region }),
         keys: [{ vendor: "AWS", variable: "AWS_PROFILE" }],
     },
+    // A Claude Pro or Max subscription, through Claude Code: its pi extension's provider (installed-providers.ts), no key.
+    "claude-code": {
+        label: "Claude subscription",
+        harness: "claude-code/claude-opus-5-5",
+        coding: "claude-code/claude-sonnet-5",
+        strong: "claude-code/claude-opus-5-5",
+        keys: [],
+    },
     // A mix - the strongest to talk to, a cheap one to code - and the starting point for any other provider pi supports.
     other: {
         label: "Other",
@@ -370,6 +379,8 @@ export function vendorOf(answer) {
     const byNumber = /^\d+$/.test(typed) ? names[Number(typed) - 1] : undefined;
     if (typed === "bedrock" || typed === "aws")
         return "amazon-bedrock";
+    if (typed === "claude" || typed === "subscription" || typed === "claude code")
+        return "claude-code";
     return byNumber ?? names.find((name) => name === typed || VENDORS[name].label.toLowerCase() === typed);
 }
 /** The makers offered, as numbered: pi's catalogue's, or without it turri's two. */
@@ -404,6 +415,17 @@ function shellProfile() {
 function signInText(vendor, bedrock, models) {
     // Models given on another vendor's terms - other's, a provider of their own: the keys of the providers they name.
     const providers = models !== undefined && vendor === "other" ? [...new Set([models.harness, models.coding].map((model) => model.split("/")[0]))] : [];
+    // A provider a pi extension brings - a Claude subscription through Claude Code: no key, its extension and its own sign-in.
+    const extensions = (vendor === "other" ? providers : [vendor]).flatMap((provider) => (EXTENSION_PROVIDERS[provider] !== undefined ? [EXTENSION_PROVIDERS[provider]] : []));
+    if (extensions.length > 0 && (vendor !== "other" || extensions.length === providers.length)) {
+        return extensions.flatMap((extension) => [
+            brand.bold(`Set up ${extension.label}`),
+            `  ${brand.accent(extension.install)}   ${brand.muted("its pi extension: turri finds what pi has installed")}`,
+            `  ${brand.muted(extension.signIn)}`,
+            "",
+            brand.muted("turri doctor --models checks it answers."),
+        ]);
+    }
     const keys = providers.length > 0
         ? providers.flatMap((provider) => (provider in VENDORS && provider !== "other" && provider !== "amazon-bedrock" ? VENDORS[provider].keys : [{ vendor: makerLabel(provider), variable: "" }]))
         : VENDORS[vendor].keys;
@@ -451,6 +473,8 @@ function whose(vendor, models, given) {
         const makers = [...new Set(places.map((place) => `${makerLabel(place.maker)}'s`))];
         return `${and(makers)} models on Amazon Bedrock (${[...new Set(places.map((place) => place.geography))].join(", ")})`;
     }
+    if (vendor === "claude-code")
+        return "your Claude subscription's models, through Claude Code";
     if (vendor !== "other")
         return `${VENDORS[vendor].label}'s models`;
     if (!given)
@@ -470,8 +494,12 @@ function notInCatalogue(spec, catalogue) {
     if (model === undefined) {
         if (THINKING.test(id) && known.some((entry) => entry.id === id.replace(THINKING, "")))
             return `${spec} names a thinking level: give the model alone, ${spec.replace(THINKING, "")} - turri writes how hard each thinks.`;
-        if (known.length === 0)
-            return `${spec} is not in pi's model catalogue: pi knows no provider ${provider}.`;
+        if (known.length === 0) {
+            const extension = EXTENSION_PROVIDERS[provider];
+            return extension !== undefined
+                ? `${spec} is not in pi's model catalogue: ${provider} - ${extension.label} - comes with a pi extension that is not installed: ${extension.install}`
+                : `${spec} is not in pi's model catalogue: pi knows no provider ${provider}.`;
+        }
         const close = closestModels(id, known.filter((entry) => entry.type === "chat").map((entry) => entry.id));
         return `${spec} is not in pi's model catalogue${close.length > 0 ? ` - did you mean ${close.map((other) => `${provider}/${other}`).join(", ")}?` : "."}`;
     }
@@ -662,7 +690,9 @@ async function askVendor(given, catalogue) {
                 const { label, harness, coding } = VENDORS[name];
                 const what = name === "amazon-bedrock"
                     ? "Anthropic's, OpenAI's, xAI's, Meta's... models on AWS"
-                    : `${name === "other" ? "a mix - " : ""}${harness.split("/")[1]} to talk to, ${coding.split("/")[1]} to code`;
+                    : name === "claude-code"
+                        ? `your Claude Pro or Max, through Claude Code - ${harness.split("/")[1]} to talk to, ${coding.split("/")[1]} to code`
+                        : `${name === "other" ? "a mix - " : ""}${harness.split("/")[1]} to talk to, ${coding.split("/")[1]} to code`;
                 return [label, what];
             }));
             vendor = await askUntil(rl, choose(names.length), vendorOf, `Type a number from 1 to ${names.length}, or a vendor's name.`);

package/dist/installed-providers.d.ts

@@ -0,0 +1,40 @@
+import { ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
+/**
+ * The model providers the person's pi extensions register - a Claude subscription through Claude Code
+ * (pi-claude-code, `claude-code`), a company's own gateway - wherever turri needs a model and no conversation has them.
+ *
+ * In a chat, pi loads the person's installed pi packages itself, and turri's agents take the providers from the
+ * conversation's model registry (pi.ts `inheritProviders`). A command with no conversation - `turri regenerate`,
+ * `turri change-plain`, doctor's model check, init-config - has none: here they are loaded the way pi loads them, once a
+ * process, and only the providers they register are kept. turri's own extension, when an older turri installed it into
+ * every pi, is loaded as nothing meanwhile (`LOADING_PROVIDERS`): it would start a session of its own.
+ */
+/** Set while the person's extensions are loaded for their providers: turri's own extension does nothing then. */
+export declare const LOADING_PROVIDERS = "TURRI_LOADING_PROVIDERS";
+/**
+ * pi's own providers that come from an extension rather than with pi: what installs each, and how it is signed in to - for
+ * doctor and init-config to say when a config names one that is not there.
+ */
+export declare const EXTENSION_PROVIDERS: Record<string, {
+    label: string;
+    install: string;
+    signIn: string;
+}>;
+/**
+ * The providers the person's installed pi extensions register, for `cwd` - its project's pi settings with the person's
+ * own - loaded once. Undefined when none could be loaded: pi's built-in providers and models.json are what there is.
+ */
+export declare function installedProviders(cwd?: string): Promise<ModelRegistry | undefined>;
+/**
+ * pi's model runtime as turri's agents have it with no conversation: pi's providers, models.json and auth.json, and the
+ * providers the person's installed pi extensions register - for a host that signs in or lists models before a chat is
+ * open, whose own `ModelRuntime.create()` would have none of an extension's (`claude-code`, say).
+ */
+export declare function installedModelRuntime(cwd?: string): Promise<ModelRuntime>;
+/** For tests: forget what was loaded. */
+export declare function forgetInstalledProviders(): void;
+/**
+ * pi's model runtime - its catalogue, models.json and its credentials - with `source`'s providers registered in it: a
+ * conversation's, or the person's installed ones. Its models are listed as the registrations land.
+ */
+export declare function runtimeWithProviders(source: ModelRegistry | undefined): Promise<ModelRuntime>;

package/dist/installed-providers.js

@@ -0,0 +1,98 @@
+import { join } from "node:path";
+import { createAgentSessionServices, getAgentDir, ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
+/**
+ * The model providers the person's pi extensions register - a Claude subscription through Claude Code
+ * (pi-claude-code, `claude-code`), a company's own gateway - wherever turri needs a model and no conversation has them.
+ *
+ * In a chat, pi loads the person's installed pi packages itself, and turri's agents take the providers from the
+ * conversation's model registry (pi.ts `inheritProviders`). A command with no conversation - `turri regenerate`,
+ * `turri change-plain`, doctor's model check, init-config - has none: here they are loaded the way pi loads them, once a
+ * process, and only the providers they register are kept. turri's own extension, when an older turri installed it into
+ * every pi, is loaded as nothing meanwhile (`LOADING_PROVIDERS`): it would start a session of its own.
+ */
+/** Set while the person's extensions are loaded for their providers: turri's own extension does nothing then. */
+export const LOADING_PROVIDERS = "TURRI_LOADING_PROVIDERS";
+/**
+ * pi's own providers that come from an extension rather than with pi: what installs each, and how it is signed in to - for
+ * doctor and init-config to say when a config names one that is not there.
+ */
+export const EXTENSION_PROVIDERS = {
+    "claude-code": {
+        label: "Claude subscription (Claude Code)",
+        install: "pi install https://github.com/earendil-works/pi-claude-code",
+        signIn: "Claude Code installed (npm install -g @anthropic-ai/claude-code) and signed in to your Claude Pro or Max subscription: claude auth login",
+    },
+};
+const loaded = new Map();
+/**
+ * The providers the person's installed pi extensions register, for `cwd` - its project's pi settings with the person's
+ * own - loaded once. Undefined when none could be loaded: pi's built-in providers and models.json are what there is.
+ */
+export function installedProviders(cwd = process.cwd()) {
+    let found = loaded.get(cwd);
+    if (found === undefined) {
+        found = load(cwd);
+        loaded.set(cwd, found);
+    }
+    return found;
+}
+async function load(cwd) {
+    const before = process.env[LOADING_PROVIDERS];
+    process.env[LOADING_PROVIDERS] = "1";
+    try {
+        // Only the extensions: no skills, prompts, themes or context files are read for this.
+        const { modelRuntime } = await createAgentSessionServices({
+            cwd,
+            resourceLoaderOptions: { noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true },
+        });
+        const registry = new ModelRegistry(modelRuntime);
+        return registry.getRegisteredProviderIds().length > 0 ? registry : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (before === undefined)
+            delete process.env[LOADING_PROVIDERS];
+        else
+            process.env[LOADING_PROVIDERS] = before;
+    }
+}
+/**
+ * pi's model runtime as turri's agents have it with no conversation: pi's providers, models.json and auth.json, and the
+ * providers the person's installed pi extensions register - for a host that signs in or lists models before a chat is
+ * open, whose own `ModelRuntime.create()` would have none of an extension's (`claude-code`, say).
+ */
+export async function installedModelRuntime(cwd = process.cwd()) {
+    return runtimeWithProviders(await installedProviders(cwd));
+}
+/** For tests: forget what was loaded. */
+export function forgetInstalledProviders() {
+    loaded.clear();
+}
+/**
+ * pi's model runtime - its catalogue, models.json and its credentials - with `source`'s providers registered in it: a
+ * conversation's, or the person's installed ones. Its models are listed as the registrations land.
+ */
+export async function runtimeWithProviders(source) {
+    const agentDir = getAgentDir();
+    const runtime = await ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
+    if (source === undefined)
+        return runtime;
+    const registry = new ModelRegistry(runtime);
+    for (const id of source.getRegisteredProviderIds()) {
+        const native = source.getRegisteredNativeProvider(id);
+        const config = source.getRegisteredProviderConfig(id);
+        try {
+            if (native !== undefined)
+                registry.registerProvider(native);
+            else if (config !== undefined)
+                registry.registerProvider(id, config);
+        }
+        catch {
+            // One provider that will not register leaves the others, and pi's own, usable.
+        }
+    }
+    await runtime.refresh({ allowNetwork: false });
+    return runtime;
+}