@anchrd/intel-ui 0.18.0 → 0.19.0

package/src/agent/agent-calendar/agent-calendar.tsx

@@ -1,160 +0,0 @@
-import type { AgentDefinition } from "@anchrd/intel-contract";
-import { CalendarClock } from "lucide-react";
-import { nextCronFires } from "@/agent/agent-cron/agent-cron.ts";
-import { useI18n } from "@/i18n/i18n-context.tsx";
-import { SectionHint } from "@/section-hint/section-hint.tsx";
-import { useChosenTimezone } from "@/timezone/timezone-context.tsx";
-
-// How far ahead one schedule is shown. Enough to recognise a rhythm — daily, weekly, the first of
-// the month — and not so much that the page becomes a year planner nobody asked for.
-const PerSchedule = 5;
-
-/**
- * What this agent is going to do, and when.
- *
- * ⚠️ Derived, never asked. The runtime arms one alarm at a time and publishes neither it nor a
- * calendar, so these times are this page's own reading of the same cron expressions — by the same
- * rules, pinned by `agent-cron.unit.ts` against the runtime's test.
- *
- * ⚠️ Each entry is drawn in ITS OWN schedule's timezone and names it (#228). Not in the reader's:
- * the agent fires at the hour its schedule says, and an instant shown in the zone of whoever is
- * looking would be a different hour from the one the agent keeps — a difference that only ever
- * surfaces as "it ran at the wrong time". And not one zone for the whole list either, because two
- * schedules of one agent may sit in different ones.
- *
- * ⚠️ The reader's own reading is ADDED beside it, never in its place (#256). The schedule's time is
- * the leading one because it is the reason the agent runs; the second is a reading aid, smaller and
- * behind it. A calendar that converted everything to the reader would have undone #228 with a
- * feature request.
- *
- * ⚠️ And only for a zone somebody SET. `useChosenTimezone` answers `null` where nothing was chosen,
- * and then this screen is exactly what it was — no browser guess dressed up as "your time", and no
- * second time on every row for a reader who never asked for one.
- *
- * ⚠️ A paused agent gets a sentence over the list, because this is the tab somebody opens to find
- * out WHETHER something runs (#203). Without it two places on one page said opposite things: the
- * header read `Paused · no schedule fires`, and this list went on naming the next five times as if
- * they would happen. The list is kept rather than emptied — what the agent WOULD do is still the
- * answer to "what did I switch off" — but it may not read as a plan.
- */
-export function AgentCalendar({
-  definition,
-  now,
-  paused,
-}: {
-  definition: AgentDefinition | null;
-  // Handed in rather than read from the clock, so the view is a function of its input and a test
-  // does not have to travel in time to assert on it.
-  now: Date;
-  // ⚠️ Handed in for the same reason, and not read from `useAgentState` here: that hook needs the
-  // router context and a query client, and reaching for it would turn every test of this view into
-  // an integration test of two providers. The caller already holds the state for the header.
-  paused: boolean;
-}) {
-  const i18n = useI18n();
-  const mine = useChosenTimezone();
-  const schedules = definition?.schedules ?? [];
-  const upcoming = schedules
-    // ⚠️ The schedule's own position rides along, and it is the only thing that separates two
-    // LITERALLY identical entries (#323). Two schedules with the same cron, zone and target are a
-    // definition somebody can save, and every other part of the key would be equal for them —
-    // including the fire time, which is computed from exactly those three.
-    .flatMap((schedule, position) =>
-      nextCronFires(schedule.cron, now, PerSchedule, schedule.timezone).map((at) => ({
-        at,
-        schedule,
-        position,
-      })),
-    )
-    .sort((left, right) => left.at.getTime() - right.at.getTime());
-
-  // One formatter per zone rather than one per row: a DateTimeFormat is expensive to build, and a
-  // calendar of five entries per schedule would otherwise build one for each of them.
-  const formatters = new Map<string, Intl.DateTimeFormat>();
-  const formatIn = (zone: string, at: Date) => {
-    let format = formatters.get(zone);
-    if (!format) {
-      format = new Intl.DateTimeFormat(i18n.locale, {
-        dateStyle: "full",
-        timeStyle: "short",
-        timeZone: zone,
-      });
-      formatters.set(zone, format);
-    }
-    return format.format(at);
-  };
-
-  // Shorter than the leading time on purpose: it is a reading aid, not a second headline. The date
-  // rides along because a schedule in Tokyo is regularly the reader's previous day.
-  const myFormat =
-    mine === null
-      ? null
-      : new Intl.DateTimeFormat(i18n.locale, {
-          dateStyle: "medium",
-          timeStyle: "short",
-          timeZone: mine,
-        });
-
-  return (
-    <section
-      aria-label={i18n.t("agent.calendar")}
-      className="min-h-0 flex-1 overflow-y-auto px-6 py-5"
-    >
-      {/* ⚠️ Behind the ⓘ rather than as a paragraph (#256): it was the longest text on the tab and
-          it explained, on every visit, a rule the list itself shows. The heading is what the hint
-          now hangs off — the same shape the profile's sections have. */}
-      <div className="flex items-center gap-1.5">
-        <h3 className="text-sm font-semibold">{i18n.t("agent.calendar")}</h3>
-        <SectionHint hint={i18n.t("agent.calendarZones")} />
-      </div>
-      {/* ⚠️ An agent with no schedule shows an empty calendar and nothing else (#254). The sentence
-          that used to stand here described the emptiness the reader is already looking at; the two
-          other states below are different, because each of them is a fact the list cannot show. */}
-      {/* ⚠️ Only where there is a list to qualify. A paused agent WITHOUT schedules shows the same
-          empty calendar it always did — the two states have to stay distinguishable, and a sentence
-          about times that do not happen, over no times at all, describes nothing. Same reason it
-          does not appear over `calendarUnreadable`: that one already says nothing is planned. */}
-      {paused && upcoming.length > 0 ? (
-        <p role="status" className="mt-4 rounded-lg border bg-muted px-4 py-3 text-sm">
-          {i18n.t("agent.calendarPaused")}
-        </p>
-      ) : null}
-      {schedules.length === 0 ? null : upcoming.length === 0 ? (
-        // Schedules exist and none of them fires: every expression is unusable. A different answer
-        // from "no schedules", because it is a different problem and needs a different fix.
-        <p role="alert" className="mt-4 text-sm text-destructive">
-          {i18n.t("agent.calendarUnreadable")}
-        </p>
-      ) : (
-        <ol className="mt-4 space-y-2">
-          {upcoming.map((entry) => (
-            <li
-              key={`${entry.position}:${entry.schedule.cron}@${entry.schedule.timezone}:${entry.schedule.target.id}:${entry.at.toISOString()}`}
-              className="flex flex-wrap items-center gap-3 rounded-lg border bg-card px-4 py-3 text-sm"
-            >
-              <CalendarClock aria-hidden="true" className="size-4 shrink-0 text-muted-foreground" />
-              <time dateTime={entry.at.toISOString()} className="font-medium">
-                {formatIn(entry.schedule.timezone, entry.at)}
-              </time>
-              {/* The zone stands next to the time, not once above the list: without it the same
-                  wall-clock hour from two schedules reads as a duplicate. */}
-              <span className="text-xs text-muted-foreground">{entry.schedule.timezone}</span>
-              {/* ⚠️ Nothing at all where the two zones agree (#256). For the ordinary reader — one
-                  zone, their own — the row must not grow a second time saying what the first
-                  already says. */}
-              {myFormat && mine !== entry.schedule.timezone ? (
-                <span className="text-xs text-muted-foreground">
-                  {i18n.t("agent.calendarYourTime", { when: myFormat.format(entry.at) })}
-                </span>
-              ) : null}
-              <code className="rounded bg-muted px-2 py-0.5 text-xs">{entry.schedule.cron}</code>
-              <span className="text-xs text-muted-foreground">
-                {i18n.t(`node.kind.${entry.schedule.target.kind}`)}
-              </span>
-            </li>
-          ))}
-        </ol>
-      )}
-    </section>
-  );
-}

