GUI test rounds 2026-10-13: one blueprint grid, working folders, captain modes, Artifacts area (merge after Codex MERGE-FÄHIG + green CI, merge commit)

README.md

@@ -848,8 +848,11 @@ python -m nemofold serve --allow-root $PWD --base-dir $PWD
 ```
 
 Open `http://127.0.0.1:8765`; the label at the top reads `FULL LOCAL CONSOLE` (the
-demo below reads `PUBLIC DEMO · SYNTHETIC DATA ONLY`). The default example folder is the
-fictional case file `examples/synthetic-case`, with default questions in German. The
+demo below reads `PUBLIC DEMO · SYNTHETIC DATA ONLY`). The full console starts clean:
+no example folder and no example questions; it begins at your first working folder, or
+else at the first folder passed with `--allow-root`. The fictional case file
+`examples/synthetic-case` and its German questions belong to the public demo
+(`--allow-root examples/synthetic-case` opens the same case in the full console). The
 console uses the same strict job parser and
 application service as the CLI. It starts on loopback only, rejects cross-origin POSTs,
 and requires `--expose-network` before it will bind to a non-loopback address. Even
@@ -859,23 +862,26 @@ hosting for other people goes through `serve-demo`. Preview is the default safe
 action workflows additionally require the server-side `--approve-actions` gate before
 an apply request can succeed.
 
-The start page `/` is the **workbench**: the Captain's Desk on top and the engine room
-open below it (the first menu item is *Engine room*). The overview and four work areas use distinct, bookmarkable routes instead of in-page
-scroll jumps: `/`, `/folders`, `/processes`, `/governance` and `/connections`. Analysis,
-Routines and Artifacts used to be rooms of their own, which meant the door you came
-through decided what you could see. They are now three tabs of Processes & Workflows —
-`?tab=workflows` (My use cases), `?tab=registry` (Blueprints) and `?tab=artifacts`
-(the URL keys are unchanged). The old routes still lead
-somewhere: `/document-center`, `/analysis`, `/routines` and `/artifacts` redirect to
-their replacement, and a link that names one contract lands in the Blueprints tab with
-that contract selected.
-
-Vocabulary: an **action** is one step, i.e. one of the 44 job contracts (the API field
-is still `workflow`); a **workflow** is a chain of two or more actions; a **use case**
-is an action or workflow you adopted and bound to your own folders; **blueprints** are
-the templates. The Blueprints tab lists workflow blueprints (two or more steps),
-single-action blueprints, *My blueprints*, and below them all 44 actions, each with
-*Add to my use cases* and *Try once*. A blueprint can be adopted any number of times
+The start page `/` is the **workbench**: the Captain's Desk on top, the engine room
+open below it and the folded ship's chart at the end, nothing else (the first menu item
+is *Engine room*). The engine room shows its four areas - mission, bounded territory,
+authority and budget, reasoning worker - as separate tinted tiles. The overview and five work areas use distinct, bookmarkable routes instead of in-page
+scroll jumps: `/`, `/folders`, `/processes`, `/artifacts`, `/governance` and
+`/connections`. Analysis and Routines used to be rooms of their own, which meant the
+door you came through decided what you could see. They are now the two tabs of
+Processes & Workflows, `?tab=workflows` (My use cases) and `?tab=registry`
+(Blueprints); Artifacts is an area of its own. The old routes still lead somewhere:
+`/document-center`, `/analysis` and `/routines` redirect to their replacement,
+`/processes?tab=artifacts` to `/artifacts`, and a link that names one contract lands
+in the Blueprints tab with that contract selected.
+
+Vocabulary: everything you can run is a **workflow**, with one step or several; a step
+is one of the 44 job contracts (the API field is still `workflow`). A **use case** is a
+workflow you adopted and bound to your own folders; **blueprints** are the templates.
+The Blueprints tab shows every blueprint as an equal tile - the shipped presets, *My
+blueprints* and the 44 one-step workflows - filtered by the same topic chips as My use
+cases. Each tile offers *Add to my use cases*; a one-step workflow can also be tried
+once in the engine room. A blueprint can be adopted any number of times
 (copies are numbered) and renamed in the dialog; a use case can be saved as a blueprint
 of your own or removed with *Remove from my use cases*, which never touches its
 blueprint. Use-case details open as a dialog.
