portable-agent-layer 0.110.0 → 0.112.0

package/README.md

@@ -88,6 +88,7 @@ pal cli status        # check your setup
 | `pal cli cost` | What each month was paid against its API-equivalent cost, per agent |
 | `pal cli wrapped [--year <yyyy>]` | A year of your work in numbers, read from the event log |
 | `pal cli patterns` | How you work across projects, read from the event log |
+| `pal cli work [show\|list\|open\|enter\|park\|wait\|done\|stopped\|decide\|attach\|follow-up]` | The work tree: what you are on in this project, where it stopped, what is parked or waiting, and the decisions and artifacts on each node. Detours are child nodes and `done` returns to the parent. With `dynamicContext.workTree` opted into, the active node rides along in every session and prompt, and your own commits attach to it at turn end |
 | `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\|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 |

package/assets/schema/pal-settings.schema.json

@@ -74,6 +74,14 @@
           "type": "boolean",
           "description": "One line with every prompt saying whether the work in the current directory is committed, pushed and released; a registered project without git is named as such."
         },
+        "workTree": {
+          "type": "boolean",
+          "description": "Opt-in, off by default until 1.0. The work tree (pal cli work): the active node, the detours it sits inside, parked work and what waits on the user at session start and after compaction, one line of it with every prompt, and new commits and branches attached to the active node at the end of a turn."
+        },
+        "workTreeGate": {
+          "type": "boolean",
+          "description": "Opt-in, off by default until 1.0. Send a turn back when it committed, made a branch, opened a PR or published an artifact without recording it in the work tree (pal cli work). Needs workTree."
+        },
         "dueReminders": {
           "type": "boolean",
           "description": "Opt-in, off by default until 1.0. Due maintenance reminders (learning analysis, relationship reflect) with every prompt until a reply names their command; then quiet until the next day."

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/templates/AGENTS.md.template

@@ -56,6 +56,7 @@ Start your response with the following header in this mode:
 - **Mandatory output format** — Every response MUST use exactly one of the output formats above (ALGORITHM, NATIVE, or MINIMAL). No freeform output.
 - **Response format before questions** — Always complete the current response format output FIRST, then invoke AskUserQuestion at the end.
 - **Named project → resume first** — Whenever the user references a project by name in ANY mode, run `pal cli project resume <slug>` before any file search or task execution. The project record has paths, context, and handoff notes that make manual searching unnecessary.
+{{IF workTree}}- **Keep the work tree true** — Record work in the tree with `pal cli work` as it happens, not at the end: `open` a node for new work (`--root` when it is unrelated), update `stopped` when the state moves, `decide` when a choice is settled, `attach` what the work produced, `done` when it is finished. When the user switches topic mid-work, `park --stopped "…"` the current node before starting the new one. Once a scope has work, the `Work:` line in each prompt shows where you are.
 
 ---
 

package/assets/templates/pal-settings.json

@@ -27,6 +27,8 @@
     "skillMatching": true,
     "wallClock": true,
     "repoState": true,
+    "workTree": false,
+    "workTreeGate": false,
     "dueReminders": false,
     "interactionAwareness": true,
     "reactionSampling": true,

package/package.json

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

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/cli/tree.ts

@@ -30,6 +30,7 @@ import { serverCommand } from "./server";
 import { skillCommand } from "./skill";
 import { subagentCommand } from "./subagent";
 import { usageCommand } from "./usage";
+import { workCommand } from "./work";
 import { wrappedCommand } from "./wrapped";
 
 type Handler = Leaf["run"];
@@ -171,6 +172,7 @@ export function cliTree(admin: AdminHandlers): Group {
       ledger: ledgerCommand,
       rule: ruleCommand,
       correction: correctionCommand,
+      work: workCommand,
       server: serverCommand,
       skill: skillCommand,
       subagent: subagentCommand,

package/src/cli/work.ts

@@ -0,0 +1,344 @@
+/**
+ * pal cli work — the work tree: what is active, what is parked and where it
+ * stopped, the decisions and artifacts of each piece of work.
+ */
+
+import {
+  ARTIFACT_KINDS,
+  type ArtifactKind,
+  appendEvent,
+  findNode,
+  newNodeId,
+  readTree,
+  type ScopeTree,
+  scopeOf,
+  type WorkNode,
+} from "../hooks/lib/work-tree";
+import {
+  renderNodeDetail,
+  renderSessionContext,
+  renderTreeList,
+  suffix,
+} from "../hooks/lib/work-tree-render";
+import { group, leaf, runCommand, UsageError } from "../tools/lib/command";
+
+const SCOPE = {
+  type: "string",
+  description: "Project or folder the work belongs to (default: the current one)",
+} as const;
+const NODE = {
+  type: "string",
+  description: "Node id or unambiguous prefix (default: the active node)",
+} as const;
+
+class NodeError extends Error {}
+
+function scopeFrom(values: { scope?: string }): string {
+  return values.scope ?? scopeOf(process.cwd());
+}
+
+function requireText(text: string | undefined, what: string): string {
+  if (!text?.trim()) throw new UsageError(`${what} is required`);
+  return text.trim();
+}
+
+function targetNode(tree: ScopeTree, idOrPrefix: string | undefined): WorkNode {
+  if (idOrPrefix) {
+    const node = findNode(tree, idOrPrefix);
+    if (!node)
+      throw new NodeError(`No single node matches "${idOrPrefix}" in ${tree.scope}`);
+    return node;
+  }
+  const active = tree.active ? tree.nodes.get(tree.active) : undefined;
+  if (!active)
+    throw new NodeError(
+      `No active node in ${tree.scope}; pass --node, or open or enter one first`
+    );
+  return active;
+}
+
+function guarded(run: () => void): number {
+  try {
+    run();
+    return 0;
+  } catch (err) {
+    if (!(err instanceof NodeError)) throw err;
+    console.error(err.message);
+    return 1;
+  }
+}
+
+function record<T extends Parameters<typeof appendEvent>[2]>(
+  values: { scope?: string; node?: string },
+  type: T,
+  payload: Parameters<typeof appendEvent<T>>[3],
+  done: (node: WorkNode) => string
+): number {
+  return guarded(() => {
+    const scope = scopeFrom(values);
+    const node = targetNode(readTree(scope), values.node);
+    appendEvent(scope, node.id, type, payload);
+    console.log(done(node));
+  });
+}
+
+function parentFor(tree: ScopeTree, under: string | undefined, root: boolean) {
+  if (root) return null;
+  if (under) return targetNode(tree, under).id;
+  return tree.active;
+}
+
+function optionalIsc(isc: string | undefined): number | undefined {
+  if (isc === undefined) return undefined;
+  const parsed = Number(isc);
+  if (!Number.isInteger(parsed) || parsed < 1)
+    throw new UsageError(`--isc must be an ISC number, got "${isc}"`);
+  return parsed;
+}
+
+function cmdOpen(
+  title: string | undefined,
+  values: {
+    scope?: string;
+    under?: string;
+    root?: boolean;
+    isc?: string;
+    commitment?: string;
+  }
+): number {
+  const text = requireText(title, "A title");
+  const isc = optionalIsc(values.isc);
+  return guarded(() => {
+    const scope = scopeFrom(values);
+    const tree = readTree(scope);
+    const parent = parentFor(tree, values.under, values.root === true);
+    const id = newNodeId();
+    const links = {
+      ...(isc !== undefined && { isc }),
+      ...(values.commitment && { commitment: values.commitment }),
+    };
+    appendEvent(scope, id, "open", { title: text, parent, links });
+    const under = parent ? ` under ${tree.nodes.get(parent)?.title ?? parent}` : "";
+    console.log(`Opened ${text} [${id}]${under}; it is now active.`);
+  });
+}
+
+function backTo(scope: string): string {
+  const tree = readTree(scope);
+  const active = tree.active ? tree.nodes.get(tree.active) : undefined;
+  if (!active) return "No node is active now.";
+  return `Back to ${active.title} [${active.id}]${suffix(", stopped at: ", active.stoppedAt)}.`;
+}
+
+function cmdDone(values: { scope?: string; node?: string; summary?: string }): number {
+  return guarded(() => {
+    const scope = scopeFrom(values);
+    const node = targetNode(readTree(scope), values.node);
+    appendEvent(
+      scope,
+      node.id,
+      "done",
+      values.summary ? { summary: values.summary } : {}
+    );
+    console.log(`Done: ${node.title} [${node.id}]. ${backTo(scope)}`);
+  });
+}
+
+function artifactKind(kind: string | undefined): ArtifactKind {
+  if (kind && (ARTIFACT_KINDS as readonly string[]).includes(kind))
+    return kind as ArtifactKind;
+  throw new UsageError(
+    `kind must be one of ${ARTIFACT_KINDS.join(", ")}, got "${kind ?? ""}"`
+  );
+}
+
+function cmdShow(values: { scope?: string; node?: string; json?: boolean }): number {
+  return guarded(() => {
+    const tree = readTree(scopeFrom(values));
+    if (!values.node && !tree.active) {
+      console.log(
+        renderSessionContext(tree) || `No work recorded for ${tree.scope} yet.`
+      );
+      return;
+    }
+    const node = targetNode(tree, values.node);
+    console.log(
+      values.json ? JSON.stringify(node, null, 2) : renderNodeDetail(tree, node)
+    );
+  });
+}
+
+function cmdList(values: { scope?: string; all?: boolean; json?: boolean }): number {
+  const tree = readTree(scopeFrom(values));
+  if (values.json) {
+    console.log(JSON.stringify({ ...tree, nodes: [...tree.nodes.values()] }, null, 2));
+    return 0;
+  }
+  console.log(renderTreeList(tree, values.all === true));
+  return 0;
+}
+
+export const workCommand = group({
+  summary: "The work tree: what is active, parked, waiting, and where each piece stopped",
+  fallback: "show",
+  commands: {
+    show: leaf({
+      summary: "The active node in full, or the whole picture when none is active",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        json: { type: "boolean", description: "As JSON" },
+      },
+      run: ({ values }) => cmdShow(values),
+    }),
+    list: leaf({
+      summary: "Every open node as a tree",
+      options: {
+        scope: SCOPE,
+        all: { type: "boolean", description: "Include finished nodes" },
+        json: { type: "boolean", description: "As JSON" },
+      },
+      run: ({ values }) => cmdList(values),
+    }),
+    open: leaf({
+      summary: "Open a node and make it active (a child of the active node by default)",
+      args: "<title...>",
+      options: {
+        scope: SCOPE,
+        under: { type: "string", description: "Parent node id or prefix" },
+        root: {
+          type: "boolean",
+          description: "Open at the top level, not under the active node",
+        },
+        isc: { type: "string", description: "The project ISC this node works on" },
+        commitment: {
+          type: "string",
+          description: "The commitment id this node fulfils",
+        },
+      },
+      run: ({ positionals, values }) => cmdOpen(positionals.join(" "), values),
+    }),
+    enter: leaf({
+      summary: "Make a node active, parking the one that was",
+      args: "<node>",
+      options: { scope: SCOPE },
+      run: ({ positionals, values }) =>
+        record(
+          { ...values, node: requireText(positionals[0], "A node") },
+          "enter",
+          {},
+          (n) => `Entered ${n.title} [${n.id}]${suffix(", stopped at: ", n.stoppedAt)}.`
+        ),
+    }),
+    park: leaf({
+      summary: "Park a node, saying where it stopped",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        stopped: { type: "string", description: "Where it stopped, to resume from" },
+      },
+      run: ({ values }) =>
+        record(
+          values,
+          "park",
+          values.stopped ? { stoppedAt: values.stopped } : {},
+          (n) => `Parked ${n.title} [${n.id}].`
+        ),
+    }),
+    wait: leaf({
+      summary: "Mark a node as waiting on the user",
+      args: "<waits-on...>",
+      options: { scope: SCOPE, node: NODE },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "wait",
+          { on: requireText(positionals.join(" "), "What it waits on") },
+          (n) => `${n.title} [${n.id}] is waiting on the user.`
+        ),
+    }),
+    done: leaf({
+      summary: "Finish a node; a finished detour hands the work back to its parent",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        summary: { type: "string", description: "One line on what it ended with" },
+      },
+      run: ({ values }) => cmdDone(values),
+    }),
+    stopped: leaf({
+      summary: "Record where the work stands now",
+      args: "<text...>",
+      options: { scope: SCOPE, node: NODE },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "stopped",
+          { text: requireText(positionals.join(" "), "Where it stopped") },
+          (n) => `Stopped-at recorded on ${n.title} [${n.id}].`
+        ),
+    }),
+    decide: leaf({
+      summary: "Record a decision on a node",
+      args: "<decision...>",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        why: { type: "string", description: "The reason" },
+      },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "decide",
+          {
+            text: requireText(positionals.join(" "), "A decision"),
+            ...(values.why && { why: values.why }),
+          },
+          (n) => `Decision recorded on ${n.title} [${n.id}].`
+        ),
+    }),
+    attach: leaf({
+      summary: `Attach an artifact to a node (${ARTIFACT_KINDS.join(", ")})`,
+      args: "<kind> <ref...>",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        label: { type: "string", description: "What it is" },
+      },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "attach",
+          {
+            kind: artifactKind(positionals[0]),
+            ref: requireText(positionals.slice(1).join(" "), "A ref"),
+            ...(values.label && { label: values.label }),
+          },
+          (n) => `Attached to ${n.title} [${n.id}].`
+        ),
+    }),
+    "follow-up": leaf({
+      summary: "Record a follow-up on a node",
+      args: "<text...>",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        due: { type: "string", description: "When it is due, such as 2026-10-25" },
+      },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "follow-up",
+          {
+            text: requireText(positionals.join(" "), "A follow-up"),
+            ...(values.due && { due: values.due }),
+          },
+          (n) => `Follow-up recorded on ${n.title} [${n.id}].`
+        ),
+    }),
+  },
+});
+
+export function runWork(args: string[]): Promise<number> {
+  return runCommand(workCommand, args, ["pal", "cli", "work"]);
+}

package/src/hooks/StopOrchestrator.ts

@@ -20,6 +20,7 @@ import { logError } from "./lib/log";
 import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 import { type StopTurnPayload, stopTurn } from "./lib/stop";
+import { stopWorkTree } from "./lib/work-tree-gate";
 
 // Recursion guard — spawned inference subprocesses must not record session
 // learning, ratings, or handoffs from their throwaway transcript.
@@ -62,4 +63,13 @@ try {
 } catch (err) {
   logError("StopOrchestrator:adaptation-rules", err);
 }
+try {
+  const sendBack = stopWorkTree(payload);
+  if (sendBack) {
+    process.stdout.write(stopBlockResponse(sendBack));
+    process.exit(0);
+  }
+} catch (err) {
+  logError("StopOrchestrator:work-tree", err);
+}
 await stopTurn(payload);

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/handlers/inject-retrieval.ts

@@ -22,6 +22,7 @@ import { isEnabled } from "../lib/settings";
 import { getSkillReminder } from "../lib/skill-match";
 import { getSteeringReminder } from "../lib/steering";
 import { getWallClockReminder } from "../lib/wall-clock";
+import { workTreePromptLine } from "../lib/work-tree-context";
 
 const BUDGET_MS = 250;
 
@@ -88,6 +89,7 @@ export async function getPromptContext(
     getWallClockReminder(),
     userText && withinBudget(() => promptRulesReminder(userText, sessionId), BUDGET_MS),
     withinBudget(() => getRepoStateReminder(), BUDGET_MS),
+    withinBudget(() => workTreePromptLine(userText), BUDGET_MS),
     userText && withinBudget(() => observeTurn(userText, sessionId), BUDGET_MS),
     withinBudget(() => dueNudgeReminder(), BUDGET_MS),
     userText && getSteeringReminder(userText),

package/src/hooks/lib/claim-check.ts

@@ -139,21 +139,22 @@ function isUserPrompt(entry: TranscriptLine): boolean {
 
 const ran = (input: unknown) => JSON.stringify(input ?? {});
 
-function commandsIn(entry: TranscriptLine): string[] {
+function callsIn(entry: TranscriptLine, tools: ReadonlySet<string>): string[] {
   if (entry.type === "PLANNER_RESPONSE")
     return toolCallsOf(entry)
-      .filter((call) => COMMAND_TOOLS.has(call.name ?? ""))
+      .filter((call) => tools.has(call.name ?? ""))
       .map((call) => ran(call.args));
   if (entry.type === "assistant")
     return blocks(entry.message?.content)
-      .filter((b) => b.type === "tool_use" && COMMAND_TOOLS.has(b.name ?? ""))
+      .filter((b) => b.type === "tool_use" && tools.has(b.name ?? ""))
       .map((b) => ran(b.input));
   const call = entry.payload;
   if (entry.type !== "response_item" || !call) return [];
   const input = call.input ?? call.arguments ?? call.action;
-  if (call.type === "local_shell_call") return [ran(input)];
+  if (call.type === "local_shell_call")
+    return tools === COMMAND_TOOLS ? [ran(input)] : [];
   const isCall = call.type === "function_call" || call.type === "custom_tool_call";
-  return isCall && COMMAND_TOOLS.has(call.name ?? "") ? [ran(input)] : [];
+  return isCall && tools.has(call.name ?? "") ? [ran(input)] : [];
 }
 
 function isTurnEntry(entry: TranscriptLine): boolean {
@@ -162,17 +163,24 @@ function isTurnEntry(entry: TranscriptLine): boolean {
   );
 }
 
-/** What each command this turn ran. Null when no line reads as a turn, so an
- *  unknown transcript format never counts as none. */
-export function commandsThisTurn(lines: string[]): string[] | null {
+/** The input of each call this turn made to one of the tools. Null when no line reads
+ *  as a turn, so an unknown transcript format never counts as none. */
+export function callsThisTurn(
+  lines: string[],
+  tools: ReadonlySet<string>
+): string[] | null {
   const entries = lines.map(parsed).filter((e): e is TranscriptLine => e !== null);
   if (!entries.some(isTurnEntry)) return null;
-  let commands: string[] = [];
+  let calls: string[] = [];
   for (const entry of entries) {
-    if (isUserPrompt(entry)) commands = [];
-    commands.push(...commandsIn(entry));
+    if (isUserPrompt(entry)) calls = [];
+    calls.push(...callsIn(entry, tools));
   }
-  return commands;
+  return calls;
+}
+
+export function commandsThisTurn(lines: string[]): string[] | null {
+  return callsThisTurn(lines, COMMAND_TOOLS);
 }
 
 function isBacked(claim: string, commands: string[]): boolean {

package/src/hooks/lib/claim-log.ts

@@ -40,7 +40,7 @@ function monthFile(date: Date): string {
   return resolve(claimsDir(), `${date.toISOString().slice(0, 7)}.jsonl`);
 }
 
-function transcriptLines(payload: StopTurnPayload): string[] {
+export function transcriptLines(payload: StopTurnPayload): string[] {
   const path = payload.transcript_path ?? payload.transcriptPath;
   if (!path || !existsSync(path)) return [];
   return readFileSync(path, "utf-8").split("\n").filter(Boolean);

package/src/hooks/lib/claude-md.ts

@@ -110,7 +110,16 @@ export function needsRebuild(): boolean {
   return latestMtime(...sources) > outputMtime;
 }
 
-import { identity } from "./settings";
+import { identity, isOptedIn } from "./settings";
+
+const OPT_IN_LINE_RE = /^\{\{IF (\w+)\}\}(.*\n?)/gm;
+
+/** A `{{IF key}}` line stays, without its prefix, only when that setting is opted into. */
+function withOptedInLines(template: string): string {
+  return template.replace(OPT_IN_LINE_RE, (_, key: string, line: string) =>
+    isOptedIn(key) ? line : ""
+  );
+}
 
 /** Render AGENTS.md from the template using current state */
 export function buildClaudeMd(): string {
@@ -120,7 +129,7 @@ export function buildClaudeMd(): string {
 
   const id = identity();
 
-  return template
+  return withOptedInLines(template)
     .replaceAll("{{IDENTITY_NAME}}", id.ai.name)
     .replaceAll("{{IDENTITY_DISPLAY}}", id.ai.displayName)
     .replaceAll("{{IDENTITY_CATCHPHRASE}}", id.ai.catchphrase)

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>;
+}