package/src/agent/agent-chat/agent-chat.tsx

@@ -1,118 +0,0 @@
-import {
-  AssistantRuntimeProvider,
-  ComposerPrimitive,
-  ErrorPrimitive,
-  MessagePrimitive,
-  ThreadPrimitive,
-} from "@assistant-ui/react";
-import { AssistantChatTransport, useChatRuntime } from "@assistant-ui/react-ai-sdk";
-import { ArrowDown, Send } from "lucide-react";
-import { useMemo } from "react";
-import { useI18n } from "@/i18n/i18n-context.tsx";
-import { useIntelRouterContext } from "@/router/router-context.ts";
-
-/**
- * The built-in chat, against the agent runtime's own SSE endpoint.
- *
- * ⚠️ assistant-ui rather than a hand-rolled reader, and the reason is the wire: the runtime already
- * frames its answer as a Vercel AI UI message stream (`x-vercel-ai-ui-message-stream: v1`) with
- * `text-delta`, `tool-input-available` and `tool-output-available` parts. That format has a client,
- * and writing a second one would mean re-implementing tool-call rendering and stream recovery to
- * arrive at the same place.
- *
- * ⚠️ The endpoint is on INTEL, which forwards the turn to the runtime with the caller's own Gate
- * token (#178). That is what `credentials: "include"` is carrying: the intel session cookie, on the
- * origin this page came from. The runtime still demands `agents/run` — it just hears it from intel
- * rather than from a bearer this page would have had to hold.
- */
-export function AgentChat({ agentId }: { agentId: string }) {
-  const { data } = useIntelRouterContext();
-  const i18n = useI18n();
-  // ⚠️ Built once per agent. A transport rebuilt on every render restarts the runtime underneath
-  // assistant-ui and takes the open thread with it.
-  const transport = useMemo(
-    () =>
-      new AssistantChatTransport({
-        api: data.agentChatApi(agentId),
-        credentials: "include",
-      }),
-    [data, agentId],
-  );
-  const runtime = useChatRuntime({ transport });
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      <ThreadPrimitive.Root className="flex min-h-0 flex-1 flex-col bg-card">
-        <ThreadPrimitive.Viewport
-          autoScroll
-          className="relative flex min-h-0 flex-1 flex-col gap-4 overflow-y-auto px-6 py-5"
-        >
-          <ThreadPrimitive.Empty>
-            <p className="m-auto max-w-md text-center text-sm text-muted-foreground">
-              {i18n.t("agent.chatEmpty")}
-            </p>
-          </ThreadPrimitive.Empty>
-          <ThreadPrimitive.Messages components={{ UserMessage, AssistantMessage }} />
-          <ThreadPrimitive.ScrollToBottom asChild>
-            <button
-              type="button"
-              aria-label={i18n.t("agent.chatScrollDown")}
-              className="sticky bottom-0 z-10 mx-auto inline-flex size-8 items-center justify-center rounded-full border bg-background shadow-sm outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring disabled:invisible"
-            >
-              <ArrowDown aria-hidden="true" className="size-4" />
-            </button>
-          </ThreadPrimitive.ScrollToBottom>
-        </ThreadPrimitive.Viewport>
-        <ComposerPrimitive.Root className="flex items-end gap-2 border-t px-6 py-4">
-          <ComposerPrimitive.Input
-            rows={1}
-            autoFocus
-            aria-label={i18n.t("agent.chatInput")}
-            placeholder={i18n.t("agent.chatPlaceholder")}
-            className="max-h-40 min-h-9 flex-1 resize-none rounded-md border bg-background px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring"
-          />
-          <ComposerPrimitive.Send asChild>
-            <button
-              type="button"
-              aria-label={i18n.t("agent.chatSend")}
-              className="inline-flex size-9 shrink-0 items-center justify-center rounded-md bg-primary text-primary-foreground outline-none hover:bg-primary/90 focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
-            >
-              <Send aria-hidden="true" className="size-4" />
-            </button>
-          </ComposerPrimitive.Send>
-        </ComposerPrimitive.Root>
-      </ThreadPrimitive.Root>
-    </AssistantRuntimeProvider>
-  );
-}
-
-function UserMessage() {
-  return (
-    <MessagePrimitive.Root className="flex justify-end">
-      <div className="max-w-[80%] rounded-2xl bg-primary px-4 py-2 text-sm text-primary-foreground">
-        <MessagePrimitive.Parts />
-      </div>
-    </MessagePrimitive.Root>
-  );
-}
-
-function AssistantMessage() {
-  return (
-    <MessagePrimitive.Root className="flex justify-start">
-      <div className="max-w-[80%] space-y-2 text-sm">
-        <MessagePrimitive.Parts />
-        {/* The runtime reports a failed turn as an `error` part on a 200 stream, so a refusal shows
-            up here rather than as a request that failed. It is worded by the runtime, which words
-            it to be read (see `packages/agent`'s guard on model-facing errors). */}
-        <MessagePrimitive.Error>
-          <ErrorPrimitive.Root
-            role="alert"
-            className="rounded-md border border-destructive/40 px-3 py-2 text-destructive"
-          >
-            <ErrorPrimitive.Message />
-          </ErrorPrimitive.Root>
-        </MessagePrimitive.Error>
-      </div>
-    </MessagePrimitive.Root>
-  );
-}

