@archmax-ai/harness 0.8.0 → 1.0.0

package/dist/rubrics/rubrics.d.ts

@@ -1,135 +0,0 @@
-/**
- * Grading rubrics: the standards a state's exit is measured against, declared
- * inline on the hook that applies them and dispatched by the runtime alone.
- *
- * This module is only the *vocabulary* — the verdict contract, the payload a
- * grader receives, the rejection wording, and the projection from a loaded spec
- * into a registry. There is deliberately no loader, no file format and no merge
- * path: a rubric is spec content, so the spec's own schema is the one thing that
- * has to accept it, and nothing outside assembly builds a registry.
- *
- * A rubric has no author-given name. Its identity is its **position** — the
- * state, the phase, and its index in that phase's hook list — which is also how
- * its retry budget is keyed, so two graders on one state can never share a
- * budget or be confused for one another in an event.
- */
-import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import type { CreateDeepAgentParams } from "deepagents";
-import type { MachineSpec, RubricDeclaration } from "../machine/types.js";
-/** A grader in the Deep Agents shape, registered for the runtime's own `task` dispatch. */
-export type LoadedRubric = NonNullable<CreateDeepAgentParams["subagents"]>[number];
-/** The verdict vocabulary. `correct` asks for another iteration; `veto` blocks outright. */
-export type RubricVerdict = "ok" | "correct" | "veto";
-export interface RubricVerdictResult {
-    verdict: RubricVerdict;
-    reason: string;
-    /** The rubric that produced this verdict; absent for a script hook's own verdict. */
-    rubric?: string;
-}
-/**
- * The structured output a rubric with an iteration budget must return. Applied
- * automatically, so a grader's output is a contract rather than a prompt
- * convention.
- */
-export declare const RUBRIC_VERDICT_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly verdict: {
-            readonly type: "string";
-            readonly enum: readonly ["ok", "correct", "veto"];
-        };
-        readonly reason: {
-            readonly type: "string";
-        };
-    };
-    readonly required: readonly ["verdict", "reason"];
-};
-/**
- * One registry entry: the declaration plus the positional id the runtime
- * dispatches it under. The id is internal — it appears in operator-facing events
- * and never in a prompt — so it is built for uniqueness, not for authoring.
- */
-export interface Rubric extends RubricDeclaration {
-    id: string;
-    state: string;
-    phase: "before" | "after";
-    index: number;
-}
-/**
- * The id one inline rubric is registered and dispatched under. Positional
- * because an inline rubric has no name: reordering a phase's hooks re-keys them,
- * which is the same class of change as editing the spec at all (it moves the
- * spec hash).
- */
-export declare function rubricId(state: string, phase: "before" | "after", index: number): string;
-/** Whether a value is a usable verdict. Anything else has graded nothing. */
-export declare function isRubricVerdict(value: unknown): value is RubricVerdictResult;
-/**
- * The structured-output schema every dispatch requests: the verdict schema,
- * unconditionally.
- *
- * Not conditional on `max_iterations`, as it was when a grader was a subagent
- * that might also be a general-purpose helper. A rubric only ever grades, so a
- * grader that needs no retries still has to answer in the verdict vocabulary —
- * and without the schema its answer arrives as prose, parses to no verdict, and
- * fails closed on a transition the author expected it to wave through.
- */
-export declare function resolveRubricResponseFormat(_rubric: RubricDeclaration): Record<string, unknown> | undefined;
-/** The compact task payload a grader is handed: the request, the transcript, and where it happened. */
-export declare function buildRubricTaskDescription(args: Record<string, unknown>): string;
-/**
- * What an `after`-hook verdict does to an `archmax_advance` attempt.
- *
- * `reason` is `null` when the transition may proceed. The other two are decided
- * here, together, because they are mutually exclusive and were not: a `correct`
- * whose budget is already spent is `budgetExhausted` and bills nothing, while
- * only a `correct` that actually got its retry is `consumesIteration`. Billing
- * an attempt that was never granted costs the state its budget for good on
- * re-entry (issue #62).
- */
-export interface RubricTransitionOutcome {
-    reason: string | null;
-    /** A `correct` refused because the hook's `max_iterations` are already spent. */
-    budgetExhausted: boolean;
-    /** This block granted a retry, so it spends one of the hook's iterations. */
-    consumesIteration: boolean;
-}
-/**
- * Map an `after`-hook verdict to an `archmax_advance` rejection outcome. One
- * implementation for every hook kind: the retry flow (bounded iterations with
- * remaining-attempt guidance) is identical whether the verdict came from a
- * rubric or a script — only the label differs (`rubric` vs `hook`).
- */
-export declare function rubricTransitionOutcome(verdict: RubricVerdictResult, opts: {
-    maxIterations: number;
-    iterationsUsed: number;
-    to?: string;
-}): RubricTransitionOutcome;
-/**
- * The rejection reason alone, for callers that do not decide the retry budget.
- */
-export declare function rubricTransitionReason(verdict: RubricVerdictResult, opts: {
-    maxIterations: number;
-    iterationsUsed: number;
-    to?: string;
-}): string | null;
-/**
- * The rubric registry for one machine: every inline rubric its states declare,
- * keyed by {@link rubricId}. Walks the spec rather than reading a root block,
- * because a grader lives on the hook that applies it.
- *
- * Scoped to this spec, so a delegated child is graded by its own standards; two
- * states declaring the same criteria produce two entries, which is the accepted
- * cost of a state being legible on its own.
- */
-export declare function rubricsFromSpec(spec: Pick<MachineSpec, "states">): Map<string, Rubric>;
-/**
- * Project the registry into the Deep Agents subagent shape so the framework
- * registers the `task` tool the runtime dispatches through. These are never
- * disclosed to the agent: `task` is withheld in every state and grantable by
- * nothing, so registering a grader here gives the graded agent no reach.
- *
- * `model` resolves the grader's own model when it declared one, else the
- * assembly's `rubric`-role model.
- */
-export declare function rubricsAsSubagents(registry: Map<string, Rubric>, modelFor?: (rubric: Rubric) => BaseChatModel | undefined): LoadedRubric[];