@@ -884,17 +890,48 @@ What stands in front changed, not the rooms. Use-case tiles are the primary obje
 filtered by topic tags, and a routine is simply a use case that carries a schedule and
 the derived `scheduled` tag — choosing that filter is what turns the porthole into the
 echo sounder: recent runs of the actions your routines use, manual runs of the same
-action included, since NemoFold does not tie a run to a schedule. The single actions, meaning the
-44 actions (job contracts) on their own, are listed in the Blueprints tab, with the
-engine room as their editor. Folders is the home of your folders: which ones are watched, what
-is actually on board, and the use cases bound to them. In the local console the folder
-dialog browses any folder on this computer and approves it for the current session
-(`/api/approve-root`); reading starts only after that approval. The public demo and a
-network-exposed server refuse it. Below the workbench the start page keeps one
-headline, one sentence and the area cards, and folds the boundary tiles, the evidence
-chain, the contract register and the roadmap behind an antique ship's chart that
-unfolds on click or Enter. Nothing is removed; documentation simply stops crowding the
-surface.
+action included, since NemoFold does not tie a run to a schedule. The one-step
+workflows sit among the blueprints, with the engine room as their editor.
+
+Folders is the home of your **working folders**: you add them once and they stay
+approved at every later start of this loopback console
+(`run-reports/web-console/working-folders.json`, `/api/working-folders`). The captain
+and the engine room offer them as one-click chips, the captain takes several folders,
+and a request that names exactly one working folder ("Summarize the documents in
+Taxes") runs on that folder. Folders also shows what is actually on board and *Your
+folder workflows*. In the local console the folder dialog browses any folder on this
+computer, takes a typed or pasted path, or opens the system folder dialog of this
+computer (`/api/pick-folder`); approving a folder for the session
+(`/api/approve-root`) or keeping it as a working folder is always an explicit click,
+and reading starts only after it. The public demo and a network-exposed server refuse
+all of these, and a network-exposed server never loads working folders. The ship's
+chart at the end of the start page folds the boundary tiles, the evidence chain, the
+area map and the roadmap; it unfolds on click or Enter.
+
+The captain plans in one of three modes, chosen per request. *Keywords* (the default)
+is a local, deterministic match of task words; a document request without one falls
+back to Evidence Analyst with the sentence itself as the question. *A model chooses*
+lets a reasoning worker read the sentence and the workflow catalogue - never a
+document - and pick up to six workflows; the choice is checked against the catalogue
+and the plan is built exactly as for keywords. A local Ollama or LM Studio model needs
+no approval; an external provider needs `--allow-external-models` and an approval for
+that one request, and receives the sentence pseudonymized. *Brief for a CLI agent*
+copies a prompt with the folders, the catalogue, the job format, the commands and the
+rules to the clipboard, for an agent such as Claude Code or Codex. A plan can be
+prepared as drafts in the job inbox (engine room, *Run identity & prepared jobs*) or
+run at once: *Run all steps* keeps it as one of My use cases and runs its steps one
+after another, locally and as a dry run.
+
+The model field of a local provider offers the models that server actually holds;
+models it only relays to a cloud (`:cloud`) are not offered and are refused as a local
+model, so "loopback, local only" stays true. Some local builds cannot force a JSON
+answer; the adapter then asks once more with the schema as an instruction. The
+research notebook sits under the engine room as the quick investigation mode and
+ships as one of My use cases. Artifacts lists every run ledger below the output scope,
+failed and blocked runs included, with the date and time it was written. Connections
+shows what this computer shows per adapter - local server running, CLI found, key
+variable set, never a key value - and names the 2026-09-02 proof run as the only
+Nemotron proof.
 
 Governance renders the authority this server was started with — the file-action,
 external-model and network gates, approved roots, budget ceiling and contracted

README_de.md

@@ -869,8 +869,12 @@ python -m nemofold serve --allow-root $PWD --base-dir $PWD
 ```
 
 Öffne `http://127.0.0.1:8765`; das Etikett oben lautet `FULL LOCAL CONSOLE` (die Demo
-unten: `PUBLIC DEMO · SYNTHETIC DATA ONLY`). Der Standard-Beispielordner ist die
-fiktive Fallakte `examples/synthetic-case` mit deutschen Standardfragen. Die Konsole
+unten: `PUBLIC DEMO · SYNTHETIC DATA ONLY`). Die Vollversion startet sauber: kein
+Beispielordner und keine Beispielfragen; sie beginnt bei deinem ersten Arbeitsordner,
+sonst beim ersten mit `--allow-root` übergebenen Ordner. Die fiktive Fallakte
+`examples/synthetic-case` mit ihren deutschen Fragen gehört zur Public Demo
+(`--allow-root examples/synthetic-case` öffnet denselben Fall auch in der Vollversion).
+Die Konsole
 verwendet denselben strikten Auftragsparser
 und Anwendungsdienst wie die CLI. Sie bindet nur an Loopback, lehnt Cross-Origin-POSTs
 ab und verlangt `--expose-network`, bevor sie eine Nicht-Loopback-Adresse verwendet.