package/src/agent/agent-costs/agent-costs.ts

@@ -1,95 +0,0 @@
-import type { AgentCosts, AgentCostWindow } from "@anchrd/intel-contract";
-import { type UseQueryResult, useQuery } from "@tanstack/react-query";
-import type { AgentRun, AgentUsage } from "@/data/agent-runtime/agent-runtime.ts";
-import { useIntelRouterContext } from "@/router/router-context.ts";
-
-/**
- * What this agent has cost, out of Cloudflare's AI Gateway log (#251).
- *
- * ⚠️ `retry: false`, and the run list beside it keeps its retries. These figures ENRICH a screen
- * that is already answered — the runs and their tokens come from the runtime and never depended on
- * Cloudflare — and a retry is paused while the tab is unfocused (#212), so a list that waited on
- * this one could sit on "Loading" for as long as the reader is looking elsewhere.
- */
-export function useAgentCosts(agentId: string): UseQueryResult<AgentCosts> {
-  const { data } = useIntelRouterContext();
-  return useQuery({
-    queryKey: ["agent-costs", agentId],
-    queryFn: () => data.getAgentCosts(agentId),
-    retry: false,
-  });
-}
-
-export function costWindow(costs: AgentCosts | undefined, days: number): AgentCostWindow | null {
-  return costs?.windows.find((window) => window.days === days) ?? null;
-}
-
-/**
- * What one run cost, or why that is not known.
- *
- * ⚠️ Four outcomes and not two, because "nothing" and "not known" are different answers and only one
- * of them is about money. A gateway that was never configured, a gateway that did not answer, and a
- * run the gateway has no line for all mean "not known" — and rendering any of them as `$0.00` says
- * the agent was free, which is the failure this ticket exists to remove.
- */
-export type RunCost =
-  | { kind: "known"; cost: number; calls: number }
-  | { kind: "not_configured" }
-  | { kind: "unreadable" }
-  | { kind: "missing" };
-
-export function runCost(costs: AgentCosts | undefined, runId: string): RunCost {
-  if (!costs || costs.status === "unreadable") return { kind: "unreadable" };
-  if (costs.status === "not_configured") return { kind: "not_configured" };
-  const found = costs.runs.find((run) => run.runId === runId);
-  // ⚠️ A run with no line is `missing`, never zero. Every run before #251 is one, and so is any run
-  // whose window has scrolled past the read's page limit.
-  return found ? { kind: "known", cost: found.cost, calls: found.calls } : { kind: "missing" };
-}
-
-/**
- * What one run consumed, or why that is not known either.
- *
- * ⚠️ All four counters at zero is read as "the provider reported nothing", NOT as "no tokens". A
- * completed model call always consumed input tokens, so four zeroes cannot honestly mean zero — and
- * Workers AI reports no usage at all, so every Workers AI run looks exactly like this. Showing them
- * as `0 in, 0 out` would put a false and very reassuring number on the screen.
- */
-export function runUsage(run: AgentRun): AgentUsage | null {
-  const usage = run.usage;
-  if (!usage) return null;
-  const total =
-    usage.inputTokens +
-    usage.outputTokens +
-    usage.cacheCreationInputTokens +
-    usage.cacheReadInputTokens;
-  return total > 0 ? usage : null;
-}
-
-/**
- * Money, with enough decimals to still be money.
- *
- * ⚠️ Four decimals below a dollar, not two. A single model call costs $0.0565 — at two decimals it
- * is "$0.06", and two runs that differ by half again read identically. Above a dollar the extra
- * digits are noise and are dropped.
- *
- * ⚠️ A cost that is real but smaller than the smallest digit shown gets a "<", never a rounded
- * "$0.00". The whole point of the figure is that nothing is silently free.
- */
-export function formatCost(dollars: number, locale: string): string {
-  const digits = Math.abs(dollars) >= 1 ? 2 : 4;
-  const format = (value: number) =>
-    value.toLocaleString(locale, {
-      style: "currency",
-      currency: "USD",
-      minimumFractionDigits: 2,
-      maximumFractionDigits: digits,
-    });
-  if (dollars > 0 && dollars < 0.0001) return `< ${format(0.0001)}`;
-  return format(dollars);
-}
-
-/** Token counts, short. 56 473 is "56.5K" — the exact figure helps nobody and costs the eye a line. */
-export function formatTokens(tokens: number, locale: string): string {
-  return tokens.toLocaleString(locale, { notation: "compact", maximumFractionDigits: 1 });
-}