package/dist/rubrics/rubrics.js

@@ -1,145 +0,0 @@
-import { normalizeHooks } from "../lifecycle/hook-shape.js";
-import { ADVANCE_TOOL } from "../machine/tool-names.js";
-/**
- * The structured output a rubric with an iteration budget must return. Applied
- * automatically, so a grader's output is a contract rather than a prompt
- * convention.
- */
-export const RUBRIC_VERDICT_SCHEMA = {
-    type: "object",
-    properties: {
-        verdict: { type: "string", enum: ["ok", "correct", "veto"] },
-        reason: { type: "string" },
-    },
-    required: ["verdict", "reason"],
-};
-/**
- * The id one inline rubric is registered and dispatched under. Positional
- * because an inline rubric has no name: reordering a phase's hooks re-keys them,
- * which is the same class of change as editing the spec at all (it moves the
- * spec hash).
- */
-export function rubricId(state, phase, index) {
-    return `${state}--${phase}--${index}`;
-}
-/** Whether a value is a usable verdict. Anything else has graded nothing. */
-export function isRubricVerdict(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const v = value;
-    return v.verdict === "ok" || v.verdict === "correct" || v.verdict === "veto";
-}
-/**
- * The structured-output schema every dispatch requests: the verdict schema,
- * unconditionally.
- *
- * Not conditional on `max_iterations`, as it was when a grader was a subagent
- * that might also be a general-purpose helper. A rubric only ever grades, so a
- * grader that needs no retries still has to answer in the verdict vocabulary —
- * and without the schema its answer arrives as prose, parses to no verdict, and
- * fails closed on a transition the author expected it to wave through.
- */
-export function resolveRubricResponseFormat(_rubric) {
-    return RUBRIC_VERDICT_SCHEMA;
-}
-/** The compact task payload a grader is handed: the request, the transcript, and where it happened. */
-export function buildRubricTaskDescription(args) {
-    return JSON.stringify({
-        userRequest: args.userRequest ?? null,
-        history: args.history ?? [],
-        state: args.state ?? null,
-        phase: args.phase ?? null,
-    }, null, 2);
-}
-/**
- * Map an `after`-hook verdict to an `archmax_advance` rejection outcome. One
- * implementation for every hook kind: the retry flow (bounded iterations with
- * remaining-attempt guidance) is identical whether the verdict came from a
- * rubric or a script — only the label differs (`rubric` vs `hook`).
- */
-export function rubricTransitionOutcome(verdict, opts) {
-    const label = verdict.rubric ? "rubric" : "hook";
-    if (verdict.verdict === "ok") {
-        return { reason: null, budgetExhausted: false, consumesIteration: false };
-    }
-    if (verdict.verdict === "veto") {
-        // A deliberate veto charges nothing: no retry was offered to bill for.
-        return {
-            reason: `${label} veto: ${verdict.reason}`,
-            budgetExhausted: false,
-            consumesIteration: false,
-        };
-    }
-    const max = Math.max(0, opts.maxIterations);
-    if (opts.iterationsUsed >= max) {
-        return {
-            reason: `${label} veto: reply still incomplete after ${max} attempt(s) — ${verdict.reason}`,
-            budgetExhausted: true,
-            consumesIteration: false,
-        };
-    }
-    const remaining = max - opts.iterationsUsed;
-    const target = opts.to ? `${ADVANCE_TOOL}({ to: "${opts.to}" })` : ADVANCE_TOOL;
-    return {
-        reason: `${label}: reply incomplete — ${verdict.reason}. ` +
-            `Update your answer and call ${target} again. (${remaining} attempt(s) remaining)`,
-        budgetExhausted: false,
-        consumesIteration: true,
-    };
-}
-/**
- * The rejection reason alone, for callers that do not decide the retry budget.
- */
-export function rubricTransitionReason(verdict, opts) {
-    return rubricTransitionOutcome(verdict, opts).reason;
-}
-/**
- * The rubric registry for one machine: every inline rubric its states declare,
- * keyed by {@link rubricId}. Walks the spec rather than reading a root block,
- * because a grader lives on the hook that applies it.
- *
- * Scoped to this spec, so a delegated child is graded by its own standards; two
- * states declaring the same criteria produce two entries, which is the accepted
- * cost of a state being legible on its own.
- */
-export function rubricsFromSpec(spec) {
-    const registry = new Map();
-    for (const [state, declared] of Object.entries(spec.states ?? {})) {
-        for (const phase of ["before", "after"]) {
-            normalizeHooks(declared?.[phase]).forEach((hook, index) => {
-                const declaration = hook.rubric;
-                if (declaration === undefined || typeof declaration !== "object")
-                    return;
-                const id = rubricId(state, phase, index);
-                registry.set(id, { ...declaration, id, state, phase, index });
-            });
-        }
-    }
-    return registry;
-}
-/**
- * Project the registry into the Deep Agents subagent shape so the framework
- * registers the `task` tool the runtime dispatches through. These are never
- * disclosed to the agent: `task` is withheld in every state and grantable by
- * nothing, so registering a grader here gives the graded agent no reach.
- *
- * `model` resolves the grader's own model when it declared one, else the
- * assembly's `rubric`-role model.
- */
-export function rubricsAsSubagents(registry, modelFor) {
-    return [...registry.values()].map((rubric) => {
-        const responseFormat = resolveRubricResponseFormat(rubric);
-        const model = modelFor?.(rubric);
-        return {
-            name: rubric.id,
-            // A grader is dispatched by the runtime under its positional id, never
-            // chosen from a menu by the agent, so the description exists only for the
-            // framework's own tool schema — which no state is ever shown.
-            description: `Grading rubric on '${rubric.state}' (${rubric.phase}).`,
-            systemPrompt: rubric.instructions,
-            ...(responseFormat !== undefined ? { responseFormat } : {}),
-            ...(model !== undefined ? { model } : {}),
-        };
-    });
-}
-//# sourceMappingURL=rubrics.js.map

