portable-agent-layer 0.92.0 → 0.94.0

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

@@ -0,0 +1,101 @@
+/**
+ * The user's answers to the extraction review queue: an accepted item is written
+ * to the entity the user names (or a new one), a rejected one is dropped.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+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;
+  name?: string;
+}
+
+export interface Accepted {
+  item: ReviewItem;
+  slug: string;
+  created: boolean;
+}
+
+function parseItem(line: string): ReviewItem[] {
+  try {
+    return [JSON.parse(line) as ReviewItem];
+  } catch {
+    return [];
+  }
+}
+
+export function pendingReviews(): ReviewItem[] {
+  const file = reviewQueueFile();
+  if (!existsSync(file)) return [];
+  return readFileSync(file, "utf-8").split("\n").filter(Boolean).flatMap(parseItem);
+}
+
+function takeFromQueue(id: string): ReviewItem | null {
+  const items = pendingReviews();
+  const item = items.find((i) => i.id === id);
+  if (!item) return null;
+  const rest = items.filter((i) => i !== item);
+  writeFileSync(reviewQueueFile(), rest.map((i) => `${JSON.stringify(i)}\n`).join(""));
+  return item;
+}
+
+function chosenEntity(
+  item: ReviewItem,
+  slug: string | undefined,
+  index: NameIndex
+): NamedEntity | null {
+  if (!slug) return null;
+  const domain = item.entity.kind === "person" ? "People" : "Companies";
+  const entity = indexedEntities(index).find(
+    (e) => e.domain === domain && e.slug === slug
+  );
+  if (!entity) throw new Error(`no ${domain} entry with slug "${slug}"`);
+  return entity;
+}
+
+export function loadEntityReviewNudge(): string {
+  const count = pendingReviews().length;
+  if (count === 0) return "";
+  const waiting =
+    count === 1 ? "1 person or company waits" : `${count} people or companies wait`;
+  return [
+    "## Entity Review Due",
+    `👥 ${waiting} for the user's answer before the knowledge store records them — offer \`pal cli knowledge review\`.`,
+  ].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);
+}
+
+/** Writes the item to `as` when given, else to a new entity named `name` or as extracted. */
+export function acceptReview(id: string, choice: AcceptChoice = {}): Accepted | null {
+  const queued = pendingReviews().find((i) => i.id === id);
+  if (!queued) return null;
+  const index = loadNameIndex(loadKnownEntities());
+  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"] : []),
   ];
 }
 
@@ -580,8 +602,12 @@ async function inferenceViaAntigravitySpawn(
  *   --disable-builtin-mcps    → no MCP servers in the child (extra safety)
  *   --no-auto-update          → prevent CLI self-update from delaying the spawn
  *   --no-color                → clean stdout for capture
- *   --allow-all-tools         → REQUIRED for non-interactive mode (without it,
- *                                copilot prompts for tool-use confirmation)
+ *   --available-tools=none    → Copilot has no "no tools" flag; an allowlist
+ *                                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
@@ -589,16 +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",
-    "--allow-all-tools",
+    "--silent",
+    ...copilotTools(opts),
+    "--deny-tool=shell",
+    "--deny-tool=write",
   ];
 }
 
+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/stop.ts

@@ -168,6 +168,7 @@ export async function runStopHandlers(
   // any in-hook budget. These spawn detached bun subprocesses that run the
   // inference and write results to disk; they don't block this hook.
   await detachSessionIntelligence(transcript, options.sessionId);
+  await detachEntityExtraction(transcript, options.sessionId);
   await detachFailurePrinciple(transcript);
   detachAgenda(options.sessionId);
   // Failure auto-graduation is intentionally NOT wired here: every pattern it
@@ -325,6 +326,24 @@ async function detachSessionIntelligence(
   }
 }
 