@@ -881,23 +885,28 @@ sichere Pfad; Aktionsworkflows benötigen zusätzlich das serverseitige Gate
 `--approve-actions`, bevor eine Apply-Anfrage erfolgreich sein kann.
 
 Die Startseite `/` ist die **Werkbank**: oben das Captain's Desk, darunter der
-geöffnete Maschinenraum (erster Menüpunkt: *Engine room*). Übersicht und vier
+geöffnete Maschinenraum und am Ende die gefaltete Seekarte, sonst nichts (erster
+Menüpunkt: *Engine room*). Der Maschinenraum zeigt seine vier Bereiche - Mission,
+Bounded territory, Authority and budget, Reasoning worker - als getrennte, farbig
+hinterlegte Kacheln. Übersicht und fünf
 Arbeitsbereiche besitzen eigene, direkt aufrufbare Routen statt
-Sprüngen innerhalb einer langen Seite: `/`, `/folders`, `/processes`, `/governance` und
-`/connections`. Analysis, Routines und Artifacts waren einmal eigene Räume — damit
-entschied die Tür, durch die man kam, darüber, was man sehen konnte. Sie sind jetzt drei
-Untertabs von Processes & Workflows: `?tab=workflows` (My use cases), `?tab=registry`
-(Blueprints) und `?tab=artifacts` (die URL-Schlüssel sind unverändert). Die alten Routen führen weiterhin irgendwohin: `/document-center`,
-`/analysis`, `/routines` und `/artifacts` leiten auf ihren Nachfolger um, und ein Link,
+Sprüngen innerhalb einer langen Seite: `/`, `/folders`, `/processes`, `/artifacts`,
+`/governance` und `/connections`. Analysis und Routines waren einmal eigene Räume —
+damit entschied die Tür, durch die man kam, darüber, was man sehen konnte. Sie sind
+jetzt die beiden Untertabs von Processes & Workflows, `?tab=workflows` (My use cases)
+und `?tab=registry` (Blueprints); Artifacts ist ein eigener Bereich. Die alten Routen
+führen weiterhin irgendwohin: `/document-center`, `/analysis` und `/routines` leiten
+auf ihren Nachfolger um, `/processes?tab=artifacts` auf `/artifacts`, und ein Link,
 der einen einzelnen Vertrag nennt, landet im Reiter Blueprints mit genau diesem Vertrag.
 
