portable-agent-layer 0.109.0 → 0.111.0

package/README.md

@@ -90,7 +90,7 @@ pal cli status        # check your setup
 | `pal cli patterns` | How you work across projects, read from the event log |
 | `pal cli content preserve` | Copy every Claude Code transcript, gzipped, into `memory/content/` before Claude Code deletes it (30 days by default). Runs on its own whenever a session closes; the content store never leaves the machine, so `export` skips it |
 | `pal cli events discord-nag <sent\|answered>` | For a bot outside PAL: record a nag it sent (`--kind <kind>`), or the answer to one and how long it took (`--after-sec <n>`), in the local event log |
-| `pal cli infer` | One model call for scripts and bots, on the active agent's route: prompt on stdin, reply on stdout. `--tier small\|medium`, `--system <file>`, `--schema <file>` for a JSON reply checked against it, `--timeout <seconds>`. The call loads no PAL hooks or context; exits 1 with the reason when no route answers |
+| `pal cli infer` | One model call for scripts and bots, on the active agent's route: prompt on stdin, reply on stdout. `--tier small\|medium\|large\|flagship` (on Claude: Haiku, Sonnet, Opus, Fable; on Codex: Luna, Sol, Sol at high effort, Astra; on Antigravity: Flash at low, medium and high effort, and no flagship; an agent without the tier asked refuses it), `--system <file>`, `--schema <file>` for a JSON reply checked against it, `--timeout <seconds>`. The call loads no PAL hooks or context; exits 1 with the reason when no route answers |
 | `pal cli actor [label <name>]` | Show or rename the actor — who caused a record. Travels with an export, so a shared memory can tell two people apart |
 | `pal cli machine [label <name>]` | Show or rename this install — where a record was written. Never leaves the machine |
 | `pal cli telos` | Which TELOS topics are answered, in interview order, and which one comes next |

package/assets/skills/research-entity/SKILL.md

@@ -23,6 +23,7 @@ Research the company or person named in $ARGUMENTS and show a sourced profile. T
 1. Work out from $ARGUMENTS and the conversation:
    - the exact name;
    - whether it is a company or a person;
+   - for a company, its registered name with the legal form, not a brand or short name. The legal form is what routes it to its country's company register;
    - for a person, where they work;
    - one sentence of what the user said about them.
    If you cannot tell a company from a person, ask.
@@ -34,6 +35,11 @@ Research the company or person named in $ARGUMENTS and show a sourced profile. T
    ```bash
    pal cli knowledge research "<name>" --person --organization "<employer>" --context "<what the user said>"
    ```
+   When the legal form places the company in a country PAL has a register for, the command first reads that register directly, because web search does not index it. An exact registered-name match fills in the registration number, tax number, seat, main activity, managing directors and status, and the profile is kept even when the web finds nothing else. A brand name, a similar name, or a company from a country without a register goes through web search alone.
+
+   | Country | Legal forms | Register read |
+   | ------- | ----------- | ------------- |
+   | Hungary | Kft., Zrt., Nyrt., Bt., Kkt., or spelled out | ceginfo.hu for the registration number, nemzeticegtar.hu for the record |
    It takes one to several minutes. Add `--queue` when the user wants the profile saved; it then waits in the review queue.
 3. If the command exits 1, tell the user the reason it printed. Usual reasons:
    - the model found only namesakes (`match: unsure`): ask for something that tells them apart, such as an employer, a city or a website, and run it again with that in `--context` or `--organization`;

package/assets/skills/scientific-research/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: scientific-research
 license: MIT
-description: "Answers scientific questions from trustworthy primary sources only (PubMed-indexed peer-reviewed literature, clinical guidelines from ERC, ESC, AHA, CDC and specialty societies, NEJM, The Lancet, JAMA, BMJ, UpToDate when accessible), with every claim cited to a source that was actually read, graded by evidence level and year, and cross-checked by a verifier agent. Use for EVERY health, medical, nutrition, drug, supplement, symptom, disease, treatment, diagnosis, exercise-physiology or other empirical scientific question, including 'is it safe to', 'does X work', 'what does the evidence say', 'side effects of', 'how much should I take' and 'what do the guidelines recommend'. Never answer such questions from memory; route them here."
+description: "Answers scientific questions from trustworthy primary sources only (PubMed-indexed peer-reviewed literature, clinical guidelines from ERC, ESC, AHA, CDC and specialty societies, NEJM, The Lancet, JAMA, BMJ, UpToDate when accessible), with every claim cited to a source that was actually read, graded by evidence level and year, its funding and any vendor ties named, and cross-checked by a verifier agent. Excludes preprints and MDPI journals and prefers SJR Q1 journals. Use for EVERY health, medical, nutrition, drug, supplement, symptom, disease, treatment, diagnosis, exercise-physiology or other empirical scientific question, including 'is it safe to', 'does X work', 'what does the evidence say', 'side effects of', 'how much should I take' and 'what do the guidelines recommend'. Never answer such questions from memory; route them here."
 argument-hint: <scientific or health question>
 metadata:
   source: portable-agent-layer
@@ -57,9 +57,26 @@ specialty society (WHO, NICE, EMA, FDA and their peers). Label each such
 source in the answer as "outside the core list".
 
 Not sources, under any circumstances: blogs, news sites, forums, supplement or
