@indigoai-us/hq-cli 5.287.0 → 5.289.0

package/dist/lib/bot/run.js

@@ -52,7 +52,7 @@ import * as path from "node:path";
 import { fullJitterDelayMs } from "../mesh/live/backoff.js";
 import { acquirePidLock, defaultPidLockDeps, releasePidLock } from "../mesh/live/daemon/pid-lock.js";
 import { BotApiError } from "./api.js";
-import { effectiveBotCompanies, effectiveBotKind, patchBotConfig, readBotConfig, SETUP_BOT_WORKER_ID } from "./config.js";
+import { effectiveBotCompanies, effectiveBotKind, patchBotConfig, readBotConfig, resolveBotMemoryDir, SETUP_BOT_WORKER_ID } from "./config.js";
 import { ensureBotSessionMeta } from "./company-bind.js";
 import { readBotCredsIdentity } from "./creds.js";
 import { isProcessed, markProcessed, readInboxState } from "./inbox-state.js";
@@ -61,6 +61,7 @@ import { containsNoReplySentinel, ProgressPoster, } from "./progress.js";
 import { splitBody } from "./split.js";
 import { createBotLogger } from "./log.js";
 import { buildSystemPrompt, introDmText, readPromptSources } from "./prompt.js";
+import { loadSetupExplainer, patchSetupIntroState, readSetupIntroState, readSetupProgressIntro, replyOffersExplain, SETUP_EXPLAINED_NOTE, setupExplainDue, } from "./setup-explain.js";
 import { FALLBACK_CLAUDE_PERMISSION_MODE, isClaudeBypassDisabled } from "./runtime/claude.js";
 import { runRuntimeTurn, RuntimeError } from "./runtime/index.js";
 import { botAttachmentsDir, dmSessionScope } from "./paths.js";