package/dist/rubrics/rubrics.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rubrics.js","sourceRoot":"","sources":["../../src/rubrics/rubrics.ts"],"names":[],"mappings":"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"}

package/dist/sandbox/assets/parts/core.js

@@ -1,22 +0,0 @@
-// QuickJS sandbox core: the verdict helpers a lifecycle hook answers with.
-//
-//   return ok();               // proceed
-//   return correct("why");     // the agent gets another attempt (after hooks)
-//   return veto("why");        // block, with the reason shown to the agent
-//
-// Returning nothing is `ok`; throwing is a veto (fail-closed). Nothing else is
-// installed here — the hook reads its inputs from the object it is called with.
-
-globalThis.__verdict = (verdict, reason, fallback) => ({
-  verdict,
-  reason: reason == null || String(reason).trim() === "" ? fallback : String(reason),
-});
-
-globalThis.ok = (reason) => globalThis.__verdict("ok", reason, "ok");
-globalThis.veto = (reason) => globalThis.__verdict("veto", reason, "vetoed by hook");
-globalThis.correct = (reason) => globalThis.__verdict("correct", reason, "correction requested");
-
-globalThis.__isVerdict = (value) =>
-  value != null &&
-  typeof value === "object" &&
-  (value.verdict === "ok" || value.verdict === "veto" || value.verdict === "correct");