-vendor sites, encyclopedias, press releases, lecture slides, model memory. Preprints
-may be mentioned only when the answer labels them "preprint, not peer-reviewed" and
-no peer-reviewed source covers the claim.
+vendor sites, encyclopedias, press releases, lecture slides, model memory.
+
+Excluded even when they look peer-reviewed:
+
+- **Preprints and repositories**: bioRxiv, medRxiv, PsyArXiv, arXiv, SSRN, Research
+  Square, OSF Preprints, Preprints.org and any other server of unreviewed
+  manuscripts. Do not search them. PubMed and Europe PMC also index preprints, so
+  add `NOT preprint[pt]` to PubMed queries and drop any record whose publication type
+  is Preprint.
+- **MDPI journals** (Nutrients, Medicina, IJMS, Healthcare and the rest), identified
+  by publisher, not by title: a DOI starting with `10.3390` or a page on `mdpi.com`.
+  Add `-site:mdpi.com` to web searches.
+
+### Journal rank
+
+Prefer journals ranked Q1 by SCImago (SJR, `scimagojr.com`) in the subject category
+that fits the question. Rank breaks ties within one evidence level and never
+outranks study design: a Q2 RCT beats a Q1 observational study. Cite a journal below
+Q1 only when no Q1 source covers the claim, and label it with its quartile, for
+example "SJR Q2". Guidelines and official bodies are not ranked.
 
 ## Citation and evidence rules
 
@@ -74,12 +91,23 @@ For every claim record and later print:
   review.
 - **Year** of publication or of the guideline edition, so stale evidence is visible.
   When a newer edition of a guideline exists, cite the newer one.
+- **Journal quartile**: the SJR quartile of the journal, for every journal article.
+- **Funding and conflicts of interest**, read from the source's Funding, Acknowledgements
+  and Competing Interests sections, never inferred. Name the funders, then add one label:
+  - **vendor-funded**: a funder sells the product or intervention studied, or is a
+    trade group of its sellers (manufacturer, supplement brand, food or drug industry
+    association).
+  - **vendor-linked authors**: the funding is independent, but an author is employed,
+    paid or holds shares in such a company.
+  - **funding not stated**: the opened source has no funding statement.
+  - **funding not accessible**: the statement sits behind a paywall that did not open.
 
 Apply these tests before keeping a claim:
 
 1. Does the opened source state this claim, in this population, at this dose or in
    this setting? Paraphrase the source, do not extrapolate from it.
-2. Does the source belong to the allowed set? If not, discard the claim.
+2. Does the source belong to the allowed set, and is it neither a preprint nor an MDPI
+   journal? If not, discard the claim.
 3. Is the number or direction of effect quoted exactly as the source gives it
    (effect size, confidence interval, absolute versus relative risk)?
 
@@ -144,12 +172,20 @@ Rules:
 - Search only your lane's domains (use site: restricted queries). Open each
   candidate and read the relevant section before using it.
 - Prefer the newest guideline edition, then systematic reviews and meta-analyses,
-  then RCTs, then observational work.
+  then RCTs, then observational work. Within one level, prefer journals ranked SJR
+  Q1 in the question's subject category.
+- Never search or cite preprint servers (bioRxiv, medRxiv, PsyArXiv, arXiv, SSRN,
+  Research Square, OSF Preprints, Preprints.org). Add NOT preprint[pt] to PubMed
+  queries and drop any record typed Preprint.
+- Never cite an MDPI journal: a DOI starting with 10.3390 or a page on mdpi.com. Add
+  -site:mdpi.com to web searches.
 - For each claim return: the claim in one sentence, quoted as the source states it;
   population and setting; effect size with confidence interval when given; evidence
   level (guideline recommendation with class/level or GRADE, meta-analysis, RCT,
   observational, expert opinion); year; full citation (authors or body, title,
-  journal or body, year, PMID or DOI or URL).
+  journal or body, year, PMID or DOI or URL); the journal's SJR quartile; funding:
+  the funders named in the source and one label, vendor-funded, vendor-linked
+  authors, funding not stated or funding not accessible.
 - Lane D only: if UpToDate does not open or shows a paywall, return the single line
   "UpToDate inaccessible" and nothing else.
 - Do not fill gaps from memory. If your lane has nothing on a sub-question, say
@@ -180,8 +216,15 @@ For every claim:
    numbers. Mark "confirmed" or "could not verify: <what differs>".
 3. Confirm the source is in the allowed set: PubMed-indexed peer-reviewed journal,
    ERC/ESC/AHA/CDC or another official health body or specialty society, NEJM, The
-   Lancet, JAMA, BMJ, or UpToDate. Otherwise mark "could not verify: source not
-   allowed".
+   Lancet, JAMA, BMJ, or UpToDate. A preprint, a record typed Preprint in PubMed, or
+   an MDPI journal (DOI starting with 10.3390) is never allowed. Otherwise mark
+   "could not verify: source not allowed".
+4. Check the journal's SJR quartile on scimagojr.com and correct it when the lane
+   got it wrong.
+5. Open the source's Funding and Competing Interests sections and confirm the
+   funders and the label (vendor-funded, vendor-linked authors, funding not stated,
+   funding not accessible). Correct the label when it differs, and flag every
+   vendor-funded or vendor-linked study.
 
 Then return three sections:
 - Confirmed matches: claims supported by two or more independent sources, with
