portable-agent-layer 0.93.0 → 0.94.0

package/README.md

@@ -208,7 +208,9 @@ PAL ships with built-in skills that extend your agent's capabilities:
 | `presentation` | Build branded slide decks from outlines |
 | `projects` | Look up, resume, register, or manage tracked projects |
 | `reflect` | Diagnose why a PAL behavior didn't trigger |
-| `rule-review` | Approve or deny the rules PAL drafted from your corrections || `telos` | Inspect or update goals, beliefs, strategies, narratives |
+| `research-entity` | Research a company or person on the web: links, registry entry, recent news |
+| `rule-review` | Approve or deny the rules PAL drafted from your corrections |
+| `telos` | Inspect or update goals, beliefs, strategies, narratives |
 | `think` | Structured first-pass reasoning on a problem |
 
 ---

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

@@ -106,6 +106,10 @@
           "type": "boolean",
           "description": "After a session stops, ask a background model which people and companies your own messages mentioned, and write clear matches and new full names to the knowledge store with the message as source. A name that could be more than one entry, or a first name alone, waits for `pal cli knowledge review` instead."
         },
+        "entityResearch": {
+          "type": "boolean",
+          "description": "Opt-in, off by default. When extraction creates a company, or a person with a known organization, research it on the web through the active agent (up to three per stop): website, LinkedIn, social accounts, the company registry entry, recent news, each with its source. A profile the model is sure of waits in `pal cli knowledge review`; accepting writes it to the entry. The name and what you said about it reach the agent's web search. Claude Code, Codex and Copilot only. Needs entityExtraction."
+        },
         "steeringTestReport": { "type": "boolean", "description": "When true, the assistant notes to the user which steering self-check fired. For the dual-live test period; ships false." }
       }
     },

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