@@ -296,6 +297,26 @@ export async function runBot(deps) {
     const turnCwd = config.hqRoot;
     // HQ's setup bot is a guided conversation: no "working on it" filler between steps.
     const isSetupBot = config.workerId === SETUP_WORKER_ID;
+    /**
+     * Setup bot, owner DM: remember whether the bot's latest reply asked the
+     * explain-or-jump question, so a click on "Explain HQ first" can be answered
+     * at once (setup-explain.ts). Never lets a bookkeeping error touch the turn.
+     */
+    const noteSetupReply = (reply) => {
+        if (!isSetupBot)
+            return;
+        try {
+            const offered = replyOffersExplain(reply);
+            const current = readSetupIntroState(dir);
+            if (offered && !current.offeredAt)
+                patchSetupIntroState(dir, { offeredAt: now().toISOString() });
+            else if (!offered && current.offeredAt)
+                patchSetupIntroState(dir, { offeredAt: undefined });
+        }
+        catch (err) {
+            log("warn", `setup intro state not updated: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
     // Scheduled runs are reported in the owner's own zone: "every weekday at 9am"
     // was set up here, so "due 13:00 UTC" would read as the wrong time.
     const timeZone = machineTimeZone();
@@ -1105,6 +1126,7 @@ export async function runBot(deps) {
                 return;
             }
             clearInflight(dir, KICKOFF_MESSAGE_ID);
+            noteSetupReply(outcome.reply);
             if (readBotConfig(dir)?.kickoffPendingSignIn)
                 patchBotConfig(dir, { kickoffPendingSignIn: false });
             const st = readStatus();
@@ -1323,6 +1345,54 @@ export async function runBot(deps) {
             await finish("failed", 0, `${FAILURE_LIMIT} model failures in 10 minutes; last: ${outcome.excerpt}`);
         }
     };
+    /**
+     * The instant answer to "Explain HQ first" (setup-explain.ts). Returns true
+     * when it answered the message (sent, marked processed, acked); false sends
+     * the message down the normal model path, so nothing here can leave a
+     * message unanswered.
+     */
+    const sendSetupExplanation = async (item, text, attachments) => {
+        const id = item.messageId;
+        let reply;
+        try {
+            const due = setupExplainDue({
+                text,
+                attachments,
+                state: readSetupIntroState(dir),
+                progress: readSetupProgressIntro(resolveBotMemoryDir(config)),
+            });
+            if (!due)
+                return false;
+            const explainer = loadSetupExplainer(config.hqRoot, config.workerDir);
+            if (!explainer) {
+                log("warn", `no usable explain-hq.md in ${config.workerDir}; answering ${id} with a model turn`);
+                return false;
+            }
+            reply = explainer.reply;
+        }
+        catch (err) {
+            log("warn", `setup explanation check failed (${err instanceof Error ? err.message : String(err)}); answering ${id} with a model turn`);
+            return false;
+        }
+        try {
+            await sendToTarget({ kind: "dm", peerUid: config.ownerUid }, reply, item.rootEventId, "human");
+        }
+        catch (err) {
+            log("warn", `setup explanation for ${id} could not be sent (${err instanceof Error ? err.message : String(err)}); answering with a model turn`);
+            return false;
+        }
+        markProcessed(dir, id, now().toISOString());
+        try {
+            patchSetupIntroState(dir, { explainedAt: now().toISOString(), notePending: true, offeredAt: undefined });
+        }
+        catch (err) {
+            log("warn", `setup intro state not updated: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await api.ackInbox(config.agentUid, id);
+        setStatus({ repliesSent: (readStatus()?.repliesSent ?? 0) + 1, lastActivityAt: now().toISOString() });
+        log("info", `answered ${id} with the setup explanation (no model turn)`);
+        return true;
+    };
     const handleItem = async (item) => {
         const id = item.messageId;
         const inboxState = readInboxState(dir);
@@ -1381,6 +1451,11 @@ export async function runBot(deps) {
             await api.ackInbox(config.agentUid, id);
             return;
         }
+        // Setup bot: "Explain HQ first" clicked while that question is pending is
+        // answered with the fixed explanation, with no model turn.
+        const ownerDm = target.kind === "dm" && target.peerUid === config.ownerUid;
+        if (isSetupBot && ownerDm && (await sendSetupExplanation(item, messageText, attachmentRefs.length)))
+            return;
         const attempt = (attempts.get(id) ?? 0) + 1;
         attempts.set(id, attempt);
         const reactionId = item.eventId ?? id;
@@ -1441,7 +1516,10 @@ export async function runBot(deps) {
             text = text ? `${text}\n\n${block}` : block;
         }
         const sessionScope = target.kind === "room" ? target.sessionScope : dmSessionScope(target.peerUid, config.ownerUid);
-        const prompt = target.kind === "room" ? await buildRoomTurn(item, target, text) : target.peerUid === config.ownerUid ? text :
+        // The turn after the app sent the explanation: tell the model it went out.
+        const setupNote = isSetupBot && ownerDm && readSetupIntroState(dir).notePending === true;
+        const ownerText = setupNote ? `${SETUP_EXPLAINED_NOTE}\n\n${text}` : text;
+        const prompt = target.kind === "room" ? await buildRoomTurn(item, target, text) : target.peerUid === config.ownerUid ? ownerText :
             `[HQ DM sender: ${target.peerUid}; owner: ${config.ownerUid}; sender is not the owner.]\n\n${text}`;
         const markerTarget = target.kind === "dm" ? { kind: "dm", peerUid: target.peerUid } : { kind: "room", channelId: target.channelId };
         const { send, sendFinal, saved } = trackingSend(markerTarget, item.rootEventId);
@@ -1463,6 +1541,18 @@ export async function runBot(deps) {
                 ? { afterProgressPost: () => api.postAgentStatus(target.channelId, ROOM_THINKING_STATUS, target.rootEventId) }
                 : {}),
         });
+        // The model saw the note once its turn ran. A turn that never started, or
+        // one held for a coding-tool sign-in, runs again and keeps the note for it.
+        if (setupNote && (outcome.ok || (outcome.started && !isRuntimeSignInFailure(outcome.excerpt)))) {
+            try {
+                patchSetupIntroState(dir, { notePending: false });
+            }
+            catch (err) {
+                log("warn", `setup intro state not updated: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        if (outcome.ok && ownerDm)
+            noteSetupReply(outcome.reply);
         if (outcome.ok) {
             // A no_reply sentinel or intentionally empty reply: ack silently, post nothing.
             if (outcome.silent) {

package/dist/lib/bot/setup-explain.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The setup bot's instant "Explain HQ first" answer.
+ *
+ * The setup bot's first question is whether to explain HQ or jump straight in,
+ * with "Explain HQ first" as a suggested reply. The explanation is fixed text,
+ * so a click on that button does not need a model turn: the runner sends the
+ * text from the setup worker's `skills/explain-hq.md` at once, and the bot's
+ * next turn starts with a note saying the explanation already went out.
+ *
+ * The text has one home, the worker file. The model reads the same file when
+ * someone asks for the explanation in their own words, so the two paths never
+ * drift. Anything unexpected (file missing or malformed, the question not
+ * pending, any other message) falls back to the normal model turn.
+ */
+/** The suggested reply that triggers the instant answer. Exact match only. */
+export declare const EXPLAIN_HQ_SUGGESTION = "Explain HQ first";
+/** Where the explanation lives, relative to the setup worker folder. */
+export declare const EXPLAIN_HQ_FILE: string;
+/** The setup bot's progress note in its memory folder (setup worker.yaml). */
+export declare const SETUP_PROGRESS_FILE = "setup-progress.md";
+/** Runner-owned state, in the bot's own folder (never the model's memory). */
+export declare const SETUP_INTRO_STATE_FILE = "setup-intro.json";
+/**
+ * Put in front of the next message from the person, so the model knows the
+ * explanation went out without it. It never reaches the person.
+ */
+export declare const SETUP_EXPLAINED_NOTE: string;
+export interface SetupExplainer {
+    /** The explanation, word for word (shared with the model path). */
+    explanation: string;
+    /** What the app adds after it: a line offering to continue, and suggestions. */
+    closing: string;
+    /** The whole message the app sends. */
+    reply: string;
+}
+/** Parse the worker file. Null when it is not the shape the app can send. */
+export declare function parseSetupExplainer(body: string): SetupExplainer | null;
+/** Read the explanation from the setup worker folder the bot runs. */
+export declare function loadSetupExplainer(hqRoot: string, workerDir: string): SetupExplainer | null;
+export type SetupProgressIntro = "asked" | "answered" | "finished" | null;
+/** What the model's progress note says about the opening question. */
+export declare function readSetupProgressIntro(memoryDir: string): SetupProgressIntro;
+export interface SetupIntroState {
+    v: 1;
+    /** The bot's latest owner-DM reply asked the explain-or-jump question. */
+    offeredAt?: string;
+    /** The app sent the explanation (never sent twice). */
+    explainedAt?: string;
+    /** The model has not yet been told that the explanation went out. */
+    notePending?: boolean;
+}
+export declare function readSetupIntroState(dir: string): SetupIntroState;
+export declare function patchSetupIntroState(dir: string, patch: Partial<Omit<SetupIntroState, "v">>): SetupIntroState;
+/** A bot reply that asks the explain-or-jump question (the words or the button). */
+export declare function replyOffersExplain(reply: string): boolean;
+/**
+ * The instant answer is due only when ALL of these hold: the message is exactly
+ * the button text with nothing attached, the question is pending (the bot's
+ * last reply offered it, or its note says it asked), and the explanation has
+ * not gone out yet (neither by the app nor, per the note, by the model).
+ */
+export declare function setupExplainDue(input: {
+    text: string;
+    attachments: number;
+    state: SetupIntroState;
+    progress: SetupProgressIntro;
+}): boolean;
+//# sourceMappingURL=setup-explain.d.ts.map

package/dist/lib/bot/setup-explain.js

@@ -0,0 +1,141 @@
+/**
+ * The setup bot's instant "Explain HQ first" answer.
+ *
+ * The setup bot's first question is whether to explain HQ or jump straight in,
+ * with "Explain HQ first" as a suggested reply. The explanation is fixed text,
+ * so a click on that button does not need a model turn: the runner sends the
+ * text from the setup worker's `skills/explain-hq.md` at once, and the bot's
+ * next turn starts with a note saying the explanation already went out.
+ *
+ * The text has one home, the worker file. The model reads the same file when
+ * someone asks for the explanation in their own words, so the two paths never
+ * drift. Anything unexpected (file missing or malformed, the question not
+ * pending, any other message) falls back to the normal model turn.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** The suggested reply that triggers the instant answer. Exact match only. */
+export const EXPLAIN_HQ_SUGGESTION = "Explain HQ first";
+/** Where the explanation lives, relative to the setup worker folder. */
+export const EXPLAIN_HQ_FILE = path.join("skills", "explain-hq.md");
+/** The setup bot's progress note in its memory folder (setup worker.yaml). */
+export const SETUP_PROGRESS_FILE = "setup-progress.md";
+/** Runner-owned state, in the bot's own folder (never the model's memory). */
+export const SETUP_INTRO_STATE_FILE = "setup-intro.json";
+const EXPLANATION_HEADING = /^##[ \t]+The explanation[ \t]*$/m;
+const CLOSING_HEADING = /^##[ \t]+After the explanation, when the app sends it[ \t]*$/m;
+/**
+ * Put in front of the next message from the person, so the model knows the
+ * explanation went out without it. It never reaches the person.
+ */
+export const SETUP_EXPLAINED_NOTE = `[Note from the HQ app: the person clicked "${EXPLAIN_HQ_SUGGESTION}", and the app already sent them the explanation ` +
+    `from skills/explain-hq.md word for word, ending by asking whether to start the setup. The explain-or-jump question is answered. ` +
+    "Write `Intro: explained` in your progress note, do not explain HQ again, and carry on with the first unfinished setup step. " +
+    "Their reply to that message follows.]";
+/** The text between a heading and the next `## ` heading (or the end). */
+function sectionAfter(body, heading) {
+    const match = heading.exec(body);
+    if (!match)
+        return null;
+    const rest = body.slice(match.index + match[0].length);
+    const next = /^##[ \t]/m.exec(rest);
+    return (next ? rest.slice(0, next.index) : rest).trim();
+}
+/** True when the closing carries exactly one well-formed suggestions block. */
+function hasSuggestionsBlock(closing) {
+    const fence = /^```hq-block\n(.+)\n```$/m.exec(closing);
+    if (!fence)
+        return false;
+    try {
+        const parsed = JSON.parse(fence[1]);
+        const block = parsed.blocks?.[0];
+        return (parsed.v === 1 &&
+            block?.kind === "suggestions" &&
+            Array.isArray(block.items) &&
+            block.items.length >= 2 &&
+            block.items.every((item) => typeof item === "string" && item.trim().length > 0));
+    }
+    catch {
+        return false;
+    }
+}
+/** Parse the worker file. Null when it is not the shape the app can send. */
+export function parseSetupExplainer(body) {
+    const text = body.replace(/\r\n/g, "\n");
+    const explanation = sectionAfter(text, EXPLANATION_HEADING);
+    const closing = sectionAfter(text, CLOSING_HEADING);
+    if (!explanation || !closing)
+        return null;
+    // The closing must end with the block (nothing after it) so the app shows the buttons.
+    if (!closing.endsWith("```") || !hasSuggestionsBlock(closing))
+        return null;
+    return { explanation, closing, reply: `${explanation}\n\n${closing}` };
+}
+/** Read the explanation from the setup worker folder the bot runs. */
+export function loadSetupExplainer(hqRoot, workerDir) {
+    try {
+        return parseSetupExplainer(fs.readFileSync(path.resolve(hqRoot, workerDir, EXPLAIN_HQ_FILE), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** What the model's progress note says about the opening question. */
+export function readSetupProgressIntro(memoryDir) {
+    let note;
+    try {
+        note = fs.readFileSync(path.join(memoryDir, SETUP_PROGRESS_FILE), "utf8");
+    }
+    catch {
+        return null;
+    }
+    if (/^Status:[ \t]*finished/im.test(note))
+        return "finished";
+    if (/^Intro:[ \t]*(explained|skipped)\b/im.test(note))
+        return "answered";
+    if (/^Intro:[ \t]*asked\b/im.test(note))
+        return "asked";
+    return null;
+}
+export function readSetupIntroState(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, SETUP_INTRO_STATE_FILE), "utf8"));
+        return parsed && parsed.v === 1 ? parsed : { v: 1 };
+    }
+    catch {
+        return { v: 1 };
+    }
+}
+export function patchSetupIntroState(dir, patch) {
+    const next = { ...readSetupIntroState(dir), ...patch, v: 1 };
+    for (const key of Object.keys(next)) {
+        if (next[key] === undefined)
+            delete next[key];
+    }
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const dest = path.join(dir, SETUP_INTRO_STATE_FILE);
+    const tmp = `${dest}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, dest);
+    return next;
+}
+/** A bot reply that asks the explain-or-jump question (the words or the button). */
+export function replyOffersExplain(reply) {
+    return reply.includes(`"${EXPLAIN_HQ_SUGGESTION}"`) || /explain HQ to you/i.test(reply);
+}
+/**
+ * The instant answer is due only when ALL of these hold: the message is exactly
+ * the button text with nothing attached, the question is pending (the bot's
+ * last reply offered it, or its note says it asked), and the explanation has
+ * not gone out yet (neither by the app nor, per the note, by the model).
+ */
+export function setupExplainDue(input) {
+    if (input.text !== EXPLAIN_HQ_SUGGESTION || input.attachments > 0)
+        return false;
+    if (input.state.explainedAt)
+        return false;
+    if (input.progress === "answered" || input.progress === "finished")
+        return false;
+    return Boolean(input.state.offeredAt) || input.progress === "asked";
+}
+//# sourceMappingURL=setup-explain.js.map

package/dist/lib/checkpoint-ontology/merge-copies.d.ts

@@ -42,7 +42,7 @@ export declare const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
  * names differ only in spacing, case or punctuation (CO-65).
  */
 export declare const MERGE_VARIANTS_FLAG = "checkpoint.ontology.merge-variants";
-export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy";
+export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy" | "not_listed";
 export type PairKind = "numbered" | "variants";
 export interface CopySkip {
     copy: string;
@@ -55,6 +55,11 @@ export interface CopyPair {
     /** Company-relative path of the original it merges into. */
     original: string;
 }
+/** One entry of a `--only` list: an exact copy -> original pair. */
+export interface ListedPair {
+    copy: string;
+    original: string;
+}
 export interface CopyPlan extends CopyPair {
     add_aliases: string[];
     /** Copy names the original lacks that another entity already holds, so they do not move. */
@@ -98,6 +103,8 @@ export interface MergeCopiesReport {
         path: string;
         error: string;
     }[];
+    /** Listed entries the finder did not produce. Absent unless `--only` was set. */
+    only_unmatched?: ListedPair[];
     /** Entity-file links whose target file does not exist. */
     broken_links_before: number;
     broken_links_after: number;
@@ -114,6 +121,8 @@ export interface MergeCopiesOptions {
     pairKind?: PairKind;
     /** Handle at most this many copies (sorted by path). */
     limit?: number;
+    /** Handle only these exact pairs; every other found pair is skipped as `not_listed`. */
+    only?: ListedPair[];
     now: Date;
     deleteVaultKey?: DeleteVaultKey;
 }

package/dist/lib/checkpoint-ontology/merge-copies.js

@@ -500,7 +500,10 @@ export async function mergeCopies(options) {
     const index = buildEntityIndex(company.dir);
     const pairKind = options.pairKind ?? "numbered";
     const found = pairKind === "variants" ? findVariantPairs(index) : findCopyPairs(index);
-    const pairs = options.limit !== undefined ? found.pairs.slice(0, Math.max(0, options.limit)) : found.pairs;
+    const listed = options.only
+        ? found.pairs.filter((pair) => options.only.some((entry) => entry.copy === pair.copy && entry.original === pair.original))
+        : found.pairs;
+    const pairs = options.limit !== undefined ? listed.slice(0, Math.max(0, options.limit)) : listed;
     const before = scanLinks(company).broken;
     const { plans, merges, finals, notReady } = plan(company, index, pairs, found.pairs, now);
     const report = {
@@ -511,7 +514,19 @@ export async function mergeCopies(options) {
         duplicate_groups_after: 0,
         copies_found: found.pairs.length,
         plans,
-        skipped: found.skipped,
+        skipped: options.only
+            ? [
+                ...found.skipped,
+                ...found.pairs
+                    .filter((pair) => !listed.includes(pair))
+                    .map((pair) => ({ copy: pair.copy, reason: "not_listed" })),
+            ]
+            : found.skipped,
+        ...(options.only
+            ? {
+                only_unmatched: options.only.filter((entry) => !found.pairs.some((pair) => pair.copy === entry.copy && pair.original === entry.original)),
+            }
+            : {}),
         merged: [],
         relinked: [],
         deleted: [],

package/dist/lib/checkpoint-ontology/plan.d.ts

@@ -20,99 +20,12 @@ export declare const ONTOLOGY_FLAG = "checkpoint.ontology";
  * 6.18.7 or later; see ./sync-client.ts.
  */
 export declare const ONTOLOGY_SYNC_GATED_FLAG = "checkpoint.ontology.sync-gated";
-export declare const COMPANY_BRIEF_FLAG = "checkpoint.ontology.company-brief";
-/**
- * Applies only when the payload's sibling backend is grok. On gold-v2, Claude
- * with stripped inputs lost 0.139 recall; Grok with stripped inputs gained
- * precision without losing recall. A machine that falls back from grok keeps
- * the annotated inputs.
- */
-export declare const IGNORE_ANNOTATIONS_FLAG = "checkpoint.ontology.ignore-annotations";
-/**
- * With `--backend auto`, `hq core checkpoint` tries grok first for this
- * company. Read here, in the detached sibling, and recorded in the company's
- * state directory, so the foreground checkpoint makes no network call.
- */
-export declare const GROK_BACKEND_FLAG = "checkpoint.ontology.grok-backend";
 /**
  * Several writers in one company vault (design section 20): record written
  * entity bytes in the outbox, merge back set-aside versions, and report
  * duplicate entities.
  */
 export declare const MULTI_WRITER_FLAG = "checkpoint.ontology.multi-writer";
-/**
- * A candidate that links to an existing entity adds no aliases to it; the plan
- * carries `link_aliases: false` and apply honours it. CO-42: most aliases
- * written through links on the CO-41 runs were other things the text named
- * next to the entity (`Publisher` on indigo, `Stripe Connect` on Stripe), and
- * entity-hints multiplied them (22 aliases on a flag-off run, 45 and 125 on two
- * hinted runs).
- */
-export declare const NO_LINK_ALIASES_FLAG = "checkpoint.ontology.no-link-aliases";
-/**
- * A person the input and the company's entities give only a first name for is
- * named by that first name instead of being left out. CO-44: on the CO-41
- * grok-4.6 runs the model read "not a first name alone" as "skip them", and
- * dropped people such as Amir and Sebastian, whose own entities carry only a
- * first name. People were 24 of the 138 missed gold entities over three runs.
- * The plan carries `first_name_people: true`, and apply then defers a one-word
- * person whose word starts an existing person's fuller name or alias, since
- * the model cannot see that `John Smith` already exists.
- */
-export declare const FIRST_NAME_PEOPLE_FLAG = "checkpoint.ontology.first-name-people";
-/**
- * A knowledge input does not link to a concept entity whose canonical name is
- * also the canonical name of an entity of another type (`concept/hq-secrets`
- * beside `project/hq-secrets`). The plan carries
- * `skip_ambiguous_concept_links: true`, and apply rejects the link as
- * `ambiguous_type`. CO-46: 34 of the 73 false positives on the knowledge
- * fixtures were such concept links; skipping them raised precision from 0.733
- * to 0.803 and cost recall 0.023 on a replay of six runs.
- */
-export declare const SKIP_AMBIGUOUS_CONCEPT_LINKS_FLAG = "checkpoint.ontology.skip-ambiguous-concept-links";
-/**
- * A knowledge link to the weaker of two entities that share a canonical name
- * across types is redirected to the sibling other entity files link to
- * (`project/build-your-own-agi` beside `concept/build-your-own-agi`, or
- * `project/hq-core 2` beside `project/hq-core` when a concept also holds the
- * name). The plan carries `dominant_sibling_link: true`, and apply reports
- * the move in `dominant_sibling_redirects` without writing the entity files.
- * CO-60: a replay of six runs raised knowledge precision from 0.725 to 0.754
- * and recall from 0.784 to 0.816, and never changed a create.
- */
-export declare const DOMINANT_SIBLING_LINK_FLAG = "checkpoint.ontology.dominant-sibling-link";
-/**
- * A knowledge link to a non-person entity that 50 or more
- * other entity files link to is rejected as `hub_under_mentioned` when the
- * input names it fewer than 2 times (whole word, any case, canonical name
- * only). The plan carries `hub_mention_floor: true`. CO-62: a replay of six
- * runs raised knowledge precision from 0.753 to 0.781 at the same recall.
- */
-export declare const HUB_MENTION_FLOOR_FLAG = "checkpoint.ontology.hub-mention-floor";
-/**
- * A knowledge concept candidate whose name is an alias of more than one
- * entity, and which apply would defer as `ambiguous_alias`, links instead to
- * the one project whose canonical name it is (`HQ` typed as a concept beside
- * `project/HQ` and several concepts aliased `HQ`). The plan carries
- * `concept_project_link: true`. CO-51: over six runs of the shipping config
- * the model typed HQ as a concept in some runs and not others, and the
- * deferral lost 61 gold links; a replay of this rule raised recall from 0.639
- * to 0.709 at precision 0.747 to 0.731 (61 of the 63 added links are HQ).
- */
-export declare const CONCEPT_PROJECT_LINK_FLAG = "checkpoint.ontology.concept-project-link";
-/**
- * A knowledge link to the company's own company entity, or a
- * concept-project-link redirect, needs evidence that names the entity as a
- * word: the candidate name or one of its aliases, not inside a path, domain,
- * handle, tag or identifier (`indigoai-us/hq`, `getindigo.ai`,
- * `scope: company:indigo`). The plan carries `named_evidence: true`, and apply
- * rejects such a link as `unnamed_in_evidence`. CO-57: on the six CO-52 runs,
- * 67 of 143 false positives were links to company/indigo and project/HQ, most
- * on evidence that only held the name inside an identifier; a replay of this
- * rule raised precision on the concept-project-link arm from 0.705 to 0.750
- * and lost no gold link.
- */
-export declare const NAMED_EVIDENCE_FLAG = "checkpoint.ontology.named-evidence";
 /**
  * CO-59: consume the files touched by company checkpoints that were queued
  * behind a busy sibling (see queued-touches.ts). On, the plan adds the
@@ -250,7 +163,6 @@ export type PlanOutcome = {
     companyBrief?: CompanyBriefResult;
 };
 export declare const READ_PATH_INSTRUCTION = "When an input has read_path, read that file (relative to the run directory) instead of path, with the same line range. It is the same text with an older annotator's entity lists and entity links removed.";
-export declare const PERSON_NAME_INSTRUCTION = "Name a person by the full name the input or the company's entities give, not a first name alone.";
 export declare const FIRST_NAME_PEOPLE_INSTRUCTION = "Name a person by the full name the input or the company's entities give. When neither gives more than a first name, name the person by that first name; do not leave them out.";
 export declare function ledgerPath(hqRoot: string, company: OntologyCompany): string;
 export declare function readLedger(hqRoot: string, company: OntologyCompany): Ledger | null;