+async function detachEntityExtraction(
+  transcript: string,
+  sessionId?: string
+): Promise<void> {
+  if (!sessionId) return;
+  try {
+    const transcriptPath = await writeTranscriptTmp(transcript);
+    const scriptPath = resolve(assets.hooks(), "handlers", "entity-extraction.ts");
+    spawnDetachedInference(
+      scriptPath,
+      ["--run", sessionId, transcriptPath],
+      "entity-extraction"
+    );
+  } catch (err) {
+    logError("detachEntityExtraction", err);
+  }
+}
+
 /**
  * If a pending-failure exists, rename it to a unique path (race-free claim),
  * write the transcript to tmp, spawn the failure-principle handler detached.

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

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

package/src/tools/knowledge/ingest.ts

@@ -29,7 +29,14 @@ import {
 
 // --- Public input shape -----------------------------------------------------
 
-export interface PersonInput {
+interface Addressing {
+  aliases?: string[] | null;
+  relation?: string | null;
+  /** The stored file to update, when its slug is not derived from the name or domain. */
+  slug?: string | null;
+}
+
+export interface PersonInput extends Addressing {
   name: string;
   role?: string | null;
   title?: string | null;
@@ -40,7 +47,7 @@ export interface PersonInput {
   [extra: string]: unknown;
 }
 
-export interface CompanyInput {
+export interface CompanyInput extends Addressing {
   name: string;
   domain?: string | null;
   industry?: string | null;
@@ -201,7 +208,17 @@ function newPersonEntity(input: PersonInput, slug: string): Entity {
   if (Object.keys(socials).length > 0) {
     fm.socials = Object.entries(socials).map(([k, v]) => `${k}:${v}`);
   }
-  return { domain: "People", slug, frontmatter: fm, body: "" };
+  return { domain: "People", slug, frontmatter: withAddressing(fm, input), body: "" };
+}
+
+/** How the user refers to an entity and stands towards it — both only ever grow. */
+function withAddressing(fm: EntityFrontmatter, input: Addressing): EntityFrontmatter {
+  const prior = Array.isArray(fm.aliases) ? (fm.aliases as string[]) : undefined;
+  const aliases = mergeStringArray(prior, input.aliases ?? undefined);
+  if (aliases.length > 0) fm.aliases = aliases;
+  const relation = mergeScalar(fm.relation, input.relation);
+  if (relation) fm.relation = relation;
+  return fm;
 }
 
 function newCompanyEntity(input: CompanyInput, slug: string): Entity {
@@ -220,7 +237,7 @@ function newCompanyEntity(input: CompanyInput, slug: string): Entity {
   if (input.industry) fm.industry = input.industry;
   if (input.mentioned_as) fm.mentioned_as = input.mentioned_as;
   if (input.sentiment) fm.sentiment = input.sentiment;
-  return { domain: "Companies", slug, frontmatter: fm, body: "" };
+  return { domain: "Companies", slug, frontmatter: withAddressing(fm, input), body: "" };
 }
 
 function mergePerson(prior: Entity, input: PersonInput): Entity {
@@ -248,7 +265,7 @@ function mergePerson(prior: Entity, input: PersonInput): Entity {
   if (Object.keys(socials).length > 0) {
     fm.socials = Object.entries(socials).map(([k, v]) => `${k}:${v}`);
   }
-  return { ...prior, frontmatter: fm };
+  return { ...prior, frontmatter: withAddressing(fm, input) };
 }
 
 function mergeCompany(prior: Entity, input: CompanyInput): Entity {
@@ -260,7 +277,7 @@ function mergeCompany(prior: Entity, input: CompanyInput): Entity {
   if (input.industry) {
     fm.tags = mergeStringArray(fm.tags, industryToTopicTags(input.industry));
   }
-  return { ...prior, frontmatter: fm };
+  return { ...prior, frontmatter: withAddressing(fm, input) };
 }
 
 function upsertPerson(
@@ -268,7 +285,7 @@ function upsertPerson(
   sourceId: string,
   rootDir?: string
 ): UpsertResult {
-  const slug = slugify(input.name);
+  const slug = input.slug || slugify(input.name);
   if (!slug) throw new Error(`ingest: cannot slugify person name "${input.name}"`);
   const prior = load("People", slug, rootDir);
   const created = prior === null;
@@ -294,7 +311,7 @@ function upsertCompany(
   rootDir?: string
 ): UpsertResult {
   const baseKey = input.domain?.trim() ? input.domain : input.name;
-  const slug = slugify(baseKey);
+  const slug = input.slug || slugify(baseKey);
   if (!slug) throw new Error(`ingest: cannot slugify company "${input.name}"`);
   const prior = load("Companies", slug, rootDir);
   const created = prior === null;