@@ -203,8 +246,10 @@ Then:
 1. **Bottom line** — two to four sentences answering the question directly, with
    citation numbers.
 2. **Key findings** — one bullet per claim: the claim, inline citation number(s)
-   `[n]`, evidence level, year. Group by sub-question when there are several. Mark
-   any source outside the core list.
+   `[n]`, evidence level, year, funding label. Write **vendor-funded** or
+   **vendor-linked authors** in bold and name the company. Group by sub-question
+   when there are several. Mark any source outside the core list and any journal
+   below SJR Q1 with its quartile.
 3. **Agreement and contradictions** — the verifier's confirmed matches and
    contradictions, each contradiction with who says what and the likely reason.
 4. **What is uncertain / not found** — sub-questions with no trustworthy evidence
@@ -214,7 +259,8 @@ Then:
 5. **Method** — one line: parallel subagents or sequential lanes; UpToDate read or
    inaccessible; number of sources opened.
 6. **References** — numbered list matching the inline numbers: authors or body,
-   title, journal or body, year, PMID or DOI or URL.
+   title, journal or body, year, PMID or DOI or URL, SJR quartile, and funding (the
+   funders and the label).
 
 For a question about the user's own health, add exactly one plain sentence after the
 Bottom line: this is a summary of published evidence, not individual medical advice,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.109.0",
+  "version": "0.111.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/cli/infer.ts