@@ -0,0 +1,57 @@
+---
+name: research-entity
+license: MIT
+description: "Research one company or person on the web and build a sourced profile: official website, LinkedIn, social accounts, the company registry entry (cégjegyzék for Hungarian companies), and recent news or statements. Use when the user asks to research, look up, profile, or background-check a specific company or person, or to enrich a knowledge-store entry."
+argument-hint: <company or person name> [what you know about them]
+metadata:
+  source: portable-agent-layer
+  triggers:
+    - "research-entity"
+    - "research entity"
+    - "research this company"
+    - "research this person"
+    - "look up the company"
+    - "company background"
+    - "background check"
+    - "cégjegyzék"
+---
+
+Research the company or person named in $ARGUMENTS and show a sourced profile. The research runs through `pal cli knowledge research`, which picks the active agent's web search and limits it to searching and reading pages. Never research with your own tools instead: the command is what keeps the result in the same shape on every agent.
+
+## Workflow
+
+1. Work out from $ARGUMENTS and the conversation:
+   - the exact name;
+   - whether it is a company or a person;
+   - 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.
+2. Run the research. For a company:
+   ```bash
+   pal cli knowledge research "<name>" --context "<what the user said>"
+   ```
+   For a person, add `--person` and, when known, `--organization "<employer>"`:
+   ```bash
+   pal cli knowledge research "<name>" --person --organization "<employer>" --context "<what the user said>"
+   ```
+   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`;
+   - nothing was found (`match: none`);
+   - the active agent cannot search the web yet.
+4. If it succeeds, show the profile it printed as it is. Do not add facts it did not print.
+5. If you queued it, tell the user the review command it printed: `pal cli knowledge review accept <id>` writes the profile to the entry, and `pal cli knowledge review reject <id>` drops it.
+
+## Output format
+
+The profile as printed: summary, links, registry, news and sources. Then one line saying whether it was queued for review, with the accept command.
+
+## When to use
+
+- The user names a specific company or person and wants to know who they are, or their website, LinkedIn, accounts, registry data or recent news.
+- The user wants an entry in the knowledge store filled in from the web.
+
+## Do NOT use
+
+- To pull every person and company out of an article, video or paste. Use `entities` for that.
+- For a broad topic, market or question rather than one named entity. Use `deep-research` for that.

package/assets/templates/pal-settings.json

@@ -35,6 +35,7 @@
     "adaptationRules": true,
     "entityCards": true,
     "entityExtraction": true,
+    "entityResearch": false,
     "steeringTestReport": false
   },
   "steering": {

package/package.json

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

package/src/cli/infer.ts

@@ -18,6 +18,7 @@ interface InferValues {
   schema?: string;
   timeout?: string;
   caller?: string;
+  web?: boolean;
 }
 
 type Infer = typeof inference;
@@ -81,6 +82,7 @@ function requestFrom(values: InferValues, stdin: string): Parameters<Infer>[0] {
     tier: tierOf(values.tier),
     timeout: timeoutMs(values.timeout),
     caller: values.caller ?? "cli-infer",
+    web: values.web ?? false,
   };
 }
 
@@ -137,6 +139,10 @@ export const inferCommand = leaf({
       value: "<label>",
       description: "Label for PAL's debug log",
     },
+    web: {
+      type: "boolean",
+      description: "Let the model search and read the web (Claude, Codex, Copilot)",
+    },
   },
   run: async ({ values }) => inferFromCli(values, await Bun.stdin.text()),
 });

package/src/cli/knowledge-research.ts

@@ -0,0 +1,93 @@
+/**
+ * pal cli knowledge research — research one person or company on the web through
+ * the active agent, print the profile, and optionally queue it for review.
+ */
+
+import { loadKnownEntities, loadNameIndex } from "../hooks/lib/entity-cards";
+import { queueForReview } from "../hooks/lib/entity-extraction";
+import { lookupName } from "../hooks/lib/entity-names";
+import {
+  type ResearchDeps,
+  type ResearchTarget,
+  renderProfile,
+  researchEntity,
+  researchItem,
+} from "../hooks/lib/entity-research";
+import { inference } from "../hooks/lib/inference";
+import { identity } from "../hooks/lib/settings";
+import { leaf, UsageError } from "../tools/lib/command";
+
+interface ResearchValues {
+  person?: boolean;
+  organization?: string;
+  context?: string;
+  queue?: boolean;
+  json?: boolean;
+}
+
+function storedSlug(name: string, kind: ResearchTarget["kind"]): string {
+  const domain = kind === "person" ? "People" : "Companies";
+  const { entities, exact } = lookupName(name, loadNameIndex(loadKnownEntities()));
+  const matches = entities.filter((e) => e.domain === domain);
+  return exact && matches.length === 1 ? matches[0].slug : "";
+}
+
+function targetFrom(name: string, values: ResearchValues): ResearchTarget {
+  const kind = values.person ? "person" : "company";
+  return {
+    kind,
+    name,
+    slug: storedSlug(name, kind),
+    organization: values.organization ?? "",
+    fact: values.context ?? "",
+  };
+}
+
+export async function researchFromCli(
+  name: string | undefined,
+  values: ResearchValues,
+  deps: ResearchDeps = { principal: identity().principal.name, infer: inference }
+): Promise<number> {
+  if (!name?.trim()) throw new UsageError("name the person or company to research");
+  const target = targetFrom(name.trim(), values);
+  const outcome = await researchEntity(target, deps);
+  if (!outcome.found) {
+    console.error(`Nothing kept for "${target.name}": ${outcome.reason}`);
+    return 1;
+  }
+  console.log(
+    values.json
+      ? JSON.stringify(outcome.profile, null, 2)
+      : renderProfile(outcome.profile)
+  );
+  if (values.queue) {
+    const item = researchItem(target, outcome.profile);
+    queueForReview([item]);
+    console.log(`\nQueued for review: pal cli knowledge review accept ${item.id}`);
+  }
+  return 0;
+}
+
+export const researchCommand = leaf({
+  summary: "Research a company (or --person) on the web: links, registry, news",
+  args: "<name>",
+  options: {
+    person: { type: "boolean", description: "Research a person, not a company" },
+    organization: {
+      type: "string",
+      value: "<name>",
+      description: "Where the person works, to tell namesakes apart",
+    },
+    context: {
+      type: "string",
+      value: "<text>",
+      description: "What you know about them, to tell namesakes apart",
+    },
+    queue: {
+      type: "boolean",
+      description: "Also queue the profile for `pal cli knowledge review`",
+    },
+    json: { type: "boolean", description: "Print the profile as JSON" },
+  },
+  run: ({ positionals, values }) => researchFromCli(positionals.join(" "), values),
+});

package/src/cli/knowledge.ts

@@ -7,6 +7,7 @@
 
 import { readFileSync } from "node:fs";
 import type { ReviewItem } from "../hooks/lib/entity-extraction";
+import { renderProfile } from "../hooks/lib/entity-research";
 import {
   type AcceptChoice,
   acceptReview,
@@ -34,6 +35,7 @@ import {
   type Status,
 } from "../tools/knowledge/lib";
 import { group, leaf, runCommand, UsageError } from "../tools/lib/command";
+import { researchCommand } from "./knowledge-research";
 
 const VOCABULARY = `Domains: ${DOMAINS.join(", ")}
 Relation types: ${RELATION_TYPES.join(", ")}`;
@@ -120,6 +122,7 @@ export const knowledgeCommand = group({
       },
       run: ({ values }) => cmdIngest(values.source ?? "manual", values.file),
     }),
+    research: researchCommand,
     review: group({
       summary: "People and companies the background extractor would not guess",
       fallback: "list",
@@ -623,17 +626,27 @@ function reviewReason(reason: ReviewItem["reason"]): string {
     ambiguous: "could be more than one known entry",
     "unknown-existing": "named an entry the store does not have",
     "first-name-only": "first name only",
+    "web-profile": "found on the web",
   };
   return reasons[reason];
 }
 
-function reviewLines(item: ReviewItem): string[] {
-  const { kind, name, fact } = item.entity;
+function reviewDetails(item: ReviewItem): string[] {
+  if (item.profile)
+    return [
+      item.entity.existing ? `for ${item.entity.existing}` : "as a new entry",
+      ...renderProfile(item.profile).split("\n"),
+    ];
   const candidates =
-    item.candidates.length > 0 ? `could be: ${item.candidates.join(", ")}` : "";
+    item.candidates.length > 0 ? [`could be: ${item.candidates.join(", ")}`] : [];
+  return [item.entity.fact, ...candidates, `from ${item.source}`];
+}
+
+function reviewLines(item: ReviewItem): string[] {
+  const { kind, name } = item.entity;
   return [
     `  ${item.id}  ${kind} "${name}" — ${reviewReason(item.reason)}`,
-    ...[fact, candidates, `from ${item.source}`]
+    ...reviewDetails(item)
       .filter(Boolean)
       .map((line) => `            ${line}`),
   ];

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

@@ -1,7 +1,8 @@
 /**
  * Stop handler: learn the people and companies the user mentioned since the last
- * stop, so the prompt-time cards know them next time. Runs detached; one model
- * call at most, and only when the new text names someone.
+ * stop, so the prompt-time cards know them next time, and research the new ones on
+ * the web for review. Runs detached; one extraction call, only when the new text
+ * names someone, and one web research call per new entry.
  */
 
 import { ingestEntities } from "../../tools/knowledge/ingest";
@@ -18,9 +19,10 @@ import {
   unseenUserText,
   worthExtracting,
 } from "../lib/entity-extraction";
+import { newResearchTargets, researchNewEntities } from "../lib/entity-research";
 import { canInfer, inference } from "../lib/inference";
 import { logDebug, logError } from "../lib/log";
-import { identity, isEnabled } from "../lib/settings";
+import { identity, isEnabled, isOptedIn } from "../lib/settings";
 import { logTokenUsage } from "../lib/token-usage";
 import { parseMessages } from "../lib/transcript";
 
@@ -65,6 +67,11 @@ export async function extractSessionEntities(
     "entity-extraction",
     `${written.people.length} people, ${written.companies.length} companies, ${plan.review.length} for review`
   );
+  if (isOptedIn("entityResearch"))
+    await researchNewEntities(newResearchTargets(plan.ingest, written), {
+      principal: id.principal.name,
+      infer: inference,
+    });
 }
 
 if (process.argv[2] === "--run") {

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

@@ -35,13 +35,35 @@ export interface ExtractedEntity {
   fact: string;
 }
 
+export interface ResearchProfile {
+  match: "sure" | "unsure" | "none";
+  summary: string;
+  role: string;
+  organization: string;
+  website: string;
+  linkedin: string;
+  socials: { platform: string; url: string }[];
+  registry: {
+    name: string;
+    number: string;
+    taxNumber: string;
+    seat: string;
+    status: string;
+    managers: string[];
+    url: string;
+  };
+  news: { date: string; title: string; url: string }[];
+  sources: string[];
+}
+
 export interface ReviewItem {
   ts: string;
   source: string;
   id: string;
-  reason: "ambiguous" | "unknown-existing" | "first-name-only";
+  reason: "ambiguous" | "unknown-existing" | "first-name-only" | "web-profile";
   entity: ExtractedEntity;
   candidates: string[];
+  profile?: ResearchProfile;
 }
 
 export interface ExtractionPlan {
@@ -49,7 +71,7 @@ export interface ExtractionPlan {
   review: ReviewItem[];
 }
 
-function closedObject<P extends Record<string, unknown>>(properties: P) {
+export function closedObject<P extends Record<string, unknown>>(properties: P) {
   return {
     type: "object" as const,
     additionalProperties: false,

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

@@ -0,0 +1,305 @@
+/**
+ * Researching a person or company on the web: website, LinkedIn, social accounts,
+ * the company registry entry and recent news, each with its source. A profile only
+ * reaches the store through the review queue.
+ */
+
+import type { IngestInput, IngestResult } from "../../tools/knowledge/ingest";
+import {
+  closedObject,
+  type ExtractedEntity,
+  queueForReview,
+  type ResearchProfile,
+  type ReviewItem,
+} from "./entity-extraction";
+import type { inference } from "./inference";
+import { logDebug, logError } from "./log";
+import { logTokenUsage } from "./token-usage";
+
+export interface ResearchTarget {
+  kind: ExtractedEntity["kind"];
+  name: string;
+  slug: string;
+  organization: string;
+  fact: string;
+}
+
+export interface ResearchDeps {
+  principal: string;
+  infer: typeof inference;
+  today?: string;
+}
+
+const MAX_TARGETS = 3;
+const RESEARCH_TIMEOUT_MS = 480_000;
+
+function created(written: IngestResult["people"]): Set<string> {
+  return new Set(written.filter((w) => w.created).map((w) => w.slug));
+}
+
+function target(
+  kind: ResearchTarget["kind"],
+  name: string,
+  slug: string,
+  organization: string | null | undefined,
+  fact: string | null | undefined
+): ResearchTarget {
+  return { kind, name, slug, organization: organization ?? "", fact: fact ?? "" };
+}
+
+/** New companies, and new people with an organization to tell namesakes apart by. */
+export function newResearchTargets(
+  input: IngestInput,
+  written: IngestResult
+): ResearchTarget[] {
+  const newCompanies = created(written.companies);
+  const newPeople = created(written.people);
+  const companies = (input.companies ?? []).flatMap((c, i) => {
+    const slug = written.companies[i]?.slug ?? "";
+    return newCompanies.has(slug) ? [target("company", c.name, slug, "", c.context)] : [];
+  });
+  const people = (input.people ?? []).flatMap((p, i) => {
+    const slug = written.people[i]?.slug ?? "";
+    return newPeople.has(slug) && p.company
+      ? [target("person", p.name, slug, p.company, p.context)]
+      : [];
+  });
+  return [...companies, ...people].slice(0, MAX_TARGETS);
+}
+
+export function researchSchema() {
+  const text = { type: "string" as const };
+  const list = (items: Record<string, unknown>) => ({ type: "array" as const, items });
+  return closedObject({
+    match: { type: "string" as const, enum: ["sure", "unsure", "none"] },
+    summary: text,
+    role: text,
+    organization: text,
+    website: text,
+    linkedin: text,
+    socials: list(closedObject({ platform: text, url: text })),
+    registry: closedObject({
+      name: text,
+      number: text,
+      taxNumber: text,
+      seat: text,
+      status: text,
+      managers: list(text),
+      url: text,
+    }),
+    news: list(closedObject({ date: text, title: text, url: text })),
+    sources: list(text),
+  });
+}
+
+const CHECKLIST = {
+  company: [
+    "- 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.",
+    "- 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.",
+  ],
+  person: [
+    "- role and organization: their current position and employer.",
+    "- website: their own site, if they have one.",
+    "- linkedin: their LinkedIn profile.",
+    "- socials: their accounts on X, GitHub, Instagram, YouTube or similar.",
+    "- news: up to five recent news items, interviews, talks or public statements from the last 12 months, newest first.",
+    "- summary: two or three sentences on who they are and what they work on.",
+  ],
+};
+
+export function researchSystem(principal: string, kind: ResearchTarget["kind"]): string {
+  return [
+    `You research a ${kind} from ${principal}'s contact book on the web. Search the web and open pages; do not answer from memory.`,
+    "Find:",
+    ...CHECKLIST[kind],
+    "Rules:",
+    `- match: "sure" when what you found is clearly this ${kind} (the same name AND it fits what ${principal} said about them), "unsure" when you found namesakes and cannot tell which, "none" when you found nothing. Only "sure" profiles are kept.`,
+    "- Only state what a page you opened or a search result shows. Never guess a URL, number or date.",
+    "- Every URL must be one you saw. List every page you used in sources.",
+    "- Leave a field empty, or a list empty, when you did not find it.",
+    "- Dates as YYYY-MM-DD, or YYYY-MM when the day is not given.",
+  ].join("\n");
+}
+
+function researchUser(target: ResearchTarget, today: string): 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}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function parseProfile(output: string | undefined): ResearchProfile | null {
+  try {
+    return output ? (JSON.parse(output) as ResearchProfile) : null;
+  } catch {
+    return null;
+  }
+}
+
+function isWebUrl(url: string): boolean {
+  return /^https?:\/\/[^\s]+$/.test(url);
+}
+
+/** Drops any link that is not a plain http(s) URL, so the store never holds a guess dressed as one. */
+function withWebUrlsOnly(p: ResearchProfile): ResearchProfile {
+  const url = (u: string) => (isWebUrl(u) ? u : "");
+  return {
+    ...p,
+    website: url(p.website),
+    linkedin: url(p.linkedin),
+    socials: p.socials.filter((s) => isWebUrl(s.url)),
+    registry: { ...p.registry, url: url(p.registry.url) },
+    news: p.news.filter((n) => isWebUrl(n.url)),
+    sources: p.sources.filter(isWebUrl),
+  };
+}
+
+export type ResearchOutcome =
+  | { found: true; profile: ResearchProfile }
+  | { found: false; reason: string };
+
+export async function researchEntity(
+  target: ResearchTarget,
+  deps: ResearchDeps
+): Promise<ResearchOutcome> {
+  const result = await deps.infer({
+    system: researchSystem(deps.principal, target.kind),
+    user: researchUser(target, deps.today ?? new Date().toISOString().slice(0, 10)),
+    tier: "medium",
+    timeout: RESEARCH_TIMEOUT_MS,
+    jsonSchema: researchSchema(),
+    caller: "entity-research",
+    web: true,
+  });
+  if (result.usage) logTokenUsage("entity-research", result.usage);
+  const profile = result.success ? parseProfile(result.output) : null;
+  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() };
+  const checked = withWebUrlsOnly(profile);
+  if (checked.sources.length === 0) return { found: false, reason: "no sources given" };
+  return { found: true, profile: checked };
+}
+
+export function researchItem(
+  target: ResearchTarget,
+  profile: ResearchProfile
+): ReviewItem {
+  return {
+    id: crypto.randomUUID().slice(0, 8),
+    ts: new Date().toISOString(),
+    source: profile.sources[0],
+    reason: "web-profile",
+    entity: {
+      kind: target.kind,
+      name: target.name,
+      existing: target.slug,
+      aliases: [],
+      role: profile.role,
+      organization: profile.organization || target.organization,
+      relation: "",
+      fact: profile.summary,
+    },
+    candidates: target.slug ? [target.slug] : [],
+    profile,
+  };
+}
+
+async function researchOrLog(
+  target: ResearchTarget,
+  deps: ResearchDeps
+): Promise<ReviewItem[]> {
+  try {
+    const outcome = await researchEntity(target, deps);
+    if (outcome.found) return [researchItem(target, outcome.profile)];
+    logDebug("entity-research", `${target.slug}: ${outcome.reason}`);
+    return [];
+  } catch (err) {
+    logError(`entity-research:${target.slug}`, err);
+    return [];
+  }
+}
+
+export async function researchNewEntities(
+  targets: ResearchTarget[],
+  deps: ResearchDeps
+): Promise<void> {
+  const found = (await Promise.all(targets.map((t) => researchOrLog(t, deps)))).flat();
+  queueForReview(found);
+  logDebug("entity-research", `${found.length} of ${targets.length} found for review`);
+}
+
+function registryLines(r: ResearchProfile["registry"]): string[] {
+  const fields: Array<[string, string]> = [
+    ["Registered name", r.name],
+    ["Registration number", r.number],
+    ["Tax number", r.taxNumber],
+    ["Seat", r.seat],
+    ["Status", r.status],
+    ["Managing directors", r.managers.join(", ")],
+    ["Registry entry", r.url],
+  ];
+  return fields.filter(([, v]) => v).map(([k, v]) => `- ${k}: ${v}`);
+}
+
+function section(title: string, lines: string[]): string[] {
+  return lines.length > 0 ? ["", `**${title}**`, ...lines] : [];
+}
+
+/** The profile as markdown: what the review list shows and what an accepted entry keeps. */
+export function renderProfile(p: ResearchProfile): string {
+  const links = [
+    p.website && `- Website: ${p.website}`,
+    p.linkedin && `- LinkedIn: ${p.linkedin}`,
+    ...p.socials.map((s) => `- ${s.platform}: ${s.url}`),
+  ].filter((l): l is string => Boolean(l));
+  return [
+    p.summary,
+    ...section("Links", links),
+    ...section("Registry", registryLines(p.registry)),
+    ...section(
+      "News",
+      p.news.map((n) => `- ${n.date} ${n.title} (${n.url})`)
+    ),
+    ...section(
+      "Sources",
+      p.sources.map((s) => `- ${s}`)
+    ),
+  ].join("\n");
+}
+
+function socialKey(platform: string): string {
+  return platform.toLowerCase().replace(/[^a-z0-9]+/g, "") || "link";
+}
+
+function hostname(url: string): string | null {
+  return url ? new URL(url).hostname.replace(/^www\./, "") : null;
+}
+
+/** The accepted profile, written to the entry it was researched for. */
+export function profileIngest(item: ReviewItem, name: string): IngestInput {
+  const p = item.profile as ResearchProfile;
+  const slug = item.entity.existing || null;
+  const context = renderProfile(p);
+  if (item.entity.kind === "company")
+    return { companies: [{ name, slug, domain: hostname(p.website), context }] };
+  const social = Object.fromEntries(
+    [
+      ["website", p.website],
+      ["linkedin", p.linkedin],
+      ...p.socials.map((s) => [socialKey(s.platform), s.url]),
+    ].filter(([, url]) => url)
+  );
+  return {
+    people: [{ name, slug, title: p.role || null, social, context }],
+  };
+}

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

