@mrclrchtr/supi-code-intelligence 4.10.0 → 6.0.0

package/src/tool/{result/find.ts → code_find/result.ts}

@@ -10,14 +10,16 @@ import {
   assembleToolResult,
   type ResultProvenance,
   type ToolResultAssembly,
-} from "./assembly.ts";
-import type { SearchDetails } from "./types.ts";
+} from "../result/assembly.ts";
+import { createToolDisplaySection } from "../result/display.ts";
+import type { SearchDetails, ToolDisplaySection } from "../result/types.ts";
 
 /** Presentation-neutral assembled find result. */
 export interface FindResultAssembly {
   outcome: Extract<FindWorkflowOutcome, { kind: "completed" }>;
   assembled: ToolResultAssembly<Extract<FindWorkflowOutcome, { kind: "completed" }>["data"]>;
   details: SearchDetails;
+  displaySections: readonly ToolDisplaySection[];
 }
 
 /** Assemble one completed code-aware search outcome before presentation. */
@@ -26,13 +28,7 @@ export function assembleFindWorkflowResult(
 ): FindResultAssembly {
   const evidence = createFindEvidence(outcome);
   const confidence: ConfidenceMode = outcome.data.kind === "semantic" ? "semantic" : "structural";
-  const nextQueries =
-    outcome.data.kind === "ast" && outcome.data.astKind === "call"
-      ? [
-          "Use code_graph references on a resolved target for symbol-identity relationships",
-          "Use PI grep for literal or regex source matches when it is active",
-        ]
-      : ["Change mode only when you need a different code-aware evidence substrate"];
+  const nextQueries = findNextQueries(outcome);
   const provenance = findProvenance(outcome.data.kind);
   const assembled = assembleToolResult({
     data: outcome.data,
@@ -53,9 +49,22 @@ export function assembleFindWorkflowResult(
     provenance,
   });
 
+  const displaySections = [
+    createToolDisplaySection({
+      key: `find.${outcome.data.kind}`,
+      title: outcome.data.kind === "semantic" ? "Symbols" : "Matches",
+      items: findItems(outcome.data),
+      totalCount: evidence.metadata.totalCount,
+      omittedCount: evidence.metadata.omittedCount,
+      partialReason: evidence.metadata.partialReason,
+      format: (item) => formatFindDisplayItem(outcome.data.kind, item),
+    }),
+  ];
+
   return {
     outcome,
     assembled,
+    displaySections,
     details: {
       confidence,
       scope: outcome.scopeLabel === "." ? null : outcome.scopeLabel,
@@ -68,6 +77,15 @@ export function assembleFindWorkflowResult(
   };
 }
 
+function findNextQueries(outcome: Extract<FindWorkflowOutcome, { kind: "completed" }>): string[] {
+  if (outcome.data.kind === "semantic" && outcome.data.symbols.length === 0) {
+    return [
+      "If you know the file, use code_resolve with a file selector to enumerate document declarations",
+    ];
+  }
+  return [];
+}
+
 function createFindEvidence(outcome: Extract<FindWorkflowOutcome, { kind: "completed" }>): {
   total: number;
   metadata: EvidenceListMetadata;
@@ -106,6 +124,25 @@ function findItems(
   return data.kind === "semantic" ? data.symbols : data.result.matches;
 }
 
+function formatFindDisplayItem(kind: "semantic" | "ast", item: unknown): string {
+  if (kind === "ast") {
+    const match = item as { name: string; kind: string; file: string; line: number };
+    return `${match.name} (${match.kind}) — ${match.file}:L${match.line}`;
+  }
+
+  const symbol = item as {
+    name: string;
+    kind: string;
+    file: string;
+    container?: string | null;
+    nameAnchor?: { line: number };
+    declarationAnchor: { line: number };
+  };
+  const container = symbol.container ? ` in ${symbol.container}` : "";
+  const anchor = symbol.nameAnchor ?? symbol.declarationAnchor;
+  return `${symbol.name} [${symbol.kind}]${container} — ${symbol.file}:L${anchor.line}`;
+}
+
 function findProvenance(
   kind: Extract<FindWorkflowOutcome, { kind: "completed" }>["data"]["kind"],
 ): ResultProvenance[] {
@@ -113,3 +150,35 @@ function findProvenance(
     ? [{ source: "semantic", capability: "workspace-symbol" }]
     : [{ source: "structural", capability: "tree-sitter" }];
 }
+
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { searchErrorResult } from "../result/errors.ts";
+import { renderFindResult } from "./render.ts";
+
+type FindOutcome = Awaited<ReturnType<CodeIntelToolExecCtx["session"]["find"]>>;
+
+/** Assemble the final model-visible code_find result for one workflow outcome. */
+export function finishFindResult(
+  outcome: FindOutcome,
+  scope: readonly string[] | undefined,
+): CodeIntelResult {
+  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
+  if (outcome.kind === "invalid-input") {
+    return searchErrorResult(`**Error:** ${outcome.message}`, {
+      scope: Array.isArray(scope) ? scope.join(", ") : null,
+      nextQueries: ["Fix the search input and retry"],
+      message: outcome.message,
+    });
+  }
+
+  const assembly = assembleFindWorkflowResult(outcome);
+  return {
+    content: renderFindResult(assembly),
+    details: {
+      type: "search",
+      data: assembly.details,
+      status: "completed",
+      displaySections: assembly.displaySections,
+    },
+  };
+}

package/src/tool/code_find/spec.ts

@@ -0,0 +1,37 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import type { CodeIntelToolExecCtx } from "../../types/index.ts";
+import { FindScopeParam, MaxResultsParam, QueryParam } from "../schemas.ts";
+import { CODE_FIND_AST_KINDS } from "./ast-kinds.ts";
+import { executeFindTool } from "./execute.ts";
+import { CODE_FIND_MODES } from "./modes.ts";
+import { renderFindCall, renderFindResult } from "./tui.ts";
+
+export const CODE_FIND_TOOL_NAME = "code_find";
+export const CODE_FIND_TOOL_LABEL = "Code Find";
+
+/** Canonical provider-facing metadata for the code_find tool. */
+export const codeFindSpec = {
+  name: CODE_FIND_TOOL_NAME,
+  label: CODE_FIND_TOOL_LABEL,
+  parameters: Type.Object(
+    {
+      query: QueryParam,
+      scope: Type.Optional(FindScopeParam),
+      mode: StringEnum(CODE_FIND_MODES, {
+        description: 'Required code-aware search mode. mode:"ast" requires `kind`.',
+      }),
+      kind: Type.Optional(
+        StringEnum(CODE_FIND_AST_KINDS, {
+          description: 'AST kind for mode:"ast".',
+        }),
+      ),
+      maxResults: Type.Optional(MaxResultsParam),
+    },
+    { additionalProperties: false },
+  ),
+  run: (params: unknown, ctx: CodeIntelToolExecCtx) =>
+    executeFindTool(params as Parameters<typeof executeFindTool>[0], ctx),
+  renderCall: renderFindCall,
+  renderResult: renderFindResult,
+} as const;

package/src/tool/code_find/tui.ts

@@ -0,0 +1,41 @@
+/** TUI renderer for code_find. */
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import {
+  formatCallValue,
+  type ResultOptios,
+  renderSimpleResult,
+  type ToolRendererContext,
+  type ToolResult,
+} from "../../ui/tui/common.ts";
+import type { CodeFindToolParams } from "./execute.ts";
+
+/** Render the compact code_find call header. */
+export function renderFindCall(
+  args: unknown,
+  theme: Theme,
+  _context: ToolRendererContext | undefined,
+): Text {
+  const params = (args ?? {}) as Partial<CodeFindToolParams>;
+  const mode = formatCallValue(params.mode, 20) ?? "mode?";
+
+  let content = theme.fg("toolTitle", "code_find");
+  const query = formatCallValue(params.query);
+  if (query) content += ` ${theme.fg("accent", JSON.stringify(query))}`;
+  content += ` ${theme.fg("muted", mode)}`;
+
+  const kind = formatCallValue(params.kind, 30);
+  if (kind) content += theme.fg("dim", ` [${kind}]`);
+
+  return new Text(content, 0, 0);
+}
+
+/** Render code_find progress, status, and structured result details. */
+export function renderFindResult(
+  result: ToolResult,
+  options: ResultOptios,
+  theme: Theme,
+  context: ToolRendererContext | undefined,
+): ReturnType<typeof renderSimpleResult> {
+  return renderSimpleResult(result, options, theme, "Searching…", context);
+}

package/src/tool/code_graph/execute.ts

@@ -0,0 +1,24 @@
+/** Thin Pi adapter for the session-owned code_graph workflow. */
+
+import type { GraphWorkflowInput, RequestedGraphRelation } from "../../session/graph-types.ts";
+import type { GraphTargetInput } from "../../session/target-input.ts";
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { finishGraphResult } from "./result.ts";
+
+export type GraphRelation = RequestedGraphRelation;
+
+export interface CodeGraphToolParams {
+  target: GraphTargetInput;
+  relations?: GraphRelation[];
+  calleeDepth?: "direct" | "deep";
+  maxResults?: number;
+}
+
+export async function executeGraphTool(
+  params: CodeGraphToolParams,
+  ctx: CodeIntelToolExecCtx,
+): Promise<CodeIntelResult> {
+  const outcome = await ctx.session.graph(params as GraphWorkflowInput, toWorkflowControl(ctx));
+  return finishGraphResult(outcome, ctx.cwd);
+}

package/src/tool/code_graph/guidance.ts

@@ -0,0 +1,6 @@
+export const toolDescription =
+  "Collect references, structural callees, and implementations for one target. Callees match source shape, not symbol identity.";
+
+export const promptSnippet = "provider-backed and structural relation evidence";
+
+export const promptGuidelines: string[] = [];

package/src/tool/{graph → code_graph}/markdown.ts

@@ -17,7 +17,7 @@ import type {
   ReferenceEntry,
 } from "../../analysis/relations/types.ts";
 import { toDisplayPath } from "../../analysis/search/paths.ts";
-import type { GraphResultAssembly } from "../result/graph.ts";
+import type { GraphResultAssembly } from "./result.ts";
 
 /** Render an assembled graph result. */
 export function renderGraphResult(assembly: GraphResultAssembly): string {

package/src/tool/{result/graph.ts → code_graph/result.ts}

@@ -6,14 +6,16 @@ import type {
   ImplementationEntry,
   ReferenceEntry,
 } from "../../analysis/relations/types.ts";
+import { toDisplayPath } from "../../analysis/search/paths.ts";
 import type { GraphSection } from "../../session/graph-types.ts";
 import {
   assembledNextQueries,
   assembleToolResult,
   type ResultProvenance,
   type ToolResultAssembly,
-} from "./assembly.ts";
-import type { SearchDetails } from "./types.ts";
+} from "../result/assembly.ts";
+import { createToolDisplaySection } from "../result/display.ts";
+import type { SearchDetails, ToolDisplaySection } from "../result/types.ts";
 
 export type { GraphRelationKind, GraphSection } from "../../session/graph-types.ts";
 
@@ -39,6 +41,7 @@ export interface GraphResultAssembly {
   cwd: string;
   assembled: ToolResultAssembly<{ readonly sections: readonly AssembledGraphSection[] }>;
   details: SearchDetails;
+  displaySections: readonly ToolDisplaySection[];
 }
 
 /** Assemble graph evidence once before either presentation adapter consumes it. */
@@ -70,19 +73,22 @@ export function assembleGraphResult(input: {
       provenance: section.kind === "ok" ? graphProvenance([section]) : [],
     })),
     evidenceLists,
-    nextQueries: ["Use code_orientation on an exact result before editing"],
+    nextQueries: [],
     readNext: sections.flatMap((section) => (section.kind === "ok" ? section.readNext : [])),
     candidateCount,
     confidence,
     provenance,
   });
 
+  const displaySections = sections.map((section) => graphDisplaySection(section, input.cwd));
+
   return {
     displayName: input.displayName,
     sections,
     resolvedDisplayFile: input.resolvedDisplayFile,
     cwd: input.cwd,
     assembled,
+    displaySections,
     details: {
       confidence,
       scope: null,
@@ -94,6 +100,43 @@ export function assembleGraphResult(input: {
   };
 }
 
+function graphDisplaySection(section: AssembledGraphSection, cwd: string): ToolDisplaySection {
+  if (section.kind === "unavailable") {
+    return createToolDisplaySection({
+      key: `graph.${section.rel}`,
+      title: section.rel,
+      items: [section.message],
+      format: (message) => `Unavailable — ${message}`,
+      totalCount: 1,
+    });
+  }
+
+  return createToolDisplaySection({
+    key: `graph.${section.rel}`,
+    title: section.rel,
+    items: section.evidence.items as readonly unknown[],
+    totalCount: section.evidence.metadata.totalCount,
+    omittedCount: section.evidence.metadata.omittedCount,
+    partialReason: section.evidence.metadata.partialReason,
+    format: (item) => formatGraphDisplayItem(section.rel, item, cwd),
+  });
+}
+
+function formatGraphDisplayItem(
+  relation: "references" | "callees" | "implements",
+  item: unknown,
+  cwd: string,
+): string {
+  if (relation === "callees") {
+    const call = item as { name: string; file: string; line: number };
+    return `${call.name} — ${toDisplayPath(cwd, call.file)}:L${call.line}`;
+  }
+
+  const location = item as { name: string | null; file: string; line: number; character: number };
+  const name = location.name ? `${location.name} — ` : "";
+  return `${name}${toDisplayPath(cwd, location.file)}:L${location.line}:${location.character}`;
+}
+
 function assembleGraphSection(section: GraphSection, maxResults: number): AssembledGraphSection {
   if (section.kind === "unavailable") return section;
   switch (section.rel) {
@@ -190,3 +233,68 @@ function graphConfidence(sections: readonly AssembledGraphSection[]): Confidence
   );
   return hasSemantic ? "semantic" : hasStructural ? "structural" : "unavailable";
 }
+
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { searchErrorResult } from "../result/errors.ts";
+import { renderGraphResult } from "./markdown.ts";
+
+type GraphOutcome = Awaited<ReturnType<CodeIntelToolExecCtx["session"]["graph"]>>;
+
+/** Assemble the final model-visible code_graph result for one workflow outcome. */
+export function finishGraphResult(outcome: GraphOutcome, cwd: string): CodeIntelResult {
+  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
+  if (outcome.kind === "invalid-input") {
+    return searchErrorResult(`**Error:** ${outcome.message}`, { message: outcome.message });
+  }
+  if (outcome.kind === "disambiguation" || outcome.kind === "kind-mismatch") {
+    const lines = [
+      outcome.kind === "kind-mismatch"
+        ? `**No target matched provider kind \`${outcome.requestedKind}\`. Near matches:**`
+        : "**Target is ambiguous. Choose one candidate handle:**",
+      "",
+    ];
+    for (const candidate of outcome.candidates) {
+      lines.push(
+        `- \`${candidate.targetId}\` — ${candidate.name} (\`${candidate.kind ?? "unknown"}\`) at ${candidate.file}:${candidate.line}:${candidate.character}`,
+      );
+    }
+    if (outcome.kind === "kind-mismatch") {
+      lines.push(
+        "",
+        "Retry without `symbolKind`, use an observed provider kind, or choose a handle.",
+      );
+    }
+    return searchErrorResult(lines.join("\n"), {
+      message:
+        outcome.kind === "kind-mismatch"
+          ? `No target matched provider kind ${outcome.requestedKind}.`
+          : "The target is ambiguous.",
+      displaySections: [
+        createToolDisplaySection({
+          key: "graph.candidates",
+          title: "Candidates",
+          items: outcome.candidates,
+          format: (candidate) =>
+            `${candidate.targetId} — ${candidate.name} (${candidate.kind ?? "unknown"}) at ${candidate.file}:${candidate.line}:${candidate.character}`,
+        }),
+      ],
+    });
+  }
+
+  const assembly = assembleGraphResult({
+    displayName: outcome.displayName,
+    sections: outcome.sections,
+    resolvedDisplayFile: outcome.resolvedDisplayFile,
+    maxResults: outcome.maxResults,
+    cwd,
+  });
+  return {
+    content: renderGraphResult(assembly),
+    details: {
+      type: "search",
+      data: assembly.details,
+      status: "completed",
+      displaySections: assembly.displaySections,
+    },
+  };
+}

package/src/tool/code_graph/spec.ts

@@ -0,0 +1,39 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import type { CodeIntelToolExecCtx } from "../../types/index.ts";
+import { GraphTargetParam, MaxResultsParam } from "../schemas.ts";
+import { executeGraphTool } from "./execute.ts";
+import { renderGraphCall, renderGraphResult } from "./tui.ts";
+
+export const CODE_GRAPH_TOOL_NAME = "code_graph";
+export const CODE_GRAPH_TOOL_LABEL = "Code Graph";
+
+/** Canonical provider-facing metadata for the code_graph tool. */
+export const codeGraphSpec = {
+  name: CODE_GRAPH_TOOL_NAME,
+  label: CODE_GRAPH_TOOL_LABEL,
+  parameters: Type.Object(
+    {
+      target: GraphTargetParam,
+      relations: Type.Optional(
+        Type.Array(StringEnum(["all", "references", "callees", "implements"]), {
+          description:
+            'Requested relations; defaults to ["references"]. "all" must be the only item.',
+          minItems: 1,
+          uniqueItems: true,
+        }),
+      ),
+      maxResults: Type.Optional(MaxResultsParam),
+      calleeDepth: Type.Optional(
+        StringEnum(["direct", "deep"], {
+          description: "direct excludes nested scopes; deep includes them.",
+        }),
+      ),
+    },
+    { additionalProperties: false },
+  ),
+  run: (params: unknown, ctx: CodeIntelToolExecCtx) =>
+    executeGraphTool(params as Parameters<typeof executeGraphTool>[0], ctx),
+  renderCall: renderGraphCall,
+  renderResult: renderGraphResult,
+} as const;

package/src/tool/code_graph/tui.ts

@@ -0,0 +1,117 @@
+/** TUI renderer for code_graph. */
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import {
+  buildSimpleCompact,
+  buildSimpleHeader,
+  type EvidenceEntry,
+  formatCallPath,
+  formatCallValue,
+  type ResultOptios,
+  renderDomainError,
+  renderDomainResult,
+  renderEvidenceLines,
+  renderExecutionError,
+  renderMarkdownDetail,
+  renderPartial,
+  renderStructuredDetailBody,
+  renderToolDisplaySections,
+  renderTruncationDisclosure,
+  type ToolRendererContext,
+  type ToolResult,
+} from "../../ui/tui/common.ts";
+import type { CodeGraphToolParams, GraphRelation } from "./execute.ts";
+
+/** Render the compact code_graph call header. */
+export function renderGraphCall(
+  args: unknown,
+  theme: Theme,
+  _context: ToolRendererContext | undefined,
+): Text {
+  const params = (args ?? {}) as Partial<CodeGraphToolParams>;
+  const relations: GraphRelation[] = Array.isArray(params.relations)
+    ? (params.relations as GraphRelation[])
+    : ["references"];
+  const relationLabel = formatRelations(relations);
+
+  let content = theme.fg("toolTitle", "code_graph");
+  if (relationLabel) content += ` ${theme.fg("accent", relationLabel)}`;
+
+  const target = formatTarget(params.target);
+  if (target) content += ` ${theme.fg("muted", target)}`;
+
+  return new Text(content, 0, 0);
+}
+
+/** Render code_graph progress, status, and structured result details. */
+export function renderGraphResult(
+  result: ToolResult,
+  options: ResultOptios,
+  theme: Theme,
+  context: ToolRendererContext | undefined,
+): Container | Text {
+  if (options.isPartial) return renderPartial("Collecting relations…", theme);
+
+  const details =
+    result.details?.type === "search" ? (result.details.data as Record<string, unknown>) : null;
+  const executionError = renderExecutionError(context, "code_graph failed", theme);
+  if (executionError) return executionError;
+  const domainError = renderDomainError(result, theme);
+  if (domainError) return renderDomainResult(result, options, theme, domainError);
+
+  if (!options.expanded) {
+    const compact = buildSimpleCompact(details ?? undefined, theme);
+    const truncation = renderTruncationDisclosure(result, theme);
+    if (!truncation) return compact;
+    const container = new Container();
+    container.addChild(compact);
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+    return container;
+  }
+
+  const container = new Container();
+  const header = buildSimpleHeader(details ?? undefined, theme);
+  if (header) container.addChild(header);
+
+  const evidenceLists = details?.evidenceLists as EvidenceEntry[] | undefined;
+  if (evidenceLists && evidenceLists.length > 0) {
+    container.addChild(new Spacer(1));
+    renderEvidenceLines(container, evidenceLists, theme);
+  }
+
+  renderToolDisplaySections(container, result.details?.displaySections, theme);
+  renderStructuredDetailBody(container, details ?? undefined, theme);
+  const truncation = renderTruncationDisclosure(result, theme);
+  if (truncation) {
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+  }
+  renderMarkdownDetail(container, result, theme);
+  return container;
+}
+
+function formatRelations(relations: readonly GraphRelation[]): string {
+  if (relations.length === 0) return "";
+  if (relations.length === 1) return `→ ${relations[0]}`;
+  if (relations.length <= 3) return `→ ${relations.join(", ")}`;
+  return `→ ${relations.slice(0, 2).join(", ")} +${relations.length - 2}`;
+}
+
+function formatTarget(target: unknown): string {
+  if (!target || typeof target !== "object") return "";
+  const record = target as Record<string, unknown>;
+
+  if (record.symbol && typeof record.symbol === "object") {
+    const query = formatCallValue((record.symbol as Record<string, unknown>).query);
+    return query ? `of ${query}` : "";
+  }
+  if (record.anchor && typeof record.anchor === "object") {
+    const anchor = record.anchor as Record<string, unknown>;
+    const file = formatCallPath(anchor.file);
+    const line = typeof anchor.line === "number" ? `:${anchor.line}` : "";
+    return file ? `at ${file}${line}` : "";
+  }
+  const handle = formatCallValue(record.handle);
+  return handle ? `of ${handle}` : "";
+}

package/src/tool/{health → code_health}/execute.ts

@@ -3,9 +3,7 @@
 import type { HealthSection, HealthWorkflowInput } from "../../session/health-types.ts";
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
 import { toWorkflowControl } from "../infra/workflow-control.ts";
-import { healthErrorResult } from "../result/errors.ts";
-import { assembleHealthResult } from "../result/health.ts";
-import { renderHealthResult } from "./markdown.ts";
+import { finishHealthResult } from "./result.ts";
 
 export interface CodeHealthToolParams {
   scope?: string;
@@ -19,14 +17,5 @@ export async function executeHealthTool(
   ctx: CodeIntelToolExecCtx,
 ): Promise<CodeIntelResult> {
   const outcome = await ctx.session.health(params as HealthWorkflowInput, toWorkflowControl(ctx));
-  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
-  if (outcome.kind === "invalid-input") {
-    return healthErrorResult(`**Error:** ${outcome.message}`, "invalid input");
-  }
-
-  const assembly = assembleHealthResult(outcome.data);
-  return {
-    content: renderHealthResult(assembly, ctx.cwd),
-    details: { type: "health", data: assembly.details },
-  };
+  return finishHealthResult(outcome, ctx.cwd);
 }

package/src/tool/code_health/guidance.ts

@@ -0,0 +1,8 @@
+export const toolDescription =
+  "Report live diagnostics as observations, language-server status, and final semantic health state. Tracked-file snapshots do not prove workspace completeness; server inventory is workspace-wide.";
+
+export const promptSnippet = "live workspace health observations";
+
+export const promptGuidelines = [
+  "Use code_health with refresh:true before relying on potentially stale diagnostics.",
+];