package/dist/sandbox/assets/parts/lifecycle-hook.js

@@ -1,47 +0,0 @@
-// Lifecycle-hook context: the contract marker, the `defineHook` authoring
-// alias, and the reducer that turns whatever a hook produced into a verdict.
-// These globals are absent from the PTC context.
-
-globalThis.SANDBOX_CONTRACT = { context: "lifecycle-hook", version: globalThis.__SANDBOX_VERSION };
-
-// `export default defineHook(fn)` and `export default async function hook(...)`
-// both register the hook; the executor rewrites `export default` to an
-// assignment of `__hookDef`, so `defineHook` is an identity that also registers.
-globalThis.defineHook = (fn) => {
-  globalThis.__hookDef = fn;
-  return fn;
-};
-
-// How an object that is not a verdict is named back to its author: by its keys,
-// never its values, so a diagnostic cannot leak what the hook was inspecting.
-globalThis.__hookShape = (value) => {
-  if (Array.isArray(value)) return "an array";
-  try {
-    const keys = Object.keys(value);
-    if (keys.length === 0) return "an object with no keys";
-    const shown = keys.slice(0, 6).map((key) => `'${key}'`).join(", ");
-    return `an object with ${keys.length > 6 ? "keys including " : "keys "}${shown}`;
-  } catch {
-    return "an object";
-  }
-};
-
-// The verdict of a hook run. A verdict object is taken as is, a bare `false`
-// vetoes, and returning nothing is `ok`.
-//
-// Any *other* object fails closed. A hook's return value is its verdict and
-// nothing else, so an object that is not one is a verdict its author got wrong
-// — a misspelled `verdict`, a retired shape like `{ ok: false, reason }`. Read
-// as `ok` it would silently permit precisely what the hook meant to block, and
-// the author would have no way to notice: the run just proceeds.
-globalThis.__hookVerdict = (value) => {
-  if (globalThis.__isVerdict(value)) return value;
-  if (value === false) return globalThis.veto("precondition not met");
-  if (value !== null && typeof value === "object") {
-    throw new Error(
-      `hook returned ${globalThis.__hookShape(value)}, which is not a verdict — ` +
-        "return ok(), veto(reason), correct(reason), false, or nothing at all",
-    );
-  }
-  return globalThis.ok();
-};

package/dist/sandbox/bridge.d.ts

@@ -1,16 +0,0 @@
-import type { RunnableConfig } from "@langchain/core/runnables";
-import type { StructuredTool } from "@langchain/core/tools";
-import { type SubagentBridgeOptions } from "@langchain/quickjs";
-import type { WorkflowEventEmitter } from "../core/events.js";
-/** Recover the textual payload from whatever envelope `task()` returns. */
-export declare function unwrapToolEnvelope(value: unknown): unknown;
-/**
- * Bridge the QuickJS `task()` global to the Deep Agents `task` tool. When
- * `telemetry` is supplied, each dispatch is bracketed with
- * `rubric-start`/`rubric-result` lifecycle events (this path bypasses the
- * outer agent's tool middleware, so it must emit its own bracketing).
- */
-export declare function createSubagentBridgeDispatch(taskTool: StructuredTool, config: RunnableConfig, telemetry?: {
-    emit: WorkflowEventEmitter;
-    state?: string;
-}): SubagentBridgeOptions["dispatch"];