@@ -4,10 +4,11 @@
  */
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { ingestEntities } from "../../tools/knowledge/ingest";
+import { type IngestInput, ingestEntities } from "../../tools/knowledge/ingest";
 import { loadKnownEntities, loadNameIndex } from "./entity-cards";
 import { ingestInput, type ReviewItem, reviewQueueFile } from "./entity-extraction";
 import { indexedEntities, type NamedEntity, type NameIndex } from "./entity-names";
+import { profileIngest } from "./entity-research";
 
 export interface AcceptChoice {
   as?: string;
@@ -68,6 +69,22 @@ export function loadEntityReviewNudge(): string {
   ].join("\n");
 }
 
+function acceptedInput(
+  item: ReviewItem,
+  choice: AcceptChoice,
+  index: NameIndex
+): IngestInput {
+  if (!item.profile) {
+    const known = chosenEntity(item, choice.as, index);
+    return ingestInput(item.entity, index, known, choice.name);
+  }
+  const target = chosenEntity(item, choice.as ?? item.entity.existing, index);
+  return profileIngest(
+    { ...item, entity: { ...item.entity, existing: target?.slug ?? "" } },
+    target?.title ?? choice.name ?? item.entity.name
+  );
+}
+
 export function rejectReview(id: string): ReviewItem | null {
   return takeFromQueue(id);
 }