@@ -136,7 +136,7 @@ export const inferCommand = leaf({
     tier: {
       type: "string",
       value: "<tier>",
-      description: `Model size: ${INFERENCE_TIERS.join(" or ")} (default small)`,
+      description: `Model size: ${INFERENCE_TIERS.join(", ")} (default small)`,
     },
     system: { type: "string", value: "<file>", description: "System prompt file" },
     schema: {

package/src/cli/knowledge-research.ts

@@ -3,6 +3,7 @@
  * the active agent, print the profile, and optionally queue it for review.
  */
 
+import { lookupCompanyRegister } from "../hooks/lib/company-register-router";
 import { loadKnownEntities, loadNameIndex } from "../hooks/lib/entity-cards";
 import { queueForReview } from "../hooks/lib/entity-extraction";
 import { lookupName } from "../hooks/lib/entity-names";
@@ -46,7 +47,11 @@ function targetFrom(name: string, values: ResearchValues): ResearchTarget {
 export async function researchFromCli(
   name: string | undefined,
   values: ResearchValues,
-  deps: ResearchDeps = { principal: identity().principal.name, infer: inference }
+  deps: ResearchDeps = {
+    principal: identity().principal.name,
+    infer: inference,
+    registry: lookupCompanyRegister,
+  }
 ): Promise<number> {
   if (!name?.trim()) throw new UsageError("name the person or company to research");
   const target = targetFrom(name.trim(), values);

package/src/hooks/handlers/entity-extraction.ts

@@ -6,6 +6,7 @@
  */
 
 import { ingestEntities } from "../../tools/knowledge/ingest";
+import { lookupCompanyRegister } from "../lib/company-register-router";
 import { excludedNames, loadKnownEntities, loadNameIndex } from "../lib/entity-cards";
 import {
   extractionSchema,
@@ -69,6 +70,7 @@ export async function extractSessionEntities(
     await researchNewEntities(newResearchTargets(plan.ingest, written), {
       principal: id.principal.name,
       infer: inference,
+      registry: lookupCompanyRegister,
     });
 }
 

package/src/hooks/lib/company-register-router.ts

@@ -0,0 +1,24 @@
+/**
+ * Official company registers, routed by country. A company is looked up only in the
+ * register of the country its name places it in; any other name goes to web search
+ * alone. To add a country, implement CompanyRegister in its own module and add it to
+ * REGISTERS.
+ */
+
+import type { CompanyRegister, Fetch, RegisterEntry } from "./company-register";
+import { hungarianRegister } from "./hungarian-registry";
+
+const REGISTERS: CompanyRegister[] = [hungarianRegister];
+
+/** Null when no register recognizes the name, and when its register has no exact match. */
+export async function lookupCompanyRegister(
+  name: string,
+  fetchImpl: Fetch = fetch,
+  registers: CompanyRegister[] = REGISTERS
+): Promise<RegisterEntry | null> {
+  const wanted = name.trim();
+  const register = registers.find((r) => r.recognizes(wanted));
+  if (!register) return null;
+  const company = await register.lookup(wanted, fetchImpl);
+  return company && { ...company, country: register.country };
+}

package/src/hooks/lib/company-register.ts

@@ -0,0 +1,25 @@
+/** What a country's company register implements to join the routing table in company-register-router.ts. */
+
+export interface RegisteredCompany {
+  name: string;
+  fullName: string;
+  number: string;
+  taxNumber: string;
+  seat: string;
+  status: string;
+  activity: string;
+  founded: string;
+  managers: string[];
+  url: string;
+  sources: string[];
+}
+
+export type RegisterEntry = RegisteredCompany & { country: string };
+
+export type Fetch = (input: string, init?: RequestInit) => Promise<Response>;
+
+export interface CompanyRegister {
+  country: string;
+  recognizes: (name: string) => boolean;
+  lookup: (name: string, fetchImpl: Fetch) => Promise<RegisteredCompany | null>;
+}

package/src/hooks/lib/entity-extraction.ts

@@ -49,6 +49,7 @@ export interface ResearchProfile {
     taxNumber: string;
     seat: string;
     status: string;
+    activity: string;
     managers: string[];
     url: string;
   };

package/src/hooks/lib/entity-research.ts

@@ -5,6 +5,7 @@
  */
 
 import type { IngestInput, IngestResult } from "../../tools/knowledge/ingest";
+import type { RegisterEntry } from "./company-register";
 import {
   closedObject,
   type ExtractedEntity,
@@ -27,6 +28,7 @@ export interface ResearchDeps {
   principal: string;
   infer: typeof inference;
   today?: string;
+  registry?: (name: string) => Promise<RegisterEntry | null>;
 }
 
 const MAX_TARGETS = 3;
@@ -83,6 +85,7 @@ export function researchSchema() {
       taxNumber: text,
       seat: text,
       status: text,
+      activity: text,
       managers: list(text),
       url: text,
     }),
@@ -96,7 +99,7 @@ const CHECKLIST = {
     "- website: the official website.",
     "- linkedin: the LinkedIn company page.",
     "- socials: other official accounts (X, Facebook, Instagram, YouTube, GitHub).",
-    "- registry: its entry in the official company register of its country: registered name, registration number, tax number, registered seat, status (active, in liquidation…), managing directors, and the URL you read it on. For a Hungarian company (Kft., Zrt., Bt., Nyrt., a .hu site) that is the cégjegyzék: e-cegjegyzek.hu, or public mirrors such as ceginformacio.hu, nemzeticegtar.hu or opten.hu.",
+    "- registry: its entry in the official company register of its country: registered name, registration number, tax number, registered seat, status (active, in liquidation…), main activity, managing directors, and the URL you read it on. For a Hungarian company (Kft., Zrt., Bt., Nyrt., a .hu site) that is the cégjegyzék: e-cegjegyzek.hu, or public mirrors such as ceginformacio.hu, nemzeticegtar.hu or opten.hu.",
     "- news: up to five news items or public statements from the last 12 months, newest first.",
     "- summary: two or three sentences on what the company does, its size and where it is based.",
   ],
@@ -124,13 +127,30 @@ export function researchSystem(principal: string, kind: ResearchTarget["kind"]):
   ].join("\n");
 }
 
-function researchUser(target: ResearchTarget, today: string): string {
+function registryFacts(entry: RegisterEntry): string {
+  return [
+    "The company register, already read: use it to tell this company from namesakes and do not search the register again.",
+    `registered name: ${entry.fullName || entry.name}`,
+    `registration number: ${entry.number}`,
+    entry.seat && `seat: ${entry.seat}`,
+    entry.activity && `main activity: ${entry.activity}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function researchUser(
+  target: ResearchTarget,
+  today: string,
+  registry: RegisterEntry | null
+): string {
   return [
     `Today is ${today}.`,
     `${target.kind}: ${target.name}`,
     target.organization && `organization: ${target.organization}`,
     target.fact &&
       `what ${target.kind === "person" ? "was said about them" : "was said about it"}: ${target.fact}`,
+    registry && registryFacts(registry),
   ]
     .filter(Boolean)
     .join("\n");
@@ -166,13 +186,76 @@ export type ResearchOutcome =
   | { found: true; profile: ResearchProfile }
   | { found: false; reason: string };
 
+async function registryEntry(
+  target: ResearchTarget,
+  deps: ResearchDeps
+): Promise<RegisterEntry | null> {
+  if (target.kind !== "company" || !deps.registry) return null;
+  try {
+    return await deps.registry(target.name);
+  } catch (err) {
+    logError(`entity-research:registry:${target.name}`, err);
+    return null;
+  }
+}
+
+function registryOnlyProfile(entry: RegisterEntry): ResearchProfile {
+  const founded = entry.founded ? `, founded ${entry.founded}` : "";
+  const what = entry.activity || `company registered in ${entry.country}`;
+  return {
+    match: "sure",
+    summary: `${entry.name}: ${what}. Seat: ${entry.seat}${founded}.`,
+    role: "",
+    organization: "",
+    website: "",
+    linkedin: "",
+    socials: [],
+    registry: registryOf(entry),
+    news: [],
+    sources: [],
+  };
+}
+
+function registryOf(entry: RegisterEntry): ResearchProfile["registry"] {
+  return {
+    name: entry.fullName || entry.name,
+    number: entry.number,
+    taxNumber: entry.taxNumber,
+    seat: entry.seat,
+    status: entry.status,
+    activity: entry.activity,
+    managers: entry.managers,
+    url: entry.url,
+  };
+}
+
+/** What the register says replaces what the model read, and an exact register match is
+ *  enough to keep the profile even when the web turned up nothing. */
+function withRegistry(
+  profile: ResearchProfile | null,
+  entry: RegisterEntry
+): ResearchProfile {
+  const base =
+    profile?.match === "sure" ? withWebUrlsOnly(profile) : registryOnlyProfile(entry);
+  return {
+    ...base,
+    registry: registryOf(entry),
+    sources: [...new Set([...entry.sources, ...base.sources])],
+  };
+}
+
 export async function researchEntity(
   target: ResearchTarget,
   deps: ResearchDeps
 ): Promise<ResearchOutcome> {
+  const registry = await registryEntry(target, deps);
   const result = await deps.infer({
     system: researchSystem(deps.principal, target.kind),
-    user: researchUser(target, deps.today ?? new Date().toISOString().slice(0, 10)),
+    user: researchUser(
+      target,
+      deps.today ?? new Date().toISOString().slice(0, 10),
+      registry
+    ),
     tier: "medium",
     timeout: RESEARCH_TIMEOUT_MS,
     jsonSchema: researchSchema(),
@@ -180,6 +263,7 @@ export async function researchEntity(
     web: true,
   });
   const profile = result.success ? parseProfile(result.output) : null;
+  if (registry) return { found: true, profile: withRegistry(profile, registry) };
   if (!profile) return { found: false, reason: result.error ?? "no usable reply" };
   if (profile.match !== "sure")
     return { found: false, reason: `match: ${profile.match}. ${profile.summary}`.trim() };
@@ -243,6 +327,7 @@ function registryLines(r: ResearchProfile["registry"]): string[] {
     ["Tax number", r.taxNumber],
     ["Seat", r.seat],
     ["Status", r.status],
+    ["Main activity", r.activity],
     ["Managing directors", r.managers.join(", ")],
     ["Registry entry", r.url],
   ];

package/src/hooks/lib/hungarian-registry.ts

@@ -0,0 +1,194 @@
+/**
+ * The Hungarian company register, read directly. Web search does not index it, so a
+ * young or small Kft. is invisible to a search-only lookup. Only a name ending in a
+ * Hungarian legal form is recognized: ceginfo.hu resolves the exact name to its
+ * registration number, nemzeticegtar.hu shows the record for free.
+ */
+
+import type { CompanyRegister, Fetch, RegisteredCompany } from "./company-register";
+
+interface Page {
+  url: string;
+  html: string;
+}
+
+const CEGINFO = "https://ceginfo.hu/";
+const NEMZETICEGTAR = "https://www.nemzeticegtar.hu/";
+const USER_AGENT = "Mozilla/5.0 (compatible; PAL knowledge research)";
+const REQUEST_TIMEOUT_MS = 15_000;
+const MAX_REDIRECTS = 5;
+const REDIRECTS = new Set([301, 302, 303, 307, 308]);
+const SEARCH_TOKEN_RE = /name="ceginfo_csrf_token" value="([^"]+)"/;
+const OFFICERS_RE = /Cégjegyzésre jogosultak<\/h3>([\s\S]*?)<\/ul>/;
+const PROCEEDINGS_RE = /<p[^>]*>([^<]*(?:felszámolási|végelszámolási)[^<]*)<\/p>/;
+
+const LONG_FORMS: Array<[RegExp, string]> = [
+  [/korlátolt felelősségű társaság$/i, "kft"],
+  [/zártkörűen működő részvénytársaság$/i, "zrt"],
+  [/nyilvánosan működő részvénytársaság$/i, "nyrt"],
+  [/betéti társaság$/i, "bt"],
+  [/közkereseti társaság$/i, "kkt"],
+];
+const SHORT_FORM_RE = /(?:^|\s)(?:kft|zrt|nyrt|bt|kkt|rt)\.?$/i;
+
+function isHungarianCompanyName(name: string): boolean {
+  return SHORT_FORM_RE.test(name) || LONG_FORMS.some(([re]) => re.test(name));
+}
+
+function comparable(name: string): string {
+  const short = LONG_FORMS.reduce((n, [re, form]) => n.replace(re, form), name);
+  return short.toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+}
+
+const ENTITIES: Record<string, string> = { amp: "&", quot: '"', nbsp: " " };
+
+function decoded(html: string): string {
+  return html.replace(/&(#x?[0-9a-f]+|\w+);/gi, (whole, code: string) => {
+    if (code.startsWith("#x"))
+      return String.fromCodePoint(Number.parseInt(code.slice(2), 16));
+    if (code.startsWith("#")) return String.fromCodePoint(Number(code.slice(1)));
+    return ENTITIES[code] ?? whole;
+  });
+}
+
+function plainText(html: string): string {
+  return decoded(html.replace(/<[^>]+>/g, ""))
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function remember(response: Response, jar: Map<string, string>): void {
+  for (const cookie of response.headers.getSetCookie()) {
+    const [pair] = cookie.split(";");
+    const at = pair.indexOf("=");
+    jar.set(pair.slice(0, at), pair.slice(at + 1));
+  }
+}
+
+/** One browsing session: cookies carried across requests and redirects followed by hand,
+ *  because a search result lives in the session the search was posted from. */
+function session(fetchImpl: Fetch) {
+  const jar = new Map<string, string>();
+  return async (url: string, form?: URLSearchParams): Promise<Page> => {
+    let current = url;
+    let body = form;
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+      const response = await fetchImpl(current, {
+        method: body ? "POST" : "GET",
+        body,
+        redirect: "manual",
+        headers: {
+          "user-agent": USER_AGENT,
+          cookie: [...jar].map(([k, v]) => `${k}=${v}`).join("; "),
+        },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+      });
+      remember(response, jar);
+      const location = response.headers.get("location");
+      if (location && REDIRECTS.has(response.status)) {
+        current = new URL(location, current).href;
+        body = undefined;
+        continue;
+      }
+      if (!response.ok) throw new Error(`${current}: HTTP ${response.status}`);
+      return { url: current, html: await response.text() };
+    }
+    throw new Error(`${url}: too many redirects`);
+  };
+}
+
+interface Hit {
+  name: string;
+  number: string;
+  slug: string;
+  url: string;
+}
+
+function searchHits(html: string): Hit[] {
+  const results = html.matchAll(
+    /<a href="([^"]*\/ceg-adatlap\/([a-z0-9-]+)-(\d{10})\.html)"[^>]*>[\s\S]*?<h2[^>]*>([\s\S]*?)<\/h2>/g
+  );
+  return Array.from(results, ([, url, slug, number, title]) => ({
+    name: plainText(title.replace(/<small[\s\S]*?<\/small>/g, "")),
+    number,
+    slug,
+    url: url.replace(/(?<!:)\/\//g, "/"),
+  }));
+}
+
+async function findRegistered(
+  name: string,
+  browse: ReturnType<typeof session>
+): Promise<Hit | null> {
+  const home = await browse(CEGINFO);
+  const token = SEARCH_TOKEN_RE.exec(home.html)?.[1];
+  if (!token) throw new Error("ceginfo.hu: the search form has no token");
+  const results = await browse(
+    `${CEGINFO}cegkereso/rapid`,
+    new URLSearchParams({ ceginfo_csrf_token: token, rapid: name })
+  );
+  const exact = searchHits(results.html).filter(
+    (hit) => comparable(hit.name) === comparable(name)
+  );
+  return exact.length === 1 ? exact[0] : null;
+}
+
+function field(html: string, label: string): string {
+  const value = new RegExp(
+    String.raw`<h6[^>]*>\s*${label}\s*</h6>\s*<p[^>]*>([\s\S]*?)</p>`,
+    "i"
+  ).exec(html)?.[1];
+  return value ? plainText(value) : "";
+}
+
+/** Names only: the register also prints each officer's mother's name and home address. */
+function managers(html: string): string[] {
+  const block = OFFICERS_RE.exec(html)?.[1] ?? "";
+  return Array.from(block.matchAll(/<strong[^>]*>([\s\S]*?)<\/strong>/g), ([, n]) =>
+    plainText(n)
+  );
+}
+
+function proceedings(html: string): string {
+  const sentence = PROCEEDINGS_RE.exec(html)?.[1];
+  return sentence ? plainText(sentence) : "";
+}
+
+function formattedNumber(digits: string): string {
+  return `${digits.slice(0, 2)}-${digits.slice(2, 4)}-${digits.slice(4)}`;
+}
+
+function entryFrom(hit: Hit, record: Page): RegisteredCompany {
+  const html = record.html;
+  return {
+    name: hit.name,
+    fullName: field(html, "Teljes név"),
+    number: formattedNumber(hit.number),
+    taxNumber: field(html, "Adószám"),
+    seat: field(html, "székhely"),
+    status: proceedings(html),
+    activity: field(html, "Főtevékenység"),
+    founded: field(html, "Alapítás éve"),
+    managers: managers(html),
+    url: record.url,
+    sources: [hit.url, record.url],
+  };
+}
+
+/** Null for anything but one exact match. */
+async function lookupHungarianCompany(
+  name: string,
+  fetchImpl: Fetch
+): Promise<RegisteredCompany | null> {
+  const browse = session(fetchImpl);
+  const hit = await findRegistered(name, browse);
+  if (!hit) return null;
+  const record = await browse(`${NEMZETICEGTAR}${hit.slug}-c${hit.number}.html`);
+  return entryFrom(hit, record);
+}
+
+export const hungarianRegister: CompanyRegister = {
+  country: "Hungary",
+  recognizes: isHungarianCompanyName,
+  lookup: lookupHungarianCompany,
+};

package/src/hooks/lib/inference.ts

@@ -62,6 +62,7 @@ import { logDebug, logError } from "./log";
 import {
   type FixedModelRoute,
   type InferenceTier,
+  inferenceEffort,
   inferenceModel,
   isFixedModelRoute,
 } from "./models";
@@ -224,10 +225,21 @@ export function plannedInferenceRoute(
   return { agent: previewRoute().agent, ...plannedRoute({ user: "", tier, caller }) };
 }
 
+function routeWithModel(
+  opts: InferenceOptions
+): ReturnType<typeof plannedRoute> | { error: string } {
+  try {
+    return plannedRoute(opts);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 export async function inference(opts: InferenceOptions): Promise<InferenceResult> {
+  const planned = routeWithModel(opts);
+  if ("error" in planned) return { success: false, error: planned.error };
   const started = performance.now();
   const result = await checkedInference(opts);
-  const planned = plannedRoute(opts);
   logInferenceCall(opts, planned, result, performance.now() - started);
   return { ...result, model: planned.model ?? undefined };
 }
@@ -524,9 +536,15 @@ export function buildCodexArgs(opts: InferenceOptions): string[] {
     "--ephemeral",
     "--json",
     ...(opts.web ? ["-c", "web_search=live"] : []),
+    ...codexEffortArgs(opts),
   ];
 }
 
+function codexEffortArgs(opts: InferenceOptions): string[] {
+  const effort = inferenceEffort("codex-spawn", opts.tier);
+  return effort ? ["-c", `model_reasoning_effort="${effort}"`] : [];
+}
+
 interface CodexItem {
   type?: string;
   text?: string;
@@ -1124,31 +1142,38 @@ async function inferenceViaApi(opts: InferenceOptions): Promise<InferenceResult>
 // structured-output schema for JSON-mode callers.
 // ─────────────────────────────────────────────────────────────────────────────
 
+export function buildOpenAiBody(opts: InferenceOptions): Record<string, unknown> {
+  const { system, user, maxTokens = 500, jsonSchema } = opts;
+  const messages: Array<{ role: string; content: string }> = [];
+  if (system) messages.push({ role: "system", content: system });
+  messages.push({ role: "user", content: user });
+
+  const body: Record<string, unknown> = {
+    model: modelFor("openai-api", opts),
+    max_tokens: maxTokens,
+    messages,
+  };
+  const effort = inferenceEffort("openai-api", opts.tier);
+  if (effort) body.reasoning_effort = effort;
+  if (jsonSchema) {
+    body.response_format = {
+      type: "json_schema",
+      json_schema: { name: "structured_response", strict: true, schema: jsonSchema },
+    };
+  }
+  return body;
+}
+
 async function inferenceViaOpenAiApi(opts: InferenceOptions): Promise<InferenceResult> {
   const apiKey = withPalEnv().PAL_OPENAI_API_KEY;
   if (!apiKey) return { success: false };
 
-  const { system, user, maxTokens = 500, timeout = 15000, jsonSchema } = opts;
+  const { timeout = 15000 } = opts;
 
   try {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeout);
-
-    const messages: Array<{ role: string; content: string }> = [];
-    if (system) messages.push({ role: "system", content: system });
-    messages.push({ role: "user", content: user });
-
-    const body: Record<string, unknown> = {
-      model: modelFor("openai-api", opts),
-      max_tokens: maxTokens,
-      messages,
-    };
-    if (jsonSchema) {
-      body.response_format = {
-        type: "json_schema",
-        json_schema: { name: "structured_response", strict: true, schema: jsonSchema },
-      };
-    }
+    const body = buildOpenAiBody(opts);
 
     const response = await fetch("https://api.openai.com/v1/chat/completions", {
       method: "POST",

package/src/hooks/lib/models.ts

@@ -6,11 +6,13 @@ import type { AgentType } from "./agent";
 
 export const HAIKU_MODEL = "claude-haiku-4-5-20251001";
 export const HAIKU_5_5_MODEL = "claude-haiku-5-5";
-export const SONNET_MODEL = "claude-sonnet-5";
-export const FABLE_MODEL = "claude-fable-5";
+export const SONNET_MODEL = "claude-sonnet-5-5";
+export const OPUS_MODEL = "claude-opus-5-5";
+export const FABLE_MODEL = "claude-fable-5-1";
 
-export const INFERENCE_TIERS = ["small", "medium"] as const;
+export const INFERENCE_TIERS = ["small", "medium", "large", "flagship"] as const;
 export type InferenceTier = (typeof INFERENCE_TIERS)[number];
+type ReasoningEffort = "low" | "medium" | "high";
 
 export type FixedModelRoute =
   | "claude-spawn"
@@ -19,24 +21,37 @@ export type FixedModelRoute =
   | "openai-api"
   | "antigravity-spawn";
 
-/** `large` is the flagship that authors skills and subagents; without one, the agent authors inline. */
-type RouteModels = Record<InferenceTier, string> & { large?: string };
+type RouteModels = Record<"small" | "medium" | "large", string> & { flagship?: string };
 
 const ANTHROPIC_MODELS: RouteModels = {
   small: HAIKU_MODEL,
   medium: SONNET_MODEL,
-  large: FABLE_MODEL,
+  large: OPUS_MODEL,
+  flagship: FABLE_MODEL,
 };
 const OPENAI_MODELS: RouteModels = {
   small: "gpt-6-luna",
   medium: "gpt-6-sol",
-  large: "gpt-6-astra",
+  large: "gpt-6-sol",
+  flagship: "gpt-6-astra",
 };
-/** An Antigravity subagent's `model:` takes only a tier name, so `large` is `pro`. */
 const GEMINI_MODELS: RouteModels = {
   small: "gemini-3.8-flash-low",
-  medium: "gemini-3.8-flash-high",
-  large: "pro",
+  medium: "gemini-3.8-flash-medium",
+  large: "gemini-3.8-flash-high",
+};
+
+const OPENAI_EFFORTS: Partial<Record<InferenceTier, ReasoningEffort>> = { large: "high" };
+const INFERENCE_EFFORTS: Partial<
+  Record<FixedModelRoute, Partial<Record<InferenceTier, ReasoningEffort>>>
+> = {
+  "codex-spawn": OPENAI_EFFORTS,
+  "openai-api": OPENAI_EFFORTS,
+};
+
+/** An Antigravity subagent's `model:` takes only a tier name, never a model id. */
+const SUBAGENT_FLAGSHIP: Partial<Record<FixedModelRoute, string>> = {
+  "antigravity-spawn": "pro",
 };
 
 /**
@@ -63,9 +78,13 @@ export function isFixedModelRoute(route: string): route is FixedModelRoute {
  */
 const ANTHROPIC_ON_HAIKU_5_5 = new Set(["rule-drafter", "correction-kind"]);
 
-function evaluatedModel(models: RouteModels, caller?: string): string | undefined {
-  const onAnthropic = models === ANTHROPIC_MODELS;
-  return onAnthropic && caller && ANTHROPIC_ON_HAIKU_5_5.has(caller)
+function evaluatedModel(
+  models: RouteModels,
+  tier: InferenceTier,
+  caller?: string
+): string | undefined {
+  const onAnthropicSmall = models === ANTHROPIC_MODELS && tier === "small";
+  return onAnthropicSmall && caller && ANTHROPIC_ON_HAIKU_5_5.has(caller)
     ? HAIKU_5_5_MODEL
     : undefined;
 }
@@ -76,7 +95,17 @@ export function inferenceModel(
   caller?: string
 ): string {
   const models = INFERENCE_MODELS[route];
-  return evaluatedModel(models, caller) ?? models[tier];
+  const model = evaluatedModel(models, tier, caller) ?? models[tier];
+  if (!model) throw new Error(`${route} has no ${tier} model`);
+  return model;
+}
+
+/** The reasoning effort a tier asks of a model it shares with another tier; undefined keeps the model's default. */
+export function inferenceEffort(
+  route: FixedModelRoute,
+  tier: InferenceTier = "small"
+): ReasoningEffort | undefined {
+  return INFERENCE_EFFORTS[route]?.[tier];
 }
 
 const AGENT_SPAWN_ROUTE: Partial<Record<AgentType, FixedModelRoute>> = {
@@ -88,11 +117,13 @@ const AGENT_SPAWN_ROUTE: Partial<Record<AgentType, FixedModelRoute>> = {
 /**
  * The model an agent's `skill-author` / `subagent-author` runs on, or undefined
  * when `create-skill` and `create-subagent` should author inline. A new provider
- * needs a `large` model on its route and a platform block in assets/agents/*-author.md.
+ * needs a flagship model on its route and a platform block in assets/agents/*-author.md.
  */
 export function flagshipAuthorModel(agent: AgentType): string | undefined {
   const route = AGENT_SPAWN_ROUTE[agent];
-  return route ? INFERENCE_MODELS[route].large : undefined;
+  return route
+    ? (SUBAGENT_FLAGSHIP[route] ?? INFERENCE_MODELS[route].flagship)
+    : undefined;
 }
 
 export interface ModelPricing {
@@ -131,18 +162,31 @@ const withoutWritePremium = (
   cacheRead,
 });
 
+const withWritePremium = (
+  input: number,
+  cacheRead: number,
+  output: number
+): ModelPricing => ({
+  input,
+  output,
+  cacheWrite5m: input * 1.25,
+  cacheWrite1h: input * 1.25,
+  cacheRead,
+});
+
 /**
  * Standard-tier rates from https://developers.openai.com/api/docs/pricing; prompts over
- * 272K tokens cost more, and PAL's never get there. OpenAI bills no cache-write premium.
+ * 272K tokens cost more, and PAL's never get there. GPT-6 and GPT-5.6 bill cache writes
+ * at 1.25x input; older models publish no cache-write price, so writes bill as input.
  */
 const OPENAI_PRICING: Record<string, ModelPricing> = {
-  "gpt-6-astra": withoutWritePremium(10, 1, 50),
-  "gpt-6.1-sol": withoutWritePremium(2, 0.1, 10),
-  "gpt-6-sol": withoutWritePremium(2, 0.2, 10),
-  "gpt-6-luna": withoutWritePremium(0.1, 0.01, 0.5),
-  "gpt-5.6-sol": withoutWritePremium(4, 0.4, 20),
-  "gpt-5.6-terra": withoutWritePremium(2, 0.2, 12),
-  "gpt-5.6-luna": withoutWritePremium(0.2, 0.02, 1.2),
+  "gpt-6-astra": withWritePremium(10, 1, 50),
+  "gpt-6.1-sol": withWritePremium(2, 0.1, 10),
+  "gpt-6-sol": withWritePremium(2, 0.2, 10),
+  "gpt-6-luna": withWritePremium(0.1, 0.01, 0.5),
+  "gpt-5.6-sol": withWritePremium(4, 0.4, 20),
+  "gpt-5.6-terra": withWritePremium(2, 0.2, 12),
+  "gpt-5.6-luna": withWritePremium(0.2, 0.02, 1.2),
   "gpt-5.5": withoutWritePremium(5, 0.5, 30),
   "gpt-5.5-pro": withoutWritePremium(30, 30, 180),
   "gpt-5.4": withoutWritePremium(2.5, 0.25, 15),
@@ -176,14 +220,14 @@ export const MODEL_PRICING: Record<string, ModelPricing> = {
     cacheWrite1h: 0.2,
     cacheRead: 0.01,
   },
-  "claude-fable-5-1": {
+  [FABLE_MODEL]: {
     input: 10,
     output: 50,
     cacheWrite5m: 12.5,
     cacheWrite1h: 20,
     cacheRead: 0.25,
   },
-  [FABLE_MODEL]: {
+  "claude-fable-5": {
     input: 10,
     output: 50,
     cacheWrite5m: 12.5,