package/dist/sandbox/bridge.js

@@ -1,95 +0,0 @@
-import { BaseMessage } from "@langchain/core/messages";
-import { isCommand } from "@langchain/langgraph";
-import { SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY } from "deepagents";
-import { validateResponseSchema } from "@langchain/quickjs";
-/** Recover the textual payload from whatever envelope `task()` returns. */
-export function unwrapToolEnvelope(value) {
-    if (typeof value === "string")
-        return value;
-    if (isCommand(value)) {
-        const messages = value.update?.messages;
-        if (Array.isArray(messages)) {
-            for (let i = messages.length - 1; i >= 0; i--) {
-                const message = messages[i];
-                if (BaseMessage.isInstance(message) && message.content != null) {
-                    return unwrapToolEnvelope(message.content);
-                }
-            }
-        }
-        return value;
-    }
-    if (BaseMessage.isInstance(value))
-        return unwrapToolEnvelope(value.content);
-    if (Array.isArray(value)) {
-        for (let i = value.length - 1; i >= 0; i--) {
-            const entry = value[i];
-            if (BaseMessage.isInstance(entry))
-                return unwrapToolEnvelope(entry.content);
-            if (isCommand(entry)) {
-                const inner = unwrapToolEnvelope(entry);
-                if (inner !== entry)
-                    return inner;
-            }
-        }
-    }
-    return value;
-}
-/** Ids for bridge dispatches, which have no model-assigned tool-call id. */
-let bridgeDispatchSeq = 0;
-/**
- * Bridge the QuickJS `task()` global to the Deep Agents `task` tool. When
- * `telemetry` is supplied, each dispatch is bracketed with
- * `rubric-start`/`rubric-result` lifecycle events (this path bypasses the
- * outer agent's tool middleware, so it must emit its own bracketing).
- */
-export function createSubagentBridgeDispatch(taskTool, config, telemetry) {
-    return async (input) => {
-        const hasSchema = input.responseSchema != null;
-        if (hasSchema)
-            validateResponseSchema(input.responseSchema);
-        const toolConfig = {
-            ...config,
-            configurable: {
-                ...config.configurable,
-                ...(hasSchema && { [SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY]: input.responseSchema }),
-            },
-        };
-        const dispatchId = `bridge-${++bridgeDispatchSeq}`;
-        const state = telemetry?.state ?? "";
-        telemetry?.emit({
-            type: "rubric-start",
-            state,
-            name: input.subagentType,
-            dispatchId,
-        });
-        const startedAt = Date.now();
-        const settle = (status) => telemetry?.emit({
-            type: "rubric-result",
-            state,
-            name: input.subagentType,
-            dispatchId,
-            status,
-            durationMs: Date.now() - startedAt,
-        });
-        let raw;
-        try {
-            raw = await taskTool.invoke({ description: input.description, subagent_type: input.subagentType }, toolConfig);
-        }
-        catch (err) {
-            settle("error");
-            throw err;
-        }
-        settle("ok");
-        const content = unwrapToolEnvelope(raw);
-        if (hasSchema && typeof content === "string") {
-            try {
-                return JSON.parse(content);
-            }
-            catch {
-                return content;
-            }
-        }
-        return content;
-    };
-}
-//# sourceMappingURL=bridge.js.map

package/dist/sandbox/bridge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bridge.js","sourceRoot":"","sources":["../../src/sandbox/bridge.ts"],"names":[],"mappings":"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"}

package/skills/archmax-harness/references/hooks-and-scripts.md