@@ -77,11 +94,7 @@ export function acceptReview(id: string, choice: AcceptChoice = {}): Accepted |
   const queued = pendingReviews().find((i) => i.id === id);
   if (!queued) return null;
   const index = loadNameIndex(loadKnownEntities());
-  const known = chosenEntity(queued, choice.as, index);
-  const result = ingestEntities(
-    ingestInput(queued.entity, index, known, choice.name),
-    queued.source
-  );
+  const result = ingestEntities(acceptedInput(queued, choice, index), queued.source);
   takeFromQueue(id);
   const written = result.people[0] ?? result.companies[0];
   return { item: queued, slug: written.slug, created: written.created };

package/src/hooks/lib/inference.ts

@@ -134,6 +134,13 @@ function previewRoute(): RoutePreview {
 }
 
 /** True if any inference path is currently usable (subscription CLI OR API key). */
+/** Routes whose CLI can be limited to web search and fetch alone. */
+function canSearchWeb(): boolean {
+  if (isClaude() && hasClaudeBinary()) return true;
+  if (isCodex() && hasCodexBinary()) return true;
+  return isCopilot() && hasCopilotBinary();
+}
+
 export function canInfer(): boolean {
   if (isClaude() && hasClaudeBinary()) return true;
   if (isCodex() && hasCodexBinary()) return true;
@@ -158,6 +165,8 @@ interface InferenceOptions {
   caller?: string;
   /** Session ID the call is associated with — appears in debug logs as sessionId=X */
   sessionId?: string;
+  /** Let the model search and read the web, and nothing else; a route that can't fails */
+  web?: boolean;
 }
 
 interface InferenceResult {
@@ -210,6 +219,10 @@ async function routeInference(opts: InferenceOptions): Promise<InferenceResult>
   const caller = opts.caller ?? "anonymous";
   const session = opts.sessionId ?? "-";
   const tag = `caller=${caller} sessionId=${session}`;
+  if (opts.web && !canSearchWeb()) {
+    logDebug("inference", `${tag} refuse: no web route agent=${agent}`);
+    return { success: false, error: `web research is not available on ${agent} yet` };
+  }
   if (isClaude()) {
     const bin = getClaudeBinary();
     if (bin) {
@@ -342,6 +355,15 @@ function hasAntigravityBinary(): boolean {
  * line. System, user and any JSON-schema instruction all travel together on
  * stdin instead, the same way every other agent receives them.
  */
+const CLAUDE_WEB_TOOLS = "WebSearch,WebFetch";
+
+/** --tools alone makes the web tools visible; --allowed-tools spares them the prompt. */
+function claudeTools(opts: InferenceOptions): string[] {
+  return opts.web
+    ? ["--tools", CLAUDE_WEB_TOOLS, "--allowed-tools", CLAUDE_WEB_TOOLS]
+    : ["--tools", ""];
+}
+
 export function buildClaudeArgs(
   opts: InferenceOptions,
   systemPromptFile?: string
@@ -350,8 +372,7 @@ export function buildClaudeArgs(
     "--print",
     "--model",
     modelFor("claude-spawn", opts),
-    "--tools",
-    "",
+    ...claudeTools(opts),
     "--output-format",
     "text",
     "--setting-sources",
@@ -447,6 +468,7 @@ export function buildCodexArgs(opts: InferenceOptions): string[] {
     "--sandbox",
     "read-only",
     "--ephemeral",
+    ...(opts.web ? ["-c", "web_search=live"] : []),
   ];
 }
 
@@ -584,6 +606,8 @@ async function inferenceViaAntigravitySpawn(
  *                                naming an unknown tool hides every tool
  *   --deny-tool=…             → backstop: deny rules win over any allow rule
  *   --silent                  → keeps the tool-filter notices out of stdout
+ *   web: only web_fetch, pre-approved for every URL; Copilot has no search tool,
+ *        so it fetches search pages itself
  *
  * Copilot has no --system-prompt flag, so system + user + JSON-schema are
  * concatenated into one prompt delivered on stdin. `-p/--prompt` is deliberately
@@ -591,20 +615,25 @@ async function inferenceViaAntigravitySpawn(
  * survive cmd.exe when Bun.spawn resolves copilot to its Windows .cmd shim.
  * Piping stdin keeps copilot non-interactive, so dropping -p costs nothing.
  */
-export function buildCopilotArgs(_opts: InferenceOptions): string[] {
+export function buildCopilotArgs(opts: InferenceOptions): string[] {
   return [
     "--no-custom-instructions",
     "--disable-builtin-mcps",
     "--no-auto-update",
     "--no-color",
     "--silent",
-    "--available-tools=none",
+    ...copilotTools(opts),
     "--deny-tool=shell",
     "--deny-tool=write",
-    "--deny-tool=url",
   ];
 }
 
+function copilotTools(opts: InferenceOptions): string[] {
+  return opts.web
+    ? ["--available-tools=web_fetch", "--allow-tool=web_fetch", "--allow-all-urls"]
+    : ["--available-tools=none", "--deny-tool=url"];
+}
+
 /**
  * Extract the agent's text reply from opencode --format json NDJSON output.
  * Concatenates all `type:"text"` event payloads in order. Returns empty

package/src/hooks/lib/token-usage.ts

@@ -15,6 +15,7 @@ type TokenCaller =
   | "session-name"
   | "session-intelligence"
   | "entity-extraction"
+  | "entity-research"
   | "relationship"
   | "self-model"
   | "agenda-serves"