package/src/agent/agent-cron/agent-cron.ts

@@ -1,68 +0,0 @@
-import { Cron } from "croner";
-
-/**
- * When a five-field cron expression fires next, read in the schedule's own timezone.
- *
- * ⚠️ This is still a second copy of `packages/agent/src/schedule/cron/cron.ts` — the runtime imports
- * nothing from the contract and this package cannot import a Worker package, so there remains no
- * third place for it. What changed with #228 is WHAT is duplicated: both files are now a thin
- * wrapper over croner, and the part that could actually disagree — the matching, DST, the day-field
- * OR rule — is one implementation in the library.
- *
- * That was the real risk. The old comment put it plainly: "a calendar that promises 08:00 while the
- * alarm fires at 09:00 is worse than a calendar that says nothing" — and two independent
- * reimplementations of timezone arithmetic is exactly how that happens.
- */
-
-// One year is the search bound. An expression that matches nothing within a year — "31st of
-// February" — has no next fire time, and saying so beats stepping forever.
-const MaxYearsAhead = 1;
-
-function schedule(expression: string, timezone: string): Cron | null {
-  try {
-    const job = new Cron(expression.trim(), { timezone, paused: true });
-    // croner also accepts six fields (with seconds). Intel's contract is five, and so is the hint
-    // shown next to the input — a six-field expression must not quietly mean something else.
-    return expression.trim().split(/\s+/).length === 5 ? job : null;
-  } catch {
-    return null;
-  }
-}
-
-// ⚠️ The croner call is inside the try, not only the construction. An unknown timezone can surface
-// either place depending on when croner first converts a date — and an exception escaping here ends
-// up inside a Durable Object alarm, which is the one place nobody is watching.
-function runs(expression: string, after: Date, count: number, timezone: string): Date[] {
-  const job = schedule(expression, timezone);
-  if (!job) return [];
-  try {
-    return job.nextRuns(count, after);
-  } catch {
-    return [];
-  }
-}
-
-export function nextCronFire(expression: string, after: Date, timezone: string): Date | null {
-  // Strictly after: a schedule that just fired must not match the same minute again. croner's
-  // `nextRuns(…, from)` is already exclusive of `from`.
-  const next = runs(expression, after, 1, timezone)[0];
-  if (!next) return null;
-  const limit = new Date(after.getTime());
-  limit.setUTCFullYear(limit.getUTCFullYear() + MaxYearsAhead);
-  return next > limit ? null : next;
-}
-
-/**
- * The next `count` fire times of one expression.
- *
- * An unparseable or never-matching expression yields an empty list — the caller says "nothing"
- * rather than guessing.
- */
-export function nextCronFires(
-  expression: string,
-  after: Date,
-  count: number,
-  timezone: string,
-): Date[] {
-  return runs(expression, after, count, timezone);
-}