@@ -1,88 +0,0 @@
-# Hook scripts and `archmax_run` scripts — contracts
-
-Load this when writing a `workflows/<slug>/hooks/*.js` gate or a
-`skills/<cap>/scripts/*.js` source. Worked examples and the sandbox details:
-[`hook-and-test-scripts.md`](hook-and-test-scripts.md) Part 1.
-
-## Hook script contract
-
-Default-export function; its return value is the verdict. Verdict helpers are
-globals (typed import optional: `import { ok, veto, correct } from "@archmax-ai/harness/sandbox";`,
-placed below the JSDoc; no other import is allowed).
-
-```js
-/**
- * Requester gate — the request must name a requester the order records know.
- *
- * Reads the first user message, extracts the first email address, loads
- * skills/order-data/assets/orders.json through the bridge and matches the
- * address against every record's `email`, case-insensitively.
- *
- * Vetoes when the file cannot be parsed, no address is present, or none
- * matches — each with the reason. Otherwise ok.
- */
-export default async function hook({ state, phase, trigger, variables, messages, tools, from, to, reason }) {
-  let orders;
-  try { orders = JSON.parse(await tools.readFile({ file_path: "skills/order-data/assets/orders.json" })); }
-  catch { return veto("Could not load skills/order-data/assets/orders.json."); }
-  const text = messages.find((m) => m.role === "user")?.text ?? "";
-  const email = text.match(/[\w.+-]+@[\w.-]+\.\w{2,}/)?.[0];
-  if (!email) return veto("Include your email address so we can look up your account.");
-  if (!orders.some((o) => o.email?.toLowerCase() === email.toLowerCase())) return veto(`"${email}" is not in the order database.`);
-  return ok();
-}
-```
-
-| Input | Meaning |
-| --- | --- |
-| `state`, `phase` | state slug; `"before"` or `"after"` |
-| `trigger` | trigger id string (payload is in `variables`) |
-| `variables` | read-only `name → value` map incl. `trigger`; structured values whole |
-| `messages` | last 24 messages, newest last, `{ role, text, toolCalls? }`; roles `user`/`assistant`/`tool`/`system`/`runtime` (a runtime note; match `role === "runtime"`, never a `[bracket]`) |
-| `from`, `to`, `reason` | `after` only: the attempted transition and the agent's reason |
-| `tools` | async camelCased bridge: `tools.readFile`, `tools.writeFile`, `tools.archmaxWorkflowEnrichOrder(...)`; no control tools; a hook's lists every tool on the bridge, not only the state's |
-
-| Return | Effect |
-| --- | --- |
-| `ok()`, nothing, `true`/number/string | proceed |
-| `veto(reason)` | block; the reason is shown to the agent — make it actionable |
-| `correct(reason)` | `after` only: retry with the reason, within `max_iterations` |
-| `false` | veto ("precondition not met") |
-| any other object, a throw | veto with keys/error named — never silently ok |
-
-`console.log` goes to the trail. A file with no default export uses its
-completion value as the verdict. Parse inputs defensively; turn a failure that
-should not block into an explicit `ok()`.
-
-## `archmax_run` script contract
-
-`skills/<cap>/scripts/<x>.js`: plain script, top-level `await`, `tools.*`,
-`console.log`; the **last expression** is the tool result. Input is the global
-`args`: the arguments the model passed plus `args.variables` (read-only snapshot).
-No `archmax_advance`, `archmax_set_variables` or `task`. Fan-out shape:
-
-```js
-/** One sub-run per requested order, all in flight at once; returns [{ order_id, ...returns }]. */
-const orders = args.variables?.orders_to_enrich ?? [];
-await Promise.all(orders.map(async (o) => {
-  const answer = await tools.archmaxWorkflowEnrichOrder({ order_id: o.order_id });
-  return { order_id: o.order_id, ...JSON.parse(answer).returns };
-}));
-```
-
-The calling state must allow every tool the script calls (here
-`archmax_workflow_enrich-order`). A script's `tools` lists exactly the calling
-state's tools, re-scoped at every evaluation (so after an advance the same REPL
-lists the next state's); a tool the state does not offer is unlisted, and
-calling it by name is refused with governance's reason. The listing is
-camelCased, but a tool's own name reaches the same function
-(`tools["archmax_workflow_enrich-order"]`, `tools.read_file`); a hook's `tools`
-takes the camelCased names alone.
-
-**Return into a variable.** A script's result reaches the model as one tool
-message and no further — it is not written to the variable store, and a script
-cannot write there itself. Return structured data and name the variable in the
-calling state's `requires:`; the model then records it with
-`archmax_set_variables`, which is what makes it survive the state, guard a
-`tools.allow` glob, and be quotable downstream as `${{name}}` instead of retyped.
-A result worth computing is worth naming.