@indigoai-us/hq-cli 5.286.0 → 5.288.0

package/dist/commands/team-sync.js

@@ -16,6 +16,7 @@ import chalk from 'chalk';
 import simpleGit from 'simple-git';
 import { resolveDefaultHqRoot } from '../utils/cognito-session.js';
 import { ensureCognitoToken } from '../utils/cognito-session.js';
+import { readCompaniesManifestMap } from '../lib/work-context/repo-remote.js';
 // ─── API helpers ────────────────────────────────────────────────────────────
 const API_BASE = 'https://example.com/api';
 async function apiGet(urlPath, token) {
@@ -137,15 +138,38 @@ function getTrackedFiles(repoDir) {
 function discoverTeamDirs(hqRoot) {
     const companiesDir = path.join(hqRoot, 'companies');
     if (!fs.existsSync(companiesDir)) {
-        return [];
+        return {
+            teams: [],
+            cloudSyncedCompanyNames: [],
+            nonCloudBackedCompanyNames: [],
+            diagnostics: [`companies directory ${companiesDir}: missing`],
+        };
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(companiesDir, { withFileTypes: true });
     }
+    catch (error) {
+        return {
+            teams: [],
+            cloudSyncedCompanyNames: [],
+            nonCloudBackedCompanyNames: [],
+            diagnostics: [
+                `companies directory ${companiesDir}: could not read (${error instanceof Error ? error.message : 'unknown error'})`,
+            ],
+        };
+    }
+    const companyDirs = entries.filter((entry) => entry.isDirectory());
     const results = [];
-    for (const entry of fs.readdirSync(companiesDir, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
+    const missingTeamJson = [];
+    const invalidTeamJson = [];
+    const companiesManifest = readCompaniesManifestMap(hqRoot) ?? {};
+    for (const entry of companyDirs) {
         const teamJsonPath = path.join(companiesDir, entry.name, 'team.json');
-        if (!fs.existsSync(teamJsonPath))
+        if (!fs.existsSync(teamJsonPath)) {
+            missingTeamJson.push(teamJsonPath);
             continue;
+        }
         try {
             const raw = fs.readFileSync(teamJsonPath, 'utf-8');
             const meta = JSON.parse(raw);
@@ -155,12 +179,31 @@ function discoverTeamDirs(hqRoot) {
                     meta,
                 });
             }
+            else {
+                invalidTeamJson.push(teamJsonPath);
+            }
         }
         catch {
-            // Skip malformed team.json
+            invalidTeamJson.push(teamJsonPath);
         }
     }
-    return results;
+    const missingTeamJsonCompanyNames = missingTeamJson.map((file) => path.basename(path.dirname(file)));
+    const isCloudBacked = (name) => {
+        const cloudUid = companiesManifest[name]?.cloud_uid;
+        return typeof cloudUid === 'string' && cloudUid.trim().length > 0;
+    };
+    return {
+        teams: results,
+        cloudSyncedCompanyNames: missingTeamJsonCompanyNames.filter(isCloudBacked),
+        nonCloudBackedCompanyNames: missingTeamJsonCompanyNames.filter((name) => !isCloudBacked(name)),
+        diagnostics: [
+            `HQ root resolver: resolveDefaultHqRoot() returned ${hqRoot}`,
+            `companies directory ${companiesDir}: present; ${companyDirs.length} direct company directories found`,
+            `team.json discovery: ${results.length} valid, ${missingTeamJson.length} missing, ${invalidTeamJson.length} unreadable or invalid`,
+            ...missingTeamJson.map((file) => `${file}: missing`),
+            ...invalidTeamJson.map((file) => `${file}: unreadable or invalid`),
+        ],
+    };
 }
 /**
  * Sync a single team directory:
@@ -308,9 +351,27 @@ export function registerTeamSyncCommand(program) {
         try {
             const hqRoot = resolveDefaultHqRoot({ onMissing: 'throw' });
             // 1. Discover team directories
-            let teamDirs = discoverTeamDirs(hqRoot);
+            const discovery = discoverTeamDirs(hqRoot);
+            let teamDirs = discovery.teams;
             if (teamDirs.length === 0) {
-                console.log(chalk.yellow('No team directories found. Join a team first with: npx create-hq'));
+                console.log(chalk.yellow('No joined team directories found; no team sync ran.'));
+                if (discovery.cloudSyncedCompanyNames.length > 0) {
+                    const companyNames = discovery.cloudSyncedCompanyNames
+                        .map((name) => `"${name}"`)
+                        .join(', ');
+                    console.log(chalk.yellow(`Companies ${companyNames} are cloud-synced and do not have team.json. ` +
+                        'hq team-sync only handles git team repositories with team.json.'));
+                    console.log(chalk.dim('Use `hq sync pull --all` to sync company vault files and `hq sync status` to check their local sync state.'));
+                }
+                if (discovery.nonCloudBackedCompanyNames.length > 0) {
+                    const companyNames = discovery.nonCloudBackedCompanyNames
+                        .map((name) => `"${name}"`)
+                        .join(', ');
+                    console.log(`Companies ${companyNames} have no team.json and are not cloud-backed.`);
+                }
+                for (const diagnostic of discovery.diagnostics) {
+                    console.log(chalk.dim(`  ${diagnostic}`));
+                }
                 return;
             }
             // Filter to specific team if requested
@@ -318,7 +379,7 @@ export function registerTeamSyncCommand(program) {
                 teamDirs = teamDirs.filter((t) => t.meta.team_slug === options.team);
                 if (teamDirs.length === 0) {
                     console.log(chalk.red(`Team "${options.team}" not found. Available teams:`));
-                    for (const t of discoverTeamDirs(hqRoot)) {
+                    for (const t of discoverTeamDirs(hqRoot).teams) {
                         console.log(`  - ${t.meta.team_slug} (${t.meta.team_name})`);
                     }
                     process.exit(1);

package/dist/fast-lanes-list-route.js

@@ -1,5 +1,6 @@
 import { isFastCachedLanesListRequest } from "./fast-scaffold.js";
 import { fastFlagEnabled } from "./native-fast-route.js";
+import { registerOutpostLaneSnapshotRefreshChild } from "./lib/lanes/outpost-snapshot-refresh.js";
 import { LANE_OUTPOST_SNAPSHOT_CACHE_FLAG } from "./lib/lanes/outpost-hire-cache.js";
 import { LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lib/lanes/flag-keys.js";
 /** Returns false unless this exact list form is safely enabled in the local flag snapshot. */
@@ -14,6 +15,7 @@ export async function runFastLanesListRequest(argv, env = process.env, deps = {
         await runFastCachedLanesListFromEntrypoint();
     },
 }) {
+    registerOutpostLaneSnapshotRefreshChild(env);
     if (!isFastCachedLanesListRequest(argv))
         return false;
     if (env.HQ_INTERNAL_LANES_REFRESH_REMOTE_SNAPSHOT === "1")

package/dist/fast-lanes-list.js

@@ -1,10 +1,10 @@
-import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { compareLaneQueueOrder, laneRunsOnHost } from "./lib/lanes/admission.js";
 import { readOutpostIdentity, resolveAdmissionHost } from "./lib/lanes/admission-host.js";
 import { LaneSchemaError, isLanesError } from "./lib/lanes/errors.js";
+import { startOutpostLaneSnapshotRefresh } from "./lib/lanes/outpost-snapshot-refresh.js";
 import { OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS, outpostHireSummaryCacheKey, readOutpostHireSummaryCacheIncludingStale, } from "./lib/lanes/outpost-hire-cache.js";
 import { resolveLanesHqRoot } from "./lib/lanes/hq-root.js";
 import { laneStories } from "./lib/lanes/stories.js";
@@ -82,34 +82,6 @@ function isOverdue(hqRoot, laneId, now) {
         return false;
     return now.getTime() > at;
 }
-function startOutpostLaneSnapshotRefresh(root, env) {
-    let entry;
-    try {
-        const currentEntry = process.argv[1];
-        if (!currentEntry)
-            throw new Error("process.argv[1] is empty");
-        entry = fs.realpathSync(currentEntry);
-    }
-    catch (err) {
-        process.stderr.write(`lanes snapshot refresh could not resolve the running CLI entry: ${errorMessage(err)}\n`);
-        return;
-    }
-    try {
-        const child = spawn(process.execPath, [...process.execArgv, entry, "lanes", "list"], {
-            cwd: root,
-            detached: true,
-            stdio: ["ignore", "ignore", "inherit"],
-            env: { ...env, HQ_ROOT: root, HQ_NO_UPDATE_CHECK: "1", HQ_INTERNAL_LANES_REFRESH_REMOTE_SNAPSHOT: "1" },
-        });
-        child.once("error", (err) => {
-            process.stderr.write(`lanes snapshot refresh could not start: ${errorMessage(err)}\n`);
-        });
-        child.unref();
-    }
-    catch (err) {
-        process.stderr.write(`lanes snapshot refresh could not start: ${errorMessage(err)}\n`);
-    }
-}
 function isOwnerLane(lane, host) {
     return lane.host.kind === "outpost" &&
         !isTerminalLaneState(lane.state) &&

package/dist/lanes-drain-hook.d.ts

@@ -1,2 +1,14 @@
+import type { LaneDrainHookInput } from "./lib/lanes/dropbox.js";
+interface DrainHookResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+type DropboxModule = typeof import("./lib/lanes/dropbox.js");
+export interface DrainHookRunnerDeps {
+    /** Test seam for proving the steady-state path does not load the drainer. */
+    loadDropbox?: () => Promise<Pick<DropboxModule, "runDrainHook">>;
+}
+export declare function runLaneDrainHook(env: NodeJS.ProcessEnv, input?: LaneDrainHookInput, inputError?: string, deps?: DrainHookRunnerDeps): Promise<DrainHookResult>;
 export {};
 //# sourceMappingURL=lanes-drain-hook.d.ts.map

package/dist/lanes-drain-hook.js

@@ -1,6 +1,8 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MESSAGE_REPLAY_STATE_NAME, readMessageReplayState, updateMessageReplayTranscript, writeMessageReplayState, } from "./lib/lanes/message-replay.js";
 function parseHookInput(text) {
     if (text.trim() === "")
         return {};
@@ -72,38 +74,34 @@ function dropboxMayNeedDrain(box) {
     }
     return false;
 }
-function replayMayNeedWork(box, turnId, input) {
+function replayMayNeedWork(box, turnId, input, env) {
     if (!/^[A-Za-z0-9-]{1,80}$/.test(turnId))
         return false;
-    if (input.transcript_path)
-        return true;
-    let text;
-    const statePath = path.join(box, "message-compaction-replay.json");
+    const statePath = path.join(box, MESSAGE_REPLAY_STATE_NAME);
+    let state;
+    let hasLegacyFlag = false;
     try {
-        text = fs.readFileSync(statePath, "utf8");
+        state = readMessageReplayState(statePath, turnId, () => {
+            hasLegacyFlag = true;
+        });
     }
     catch {
         // Keep the existing named replay error behavior for missing or unreadable state.
         return true;
     }
+    if (hasLegacyFlag || !input.transcript_path)
+        return hasLegacyFlag;
+    if (!state.provider)
+        return true;
     try {
-        const parsed = JSON.parse(text);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        const update = updateMessageReplayTranscript(state, input.transcript_path, state.provider, env);
+        if (update === "compacted")
             return true;
-        const state = parsed;
-        if (state.schema_version !== 1 ||
-            state.turn_id !== turnId ||
-            (state.last_compaction_marker !== null &&
-                (!Number.isSafeInteger(state.last_compaction_marker) || Number(state.last_compaction_marker) < 0)) ||
-            (state.transcript_offset !== undefined &&
-                (!Number.isSafeInteger(state.transcript_offset) || Number(state.transcript_offset) < 0)) ||
-            (state.transcript_path !== undefined && typeof state.transcript_path !== "string") ||
-            state.flag_enabled !== undefined) {
-            return true;
-        }
+        writeMessageReplayState(statePath, state);
         return false;
     }
     catch {
+        // The full path preserves the existing named replay error reporting.
         return true;
     }
 }
@@ -125,52 +123,42 @@ function recordToolActivity(hqRoot, laneId) {
         return `hq-lanes-drain: failed to record tool activity: ${err instanceof Error ? err.message : String(err)}\n`;
     }
 }
-function finish(result, inputError) {
+function finish(result) {
     if (result.stdout)
         process.stdout.write(result.stdout);
-    if (inputError || result.stderr)
-        process.stderr.write(`${inputError}${result.stderr}`);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
     process.exitCode = result.exitCode;
 }
-async function runFullPath(input, inputError) {
-    const { runDrainHook } = await import("./lib/lanes/dropbox.js");
-    finish(await runDrainHook(process.env, input), inputError);
+async function runFullPath(env, input, deps) {
+    const loadDropbox = deps.loadDropbox ?? (() => import("./lib/lanes/dropbox.js"));
+    const { runDrainHook } = await loadDropbox();
+    return runDrainHook(env, input);
 }
-async function main() {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(Buffer.from(chunk));
-    const text = Buffer.concat(chunks).toString("utf8");
-    let input = {};
-    let inputError = "";
-    try {
-        input = parseHookInput(text);
-    }
-    catch (err) {
-        inputError = `hq-lanes-drain: ${err instanceof Error ? err.message : String(err)}\n`;
-    }
-    const laneId = process.env.HQ_LANE_ID ?? "";
+export async function runLaneDrainHook(env, input = {}, inputError = "", deps = {}) {
+    const withInputError = (result) => ({
+        ...result,
+        stderr: `${inputError}${result.stderr}`,
+    });
+    const laneId = env.HQ_LANE_ID ?? "";
     if (laneId === "") {
-        finish({ exitCode: 0, stdout: "", stderr: "" }, inputError);
-        return;
+        return withInputError({ exitCode: 0, stdout: "", stderr: "" });
     }
-    const hqRoot = process.env.HQ_ROOT ?? "";
+    const hqRoot = env.HQ_ROOT ?? "";
     if (hqRoot === "" || !laneIdIsSafe(laneId)) {
-        await runFullPath(input, inputError);
-        return;
+        return withInputError(await runFullPath(env, input, deps));
     }
     const box = path.join(hqRoot, "workspace", "lanes-runs", laneId, "dropbox");
     let noWork = false;
     try {
         noWork = !dropboxMayNeedDrain(box) &&
-            !replayMayNeedWork(box, process.env.HQ_LANE_TURN_ID ?? "", input);
+            !replayMayNeedWork(box, env.HQ_LANE_TURN_ID ?? "", input, env);
     }
     catch {
         // Filesystem uncertainty must use the full path so it retains its named errors.
     }
     if (!noWork) {
-        await runFullPath(input, inputError);
-        return;
+        return withInputError(await runFullPath(env, input, deps));
     }
     let stderr = recordToolActivity(hqRoot, laneId);
     const directories = [
@@ -186,14 +174,30 @@ async function main() {
     catch (err) {
         const message = `Failed to open drop box ${box}: ${err instanceof Error ? err.message : String(err)}`;
         stderr += `hq-lanes-drain: ${message}\n`;
-        finish({ exitCode: 1, stdout: "", stderr }, inputError);
-        return;
+        return withInputError({ exitCode: 1, stdout: "", stderr });
+    }
+    return withInputError({ exitCode: 0, stdout: "", stderr });
+}
+async function main() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    const text = Buffer.concat(chunks).toString("utf8");
+    let input = {};
+    let inputError = "";
+    try {
+        input = parseHookInput(text);
     }
-    finish({ exitCode: 0, stdout: "", stderr }, inputError);
+    catch (err) {
+        inputError = `hq-lanes-drain: ${err instanceof Error ? err.message : String(err)}\n`;
+    }
+    finish(await runLaneDrainHook(process.env, input, inputError));
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        process.stderr.write(`hq-lanes-drain: hook_runner_failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        // A hook runner failure must not stop the provider's requested tool call.
+        process.exitCode = 0;
+    });
 }
-main().catch((err) => {
-    process.stderr.write(`hq-lanes-drain: hook_runner_failed: ${err instanceof Error ? err.message : String(err)}\n`);
-    // A hook runner failure must not stop the provider's requested tool call.
-    process.exitCode = 0;
-});
 //# sourceMappingURL=lanes-drain-hook.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;