package/src/agent/agent-definition/agent-definition.ts

@@ -1,96 +0,0 @@
-import type { AgentDefinition, AgentDefinitionInput, NodeAgent } from "@anchrd/intel-contract";
-import {
-  type UseMutationResult,
-  type UseQueryResult,
-  useMutation,
-  useQuery,
-  useQueryClient,
-} from "@tanstack/react-query";
-import { nextCronFires } from "@/agent/agent-cron/agent-cron.ts";
-import { useIntelRouterContext } from "@/router/router-context.ts";
-
-export const agentKey = (nodeId: string) => ["agent", nodeId] as const;
-
-export interface AgentDefinitionHandle {
-  query: UseQueryResult<NodeAgent>;
-  definition: AgentDefinition | null;
-  save: UseMutationResult<NodeAgent, Error, AgentDefinitionInput>;
-}
-
-/**
- * The definition as it was read, turned back into something this screen may ASK for (D30).
- *
- * ⚠️ It exists to drop exactly one field: `tools.delegatedBy`. Whose portal connection an agent
- * acts on is Intel's to write, out of the session, and the input shape has no place for it — so a
- * section that edits schedules must not carry it along just because it was in what it read. Every
- * section spreads this rather than the definition itself, which is why none of them has to invent a
- * user id for an agent that has no tools yet.
- */
-export function asDraft(definition: AgentDefinition): AgentDefinitionInput {
-  return {
-    references: definition.references,
-    schedules: definition.schedules,
-    model: definition.model,
-    tools: definition.tools === null ? null : { servers: definition.tools.servers },
-  };
-}
-
-/**
- * One agent's definition, and the one way to change it.
- *
- * ⚠️ Every edit writes a whole new definition version — there is no field-level update, by design
- * (ADR-0005): a definition is one immutable document, and what a run read is meant to stay
- * readable afterwards. So each section on the profile hands over the definition it wants next,
- * whole, and the version it was read from travels as `baseVersionId`. Somebody else's parallel
- * change is then a refusal instead of a silent overwrite.
- */
-export function useAgentDefinition(nodeId: string): AgentDefinitionHandle {
-  const { data } = useIntelRouterContext();
-  const queryClient = useQueryClient();
-  const query = useQuery({ queryKey: agentKey(nodeId), queryFn: () => data.getAgent(nodeId) });
-  const save = useMutation({
-    mutationFn: async (definition: AgentDefinitionInput) =>
-      await data.saveAgentDefinition({
-        nodeId,
-        baseVersionId: query.data?.version?.id ?? null,
-        definition,
-        idempotencyKey: crypto.randomUUID(),
-      }),
-    // The answer carries the new version, so the cache is set from it rather than refetched: the
-    // next save needs that id as its `baseVersionId`, and a round trip would leave a window in
-    // which it is still the old one.
-    onSuccess: (saved) => queryClient.setQueryData(agentKey(nodeId), saved),
-    // ⚠️ A failed save may still have MOVED the version (#214): `agent_schedules_not_armed` means
-    // the definition was written and only the runtime's alarm was not set, and the repair it names
-    // is saving again. With the old `baseVersionId` still cached that second save would answer 409
-    // instead — so the version this screen writes against is refetched whenever a save fails.
-    onError: () => queryClient.invalidateQueries({ queryKey: agentKey(nodeId) }),
-  });
-  return { query, definition: query.data?.definition ?? null, save };
-}
-
-/**
- * When this agent next does something on its own, across all of its schedules — and in which zone
- * that time is meant.
- *
- * ⚠️ Derived from the cron expressions, never asked. The runtime arms one alarm at a time and does
- * not publish it, so this is a reading of the same expressions by the same rules — since #228 both
- * sides read them through croner, so the reading and the alarm cannot drift apart.
- *
- * ⚠️ The zone travels WITH the time. Two schedules of one agent may sit in different zones, so a
- * single "all times are X" line above the screen would be a lie for one of them; the caller formats
- * each instant in the zone it came back with.
- */
-export function nextRunAt(
-  definition: AgentDefinition | null,
-  now: Date,
-): { at: Date; timezone: string } | null {
-  const fires = (definition?.schedules ?? []).flatMap((schedule) => {
-    const at = nextCronFires(schedule.cron, now, 1, schedule.timezone)[0];
-    return at ? [{ at, timezone: schedule.timezone }] : [];
-  });
-  return fires.reduce<{ at: Date; timezone: string } | null>(
-    (earliest, fire) => (earliest === null || fire.at < earliest.at ? fire : earliest),
-    null,
-  );
-}

