portable-agent-layer 0.110.0 → 0.112.0

package/src/hooks/lib/context.ts

@@ -18,6 +18,7 @@ import { sessionDir } from "./session-dir";
 import * as settings from "./settings";
 import { readFramePrinciples } from "./wisdom";
 import { lastSessionTitle } from "./work-tracking";
+import { loadWorkTreeContext } from "./work-tree-context";
 
 /** Load and concatenate loadAtStartup files */
 function loadStartupFiles(): string {
@@ -223,10 +224,12 @@ export function buildSystemReminder(
     !opts.withoutHandoff && settings.isEnabled("handoff")
       ? loadHandoffContext(sessionDir())
       : "";
+  const workTree = loadWorkTreeContext(sessionDir());
   const dueNudges = opts.agent === "cursor" ? dueNudgeSections() : [];
   const parts: string[] = [];
   if (startup) parts.push(startup);
   if (handoff) parts.push(handoff);
+  if (workTree) parts.push(workTree);
   parts.push(...dueNudges);
   if (selfModel) parts.push(selfModel);
   if (wisdom) parts.push(wisdom);

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

@@ -0,0 +1,25 @@
+/**
+ * Where the work tree enters an agent's context: the block every new or
+ * compacted session starts with, and the line every prompt carries.
+ */
+
+import { reactionTo } from "./interaction-reaction";
+import { sessionDir } from "./session-dir";
+import { isOptedIn } from "./settings";
+import { readTree, scopeOf } from "./work-tree";
+import { renderPromptLine, renderSessionContext } from "./work-tree-render";
+
+export function loadWorkTreeContext(cwd: string = sessionDir()): string {
+  if (!isOptedIn("workTree")) return "";
+  return renderSessionContext(readTree(scopeOf(cwd)));
+}
+
+export function workTreePromptLine(
+  userText: string,
+  cwd: string = sessionDir()
+): string | null {
+  if (!isOptedIn("workTree")) return null;
+  const newTopic = userText !== "" && reactionTo(userText, undefined) === "new-topic";
+  const line = renderPromptLine(readTree(scopeOf(cwd)), newTopic);
+  return line ? `<system-reminder>${line}</system-reminder>` : null;
+}

package/src/hooks/lib/work-tree-gate.ts

@@ -0,0 +1,67 @@
+/**
+ * The end-of-turn check that keeps the work tree true: a turn that produced
+ * something (a commit, a branch, a PR, a published artifact) and recorded
+ * nothing in the tree is sent back once to record it.
+ */
+
+import { callsThisTurn, commandsThisTurn } from "./claim-check";
+import { alreadySentBack, transcriptLines } from "./claim-log";
+import { sessionDir } from "./session-dir";
+import { isOptedIn } from "./settings";
+import type { StopTurnPayload } from "./stop";
+import { readTree, scopeOf } from "./work-tree";
+import { attachGitProgress } from "./work-tree-git";
+import { renderPromptLine } from "./work-tree-render";
+
+const RECORDS_WORK_RE = /\bpal\s+cli\s+work\b/;
+
+const PRODUCERS: { what: string; re: RegExp }[] = [
+  { what: "committed", re: /\bgit\s+commit\b/ },
+  { what: "made a branch", re: /\bgit\s+(?:checkout\s+-b|switch\s+-c|branch\s+(?!-)\S)/ },
+  { what: "opened a PR", re: /\bgh\s+pr\s+create\b/ },
+];
+
+const ARTIFACT_TOOLS: ReadonlySet<string> = new Set(["Artifact"]);
+const NON_PUBLISH_ACTION_RE = /"action":"(?!publish")/;
+
+function producedThisTurn(commands: string[], lines: string[]): string[] {
+  const produced = PRODUCERS.filter((p) => commands.some((c) => p.re.test(c))).map(
+    (p) => p.what
+  );
+  const artifacts = callsThisTurn(lines, ARTIFACT_TOOLS) ?? [];
+  if (artifacts.some((call) => !NON_PUBLISH_ACTION_RE.test(call)))
+    produced.push("published an artifact");
+  return produced;
+}
+
+function sendBackReason(produced: string[], scope: string): string {
+  const where = renderPromptLine(readTree(scope), false) ?? "Work: nothing recorded yet";
+  return [
+    `This turn ${produced.join(", ")} but recorded nothing in the work tree (${where}).`,
+    'Record where the work stands with `pal cli work stopped "…"`, plus `decide` or `attach` where they fit;',
+    'if no node fits, open one first with `pal cli work open "…"` (`--root` for unrelated work).',
+  ].join(" ");
+}
+
+export function workTreeSendBack(
+  payload: StopTurnPayload,
+  lines: string[],
+  cwd: string
+): string | null {
+  if (!isOptedIn("workTree") || !isOptedIn("workTreeGate")) return null;
+  if (alreadySentBack(payload)) return null;
+  const commands = commandsThisTurn(lines);
+  if (commands === null || commands.some((c) => RECORDS_WORK_RE.test(c))) return null;
+  const produced = producedThisTurn(commands, lines);
+  return produced.length > 0 ? sendBackReason(produced, scopeOf(cwd)) : null;
+}
+
+/** The reason to send the turn back with, or null after attaching what git moved. */
+export function stopWorkTree(payload: StopTurnPayload | null): string | null {
+  if (!payload || !isOptedIn("workTree")) return null;
+  const cwd = sessionDir();
+  const sendBack = workTreeSendBack(payload, transcriptLines(payload), cwd);
+  if (sendBack) return sendBack;
+  attachGitProgress(cwd);
+  return null;
+}

package/src/hooks/lib/work-tree-git.ts

@@ -0,0 +1,98 @@
+/**
+ * New commits and branch switches land on the active work-tree node at the end
+ * of a turn, so the tree knows what the work produced without being told.
+ */
+
+import { spawnSync } from "node:child_process";
+import { appendEvent, readTree, scopeOf } from "./work-tree";
+
+const GIT_TIMEOUT_MS = 1000;
+const MAX_COMMITS = 20;
+
+interface GitSnapshot {
+  branch: string;
+  head: string;
+  email: string;
+}
+
+interface Commit {
+  sha: string;
+  subject: string;
+}
+
+function git(cwd: string, ...args: string[]): string | null {
+  const result = spawnSync("git", ["-C", cwd, ...args], {
+    encoding: "utf-8",
+    timeout: GIT_TIMEOUT_MS,
+  });
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+
+function snapshot(cwd: string): GitSnapshot | null {
+  const head = git(cwd, "rev-parse", "HEAD");
+  const branch = git(cwd, "rev-parse", "--abbrev-ref", "HEAD");
+  if (!head || !branch) return null;
+  return { head, branch, email: git(cwd, "config", "user.email") ?? "" };
+}
+
+/** Only the user's own commits: a pull brings other people's work, which this turn did not make. */
+function ownCommitsSince(cwd: string, from: string, to: string, email: string): Commit[] {
+  const log = git(
+    cwd,
+    "log",
+    `-${MAX_COMMITS}`,
+    "--format=%h%x09%ae%x09%s",
+    `${from}..${to}`
+  );
+  if (!log) return [];
+  return log
+    .split("\n")
+    .map((line) => line.split("\t"))
+    .filter(([, author]) => author === email)
+    .map(([sha, , subject]) => ({ sha, subject }))
+    .reverse();
+}
+
+/** A scope with no work yet is left alone, so visiting a repo writes nothing. */
+export function attachGitProgress(
+  cwd: string,
+  file?: string,
+  now: Date = new Date()
+): void {
+  const scope = scopeOf(cwd);
+  const tree = readTree(scope, file);
+  if (tree.nodes.size === 0) return;
+  const current = snapshot(cwd);
+  if (!current) return;
+  const cursor = tree.gitCursor;
+  if (cursor?.head === current.head && cursor.branch === current.branch) return;
+
+  if (cursor && tree.active) {
+    if (cursor.branch !== current.branch)
+      appendEvent(
+        scope,
+        tree.active,
+        "attach",
+        { kind: "branch", ref: current.branch },
+        file,
+        now
+      );
+    for (const commit of ownCommitsSince(cwd, cursor.head, current.head, current.email))
+      appendEvent(
+        scope,
+        tree.active,
+        "attach",
+        { kind: "commit", ref: commit.sha, label: commit.subject },
+        file,
+        now
+      );
+  }
+  appendEvent(
+    scope,
+    "",
+    "git-cursor",
+    { branch: current.branch, head: current.head },
+    file,
+    now
+  );
+}