-Begriffe: Eine **Action** ist ein Schritt, also einer der 44 Jobverträge (das API-Feld
-heißt weiterhin `workflow`); ein **Workflow** ist eine Kette aus zwei oder mehr
-Actions; ein **Usecase** ist eine übernommene, an Ihre eigenen Ordner gebundene Action
-oder ein ebensolcher Workflow; **Blueprints** sind die Vorlagen. Der Reiter Blueprints
-listet Workflow-Blueprints (zwei oder mehr Schritte), Single-Action-Blueprints,
-*My blueprints* und darunter alle 44 Actions, jeweils mit *Add to my use cases* und
-*Try once*. Ein Blueprint lässt sich beliebig oft übernehmen (Kopien werden
+Begriffe: Alles, was sich ausführen lässt, ist ein **Workflow**, mit einem Schritt oder
+mehreren; ein Schritt ist einer der 44 Jobverträge (das API-Feld heißt weiterhin
+`workflow`). Ein **Usecase** ist ein übernommener, an deine eigenen Ordner gebundener
+Workflow; **Blueprints** sind die Vorlagen. Der Reiter Blueprints zeigt jeden Blueprint
+als gleichberechtigte Kachel - die mitgelieferten Presets, *My blueprints* und die 44
+einschrittigen Workflows -, gefiltert mit denselben Themen-Chips wie My use cases. Jede
+Kachel bietet *Add to my use cases*; ein einschrittiger Workflow lässt sich zusätzlich
+einmal im Maschinenraum ausprobieren. Ein Blueprint lässt sich beliebig oft übernehmen (Kopien werden
 nummeriert) und im Dialog umbenennen; ein Usecase lässt sich als eigener Blueprint
 speichern oder mit *Remove from my use cases* entfernen, was den Blueprint nie
 berührt. Usecase-Details öffnen als Dialog.
@@ -906,17 +915,49 @@ Verändert hat sich, was vorn steht, nicht die Räume. Usecase-Kacheln sind das
 Primärobjekt, thematisch über Tags filterbar, und eine Routine ist schlicht ein Usecase
 mit Zeitplan und dem abgeleiteten Tag `scheduled` — dieser Filter macht aus dem Bullauge
 das Echolot: die letzten Läufe der Actions, die deine Routinen nutzen, manuelle Läufe
-derselben Action eingeschlossen, denn NemoFold ordnet einen Lauf keinem Zeitplan zu. Die einzelnen Actions, also die
-44 Actions (Jobverträge) für sich, stehen im Reiter Blueprints, dessen Editor
-der Maschinenraum ist. Folders ist das Zuhause der Ordner: welche überwacht werden, was
-tatsächlich an Bord ist, und welche Usecases daran hängen. In der lokalen Konsole
-durchsucht der Ordnerdialog jeden Ordner dieses Rechners und gibt ihn für die laufende
-Sitzung frei (`/api/approve-root`); gelesen wird erst nach dieser Freigabe. Die
-Public Demo und ein netzfreigegebener Server verweigern das. Unter der Werkbank behält die
-Startseite eine Überschrift, einen Satz und die Bereichskarten und faltet Grenz-Kacheln,
-Evidenzkette, Vertragsregister und Roadmap hinter eine alte Seekarte, die sich per Klick
-oder Enter aufklappt. Nichts wird entfernt; die Dokumentation verschmutzt nur nicht mehr
-die Oberfläche.
+derselben Action eingeschlossen, denn NemoFold ordnet einen Lauf keinem Zeitplan zu.
+Die einschrittigen Workflows stehen zwischen den Blueprints, ihr Editor ist der
+Maschinenraum.
+
+Folders ist das Zuhause deiner **Arbeitsordner**: Du legst sie einmal an, und sie
+bleiben bei jedem späteren Start dieser Loopback-Konsole freigegeben
+(`run-reports/web-console/working-folders.json`, `/api/working-folders`). Captain und
+Maschinenraum bieten sie als Chips mit einem Klick an, der Captain nimmt mehrere Ordner,
+und eine Anfrage, die genau einen Arbeitsordner beim Namen nennt („Fasse mir die
+Dokumente im Ordner Steuer zusammen“), läuft auf diesem Ordner. Folders zeigt außerdem,
+was tatsächlich an Bord ist, und *Your folder workflows*. In der lokalen Konsole
+durchsucht der Ordnerdialog jeden Ordner dieses Rechners, nimmt einen eingetippten oder
+eingefügten Pfad an oder öffnet den Ordnerdialog des Systems (`/api/pick-folder`); die
+Freigabe für die Sitzung (`/api/approve-root`) oder das Behalten als Arbeitsordner ist
+immer ein eigener Klick, und gelesen wird erst danach. Die Public Demo und ein
+netzfreigegebener Server verweigern all das, und ein netzfreigegebener Server lädt nie
+Arbeitsordner. Die Seekarte am Ende der Startseite faltet Grenz-Kacheln, Evidenzkette,
+Bereichskarte und Roadmap; sie klappt per Klick oder Enter auf.
+
+Der Captain plant in einem von drei Modi, je Anfrage wählbar. *Keywords* (Standard)
+ist ein lokaler, deterministischer Abgleich von Aufgabenwörtern; eine Dokumentanfrage
+ohne ein solches Wort fällt auf Evidence Analyst zurück, mit dem Satz selbst als Frage.
+Bei *A model chooses* liest ein Reasoning-Worker den Satz und den Workflow-Katalog - nie
+ein Dokument - und wählt bis zu sechs Workflows; die Wahl wird gegen den Katalog geprüft,
+und der Plan entsteht genau wie bei Keywords. Ein lokales Ollama- oder LM-Studio-Modell
+braucht keine Freigabe; ein externer Anbieter braucht `--allow-external-models` und eine
+Freigabe für genau diese Anfrage und erhält den Satz pseudonymisiert. *Brief for a CLI
+agent* kopiert einen Auftrag mit Ordnern, Katalog, Jobformat, Befehlen und Regeln in die
+Zwischenablage, für einen Agenten wie Claude Code oder Codex. Ein Plan lässt sich als
+Entwürfe in die Job-Inbox legen (Maschinenraum, *Run identity & prepared jobs*) oder
+sofort ausführen: *Run all steps* behält ihn als einen deiner Usecases und führt die
+Schritte nacheinander aus, lokal und als Trockenlauf.
+
+Das Modellfeld eines lokalen Anbieters bietet die Modelle an, die dieser Server
+tatsächlich hat; Modelle, die er nur an eine Cloud weiterreicht (`:cloud`), werden nicht
+angeboten und als lokales Modell abgelehnt, damit „loopback, local only“ stimmt.
+Manche lokalen Builds können keine JSON-Antwort erzwingen; der Adapter fragt dann einmal
+mit dem Schema als Anweisung nach. Das Research Notebook steht als schneller
+Untersuchungsmodus unter dem Maschinenraum und ist ab Auslieferung einer deiner
+Usecases. Artifacts listet jeden Lauf-Ledger unterhalb des Ausgabebereichs, auch
+fehlgeschlagene und blockierte Läufe, mit Datum und Uhrzeit. Connections zeigt je Adapter,
+was dieser Rechner zeigt - lokaler Server läuft, CLI gefunden, Schlüsselvariable gesetzt,
+nie ein Schlüsselwert - und nennt den Lauf vom 2026-09-02 als einzigen Nemotron-Beleg.
 
 Governance zeigt die Autorität, mit der dieser Server gestartet wurde — Gates für
 Dateiaktionen, externe Modelle und Netzexposition, freigegebene Roots, Budgetgrenze und

llms.txt

@@ -28,9 +28,13 @@ Primary documentation:
 
 Current local implementation boundary:
 - Forty-four workflow contracts share the strict job service.
-- Console vocabulary: an action is one of the 44 job contracts (API field `workflow`); a
-  workflow is a chain of two or more actions; a use case is an action or workflow adopted
-  from a blueprint and bound to your own folders. The start page is the workbench.
+- Console vocabulary: everything runnable is a workflow with one step or several; a step
+  is one of the 44 job contracts (API field `workflow`); a use case is a workflow adopted
+  from a blueprint and bound to your own folders. The start page is the workbench
+  (captain, engine room, research notebook, folded chart); working folders stay approved
+  across restarts of the loopback console; the full console starts without the demo case.
+  The captain plans by keywords, lets a model choose from the catalogue (sentence and
+  catalogue only), or copies a brief for a CLI agent; Artifacts is its own area.
 - Nemotron on Nebius Token Factory is selectable in the local console (provider `nebius`,
   key only from `NEBIUS_API_KEY`, server started with `--allow-external-models
   --max-external-cost-usd <n>`, per-run approval). A console run is not competition proof;