package/src/agent/agent-delegation-notice/agent-delegation-notice.ts

@@ -1,48 +0,0 @@
-import type { I18n } from "@/i18n/i18n.types.ts";
-
-export interface DelegationReading {
-  /** Whose portal connection the agent's tools run on — `null` while nothing is delegated. */
-  delegatedBy: string | null;
-  /** The signed-in person, or `null` while the session has not been read yet. */
-  viewerId: string | null;
-  /** The delegator's display name, or `null` where this browser cannot resolve it (#261). */
-  delegatorName: string | null;
-}
-
-/**
- * Whose connection the tools run on, said so that it stays true for whoever is reading (#258).
- *
- * ⚠️ "Anyone who may run this agent acts on YOUR connection" was the whole sentence until #258, and
- * it is wrong for everybody except the delegator — on the one line in the product where somebody
- * learns whose access is being spent. It survives only where it is the strongest true form:
- *
- *   nothing delegated   nobody has given anything away yet, and whoever saves the tool selection
- *                       next becomes the delegator. For the reader, that is them.
- *   the reader's own    they ARE the delegator, so "your connection" says it harder than their name
- *                       would. Two readings rather than one are worth it for exactly this: the
- *                       sentence is about a consequence for the reader, and "your" is the word that
- *                       carries a consequence.
- *   somebody else's     the name. And where the name cannot be resolved — which is most ids today,
- *                       because Intel has no user directory (#261) — a sentence that names nobody,
- *                       never an invented name and never silence. WHOSE access is spent may be
- *                       unknown; THAT somebody else's is spent must not be.
- *
- * ⚠️ One catalog key per reading, each a whole sentence with the name as a parameter. A sentence
- * glued together from "acts on" + name + "'s connection" bakes an English possessive into the code,
- * and no other language would get to put it anywhere else.
- *
- * ⚠️ An empty `delegatedBy` reads as "somebody else's", not as "yours". The runtime has that case
- * for an archived agent and a definition it could not read (`packages/api/src/tools/tools.ts:39`),
- * and it is the one case where being wrong in the reader's favour is worst.
- */
-export function delegationNotice(i18n: I18n, reading: DelegationReading): string {
-  const { delegatedBy, viewerId, delegatorName } = reading;
-  if (delegatedBy === null) return i18n.t("agent.toolsDelegationNotice");
-  if (delegatedBy.length > 0 && delegatedBy === viewerId) {
-    return i18n.t("agent.toolsDelegationNotice");
-  }
-  if (delegatorName !== null) {
-    return i18n.t("agent.toolsDelegationNoticeBy", { name: delegatorName });
-  }
-  return i18n.t("agent.toolsDelegationNoticeSomebody");
-}

package/src/agent/agent-entry-title/agent-entry-title.ts

@@ -1,72 +0,0 @@
-import type { NodeKind } from "@anchrd/intel-contract";
-import { useQuery } from "@tanstack/react-query";
-import { useI18n } from "@/i18n/i18n-context.tsx";
-import { useIntelRouterContext } from "@/router/router-context.ts";
-
-export interface EntryTitle {
-  title: string;
-  known: boolean;
-  /** The kind of node this is, or `null` for a flow and for anything not available to the reader. */
-  kind: NodeKind | null;
-  /**
-   * The folders it is filed in, outermost first — empty at the top of the tree (#255).
-   *
-   * ⚠️ Only the ancestors the reader may see. The walk stops at the first one that is missing from
-   * the graph, so a partial path is possible and is the honest answer: the graph holds exactly what
-   * this reader may know about, and inventing a step would name a folder to somebody who may not
-   * know it exists (#41).
-   */
-  path: string[];
-}
-
-/**
- * The name behind an id, read from the lists the tree already loads.
- *
- * ⚠️ An entry the reader may not see is absent from both lists, and this then answers "not
- * available to you" rather than a raw id or an invented title. Deliberately the same answer a
- * reference to something deleted gets: the two must not be distinguishable, or the row would
- * confirm that a document exists to somebody who may not know it (#41).
- *
- * Its own module because two screens need it — the profile's references and schedules, and the
- * "run now" menu in the page head, which has to name the targets it offers.
- */
-export function useEntryTitle(entryId: string, flow = false): EntryTitle {
-  const { data } = useIntelRouterContext();
-  const i18n = useI18n();
-  const graph = useQuery({
-    queryKey: ["node-graph"],
-    queryFn: () => data.getNodeGraph(),
-    enabled: !flow,
-  });
-  const flows = useQuery({ queryKey: ["flows"], queryFn: () => data.listFlows(), enabled: flow });
-  if (flow) {
-    const found = flows.data?.items.find((item) => item.id === entryId);
-    if (found) return { title: found.title, known: true, kind: null, path: [] };
-    return { ...unknown(i18n, flows.isPending), kind: null };
-  }
-
-  const nodes = graph.data?.nodes ?? [];
-  const found = nodes.find((node) => node.id === entryId);
-  if (!found) return { ...unknown(i18n, graph.isPending), kind: null };
-
-  // Upwards from the node, then reversed: outermost folder first, which is how a path reads.
-  const path: string[] = [];
-  const seen = new Set<string>([found.id]);
-  let parentId = found.parentId;
-  while (parentId !== null && !seen.has(parentId)) {
-    seen.add(parentId);
-    const parent = nodes.find((node) => node.id === parentId);
-    if (!parent) break;
-    path.unshift(parent.title);
-    parentId = parent.parentId;
-  }
-  return { title: found.title, known: true, kind: found.kind, path };
-}
-
-function unknown(i18n: ReturnType<typeof useI18n>, pending: boolean) {
-  return {
-    title: i18n.t(pending ? "common.loading" : "agent.unknownEntry"),
-    known: false,
-    path: [] as string[],
-  };
-}