@payconductor/houndsman 0.8.0 → 0.11.0

package/src/core/orchestrator.ts

@@ -23,6 +23,7 @@ import { AiBriefEnricher } from "./ai/features/brief-enricher";
 import { AiClassifier } from "./ai/features/classifier";
 import { AiContextSummarizer } from "./ai/features/context-summarizer";
 import { AiPreAnalyzer } from "./ai/features/pre-analyzer";
+import { AiTechnicalSummarizer } from "./ai/features/technical-summarizer";
 import type { BriefPlan } from "./ai/schemas";
 import { assetPath, OUTPUT_FORMAT_FILE } from "./assets";
 import type { AstService } from "./ast/service";
@@ -56,6 +57,7 @@ import {
 	OUTPUT_FORMAT_PATH,
 	REVIEW_FILE,
 	REVIEW_RESUME_FILE,
+	TECHNICAL_SUMMARY_FILE,
 } from "./paths";
 import { ProjectConfig } from "./project-config";
 import { BriefRenderer } from "./renderers/brief-renderer";
@@ -79,6 +81,11 @@ import { systemClock } from "./services/clock";
 import { GitRepository } from "./services/git-repository";
 import type { ReviewRecord, StorageProvider } from "./storage/types";
 import { ReviewWorkArea } from "./storage/work-area";
+import {
+	buildTechnicalSummary,
+	parseTechnicalSummary,
+	type TechnicalSummary,
+} from "./technical-summary";
 import type { WatchdogMeta } from "./types";
 import { findWatchdog } from "./watchdog-registry";
 
@@ -483,6 +490,50 @@ async function resolveContextSummary(
 	return summary;
 }
 
+/**
+ * Pontos técnicos estruturais: IA quando disponível e, sempre, um fallback
+ * determinístico a partir da classificação/AST. Persistido para auditoria —
+ * o `finalize` apenas o consome.
+ */
+async function resolveTechnicalSummary(
+	ctx: ReviewContext,
+	ai: AiClient | undefined,
+	opts: ReviewOptions,
+	input: {
+		branch: string;
+		classification: RunClassification;
+		context: ContextSummary | null;
+		ast?: ReadonlyMap<string, AstAnalysis>;
+		impact?: AstImpact;
+		domains: readonly string[];
+	},
+): Promise<TechnicalSummary> {
+	const fallback = buildTechnicalSummary({
+		classification: input.classification,
+		ast: input.ast,
+		impact: input.impact,
+		headSha: input.classification.headSha,
+	});
+	const summary =
+		ai && !opts.noAi
+			? ((await new AiTechnicalSummarizer(ai).summarize({
+					branch: input.branch,
+					context: input.context,
+					classification: input.classification,
+					ast: input.ast,
+					impact: input.impact,
+					headSha: input.classification.headSha,
+					domains: input.domains,
+				})) ?? fallback)
+			: fallback;
+	ctx.storage.writeArtifact(ctx.review.id, {
+		name: TECHNICAL_SUMMARY_FILE,
+		kind: "technical",
+		content: `${JSON.stringify(summary, null, 2)}\n`,
+	});
+	return summary;
+}
+
 /**
  * Planos de revisão por watchdog (uma chamada por brief, concorrência
  * limitada). Sem IA/chave/feature, devolve mapa vazio e o brief fica igual.
@@ -574,13 +625,30 @@ export async function prepare(
 		return { messages };
 	}
 
+	const { classification, diff } = scope;
+
+	// Run recém-criada e sem nenhum arquivo alterado: não persiste uma "run
+	// vazia" na lista. Acontece quando o comando roda no clone principal sem
+	// `--pr`/`--worktree` (ex.: `houndsman` na `main` logo após revisar uma PR).
+	// Run com artefatos anteriores (contexto, revisão) continua existindo.
+	if (Object.keys(classification.files).length === 0) {
+		const fresh = ctx.storage.listArtifacts(ctx.review.id).length === 0;
+		if (fresh) {
+			ctx.work.clean();
+			ctx.storage.deleteReview(ctx.review.id);
+			messages.push(
+				`Nenhuma alteração entre ${opts.base}...${opts.head} — nenhuma run criada.`,
+			);
+			return { messages };
+		}
+	}
+
 	// Marca o run como "revisando" (reinicia o ciclo) — a UI mostra o status.
 	writeRunStatus(ctx.storage, ctx.review.id, {
 		status: "reviewing",
 		resetStartedAt: true,
 	});
 
-	const { classification, diff } = scope;
 	await applyAiClassification(classification, config, ai, opts);
 	ctx.storage.writeArtifact(ctx.review.id, {
 		name: "classification.json",
@@ -645,6 +713,14 @@ export async function prepare(
 
 	persistContext(ctx);
 	const context = await resolveContextSummary(ctx, ai, opts);
+	await resolveTechnicalSummary(ctx, ai, opts, {
+		branch,
+		classification,
+		context,
+		ast: astAnalyses,
+		impact: astImpact,
+		domains: activeIds.map((id) => findWatchdog(config, id)?.name ?? id),
+	});
 
 	const manifestAst: ManifestAst | undefined = astAnalyses
 		? {
@@ -853,6 +929,40 @@ function readPersistedContextSummary(ctx: ReviewContext): ContextSummary | null
 	}
 }
 
+/** JSON persistido, ou `null` quando ausente/inválido. */
+function readArtifactJson<T>(ctx: ReviewContext, name: string): T | null {
+	const artifact = ctx.storage.readArtifact(ctx.review.id, name);
+	if (!artifact) return null;
+	try {
+		return JSON.parse(artifact.content) as T;
+	} catch {
+		return null;
+	}
+}
+
+/** Pontos técnicos persistidos pelo `prepare`; `null` quando ausentes. */
+function readPersistedTechnicalSummary(ctx: ReviewContext): TechnicalSummary | null {
+	const raw = readArtifactJson<unknown>(ctx, TECHNICAL_SUMMARY_FILE);
+	return raw ? parseTechnicalSummary(raw) : null;
+}
+
+/** Fallback para runs antigas: reconstrói os destaques dos artefatos de AST. */
+function buildTechnicalFallback(
+	ctx: ReviewContext,
+	classification: RunClassification,
+): TechnicalSummary {
+	const ast = readArtifactJson<{ files?: Record<string, AstAnalysis> }>(
+		ctx,
+		"ast-summary.json",
+	);
+	return buildTechnicalSummary({
+		classification,
+		ast: ast?.files ? new Map(Object.entries(ast.files)) : undefined,
+		impact: readArtifactJson<AstImpact>(ctx, "ast-impact.json") ?? undefined,
+		headSha: classification.headSha,
+	});
+}
+
 /**
  * Grava um `review.<watchdog>.md` por watchdog com achados e devolve o índice.
  * Mantém o `review.md` consolidado navegável em PRs grandes (centenas de achados).
@@ -1028,6 +1138,8 @@ export function finalize(
 
 	persistContext(ctx);
 	const context = ctx.work.readContextSummary() ?? readPersistedContextSummary(ctx);
+	const technical =
+		readPersistedTechnicalSummary(ctx) ?? buildTechnicalFallback(ctx, classification);
 	const nameOf = (id: string): string => findWatchdog(config, id)?.name ?? id;
 	const domains = writeDomainReports(
 		ctx,
@@ -1061,7 +1173,7 @@ export function finalize(
 			context,
 			classification,
 			findings: merged,
-			nameOf,
+			technical,
 		}),
 	});
 

package/src/core/paths.ts

@@ -55,3 +55,6 @@ export const REVIEW_FILE = "review.md";
 
 /** Resumo final da review (artefato `review-resume.md`) — leitura humana apenas. */
 export const REVIEW_RESUME_FILE = "review-resume.md";
+
+/** Pontos técnicos estruturais usados no resumo final (`technical-summary.json`). */
+export const TECHNICAL_SUMMARY_FILE = "technical-summary.json";

package/src/core/pr-context.ts

@@ -229,13 +229,17 @@ export function renderContextBrief(
 
 	lines.push("## Regras", "");
 	lines.push(
-		"- **Seja curto** — o resumo abre o relatório e entra em **todos** os briefs.",
+		"- O resumo abre o relatório e o resumo final; nos briefs ele é recortado.",
 	);
 	lines.push("- Baseie-se **somente** no `context.json` — não invente intenção.");
-	lines.push("- `objective`: 1 frase (≤ 200 caracteres) sobre o que a PR entrega.");
-	lines.push("- `motivation`: 1 frase (≤ 240 caracteres) sobre o porquê.");
 	lines.push(
-		"- `changeSummary`: no máximo 4 bullets (≤ 160 caracteres cada), focados em comportamento — não liste arquivos.",
+		"- `objective`: até 2 frases (≤ 400 caracteres) sobre o que a PR entrega.",
+	);
+	lines.push(
+		"- `motivation`: até 3 frases (≤ 480 caracteres) sobre o porquê e o impacto.",
+	);
+	lines.push(
+		"- `changeSummary`: no máximo 6 bullets (≤ 240 caracteres cada), focados em comportamento — não liste arquivos.",
 	);
 	lines.push(
 		"- NÃO copie a descrição da PR: sintetize. Copie `source` do contexto bruto.",
@@ -253,7 +257,8 @@ const CONTEXT_SUMMARY_TEMPLATE = {
 		base: "main",
 		head: "feature/x",
 	},
-	objective: "O que a PR entrega, em 1 frase.",
-	motivation: "Por que a mudança é necessária, em 1-2 frases.",
+	objective: "O que a PR entrega, em 1-2 frases.",
+	motivation:
+		"Por que a mudança é necessária, com o problema e o impacto (até 3 frases).",
 	changeSummary: ["Bullet de comportamento 1", "Bullet de comportamento 2"],
 };

package/src/core/project-config.ts

@@ -8,6 +8,7 @@
 
 import type {
 	AiProviderKind,
+	AiProviderOptions,
 	HoundsmanAi,
 	HoundsmanAiFeatures,
 	HoundsmanAst,
@@ -138,6 +139,12 @@ export class ProjectConfig<TId extends string = string> {
 		return typeof value === "number" && Number.isFinite(value) ? value : 0;
 	}
 
+	/** Opções do AI SDK por provider (undefined quando ausentes/vazias). */
+	get aiProviderOptions(): AiProviderOptions | undefined {
+		const value = this.ai.providerOptions;
+		return value && Object.keys(value).length > 0 ? value : undefined;
+	}
+
 	get aiTimeoutMs(): number {
 		return positive(this.ai.timeoutMs, DEFAULT_AI_TIMEOUT_MS);
 	}
@@ -152,12 +159,13 @@ export class ProjectConfig<TId extends string = string> {
 		return value !== undefined && value > 0 ? value : undefined;
 	}
 
-	/** Features resolvidas com defaults (`context`/`brief` ligadas). */
+	/** Features resolvidas com defaults (`context`/`brief`/`technical` ligadas). */
 	get aiFeatures(): Required<HoundsmanAiFeatures> {
 		const features = this.ai.features ?? {};
 		return {
 			context: features.context !== false,
 			brief: features.brief !== false,
+			technical: features.technical !== false,
 			classification: features.classification === true,
 			preAnalysis: features.preAnalysis === true,
 			verify: features.verify === true,

package/src/core/renderers/resume-renderer.ts

@@ -3,19 +3,16 @@
  *
  * Artefato somente-leitura para humanos: não entra em briefs, não é lido pelos
  * watchdogs e não participa de nenhuma etapa seguinte. Une o contexto de
- * negócio da PR aos números técnicos diretos da revisão, com limite de
+ * negócio da PR aos pontos técnicos estruturais da revisão, com limite de
  * `RESUME_MAX_CHARS`.
  */
 
-import type {
-	ContextSummary,
-	MergedFinding,
-	WatchdogNameResolver,
-} from "../report-builder";
+import type { ContextSummary, MergedFinding } from "../report-builder";
 import { systemClock } from "../services/clock";
+import type { TechnicalSummary } from "../technical-summary";
 
 /** Teto de caracteres do artefato (inclui cabeçalho e quebras de linha). */
-export const RESUME_MAX_CHARS = 2500;
+export const RESUME_MAX_CHARS = 5000;
 
 /** Dados de classificação usados no resumo. */
 export type ResumeClassification = {
@@ -30,11 +27,10 @@ export type ReviewResumeInput = {
 	context?: ContextSummary | null;
 	classification: ResumeClassification;
 	findings: readonly MergedFinding[];
-	nameOf?: WatchdogNameResolver;
+	/** Pontos técnicos estruturais (não achados). */
+	technical?: TechnicalSummary | null;
 };
 
-const identityName: WatchdogNameResolver = (id) => id;
-
 const STATUS_BY_SEVERITY: Record<"blocking" | "attention" | "clean", string> = {
 	blocking: "❌ Mudanças necessárias",
 	attention: "⚠️ Aprovado com ressalvas",
@@ -80,36 +76,24 @@ function businessSection(input: ReviewResumeInput): string[] {
 	if (context.objective) lines.push(context.objective, "");
 	if (context.motivation) lines.push(`**Por quê:** ${context.motivation}`, "");
 	if (context.changeSummary && context.changeSummary.length > 0) {
-		for (const item of context.changeSummary.slice(0, 4)) {
-			lines.push(`- ${truncate(item, 180)}`);
+		for (const item of context.changeSummary.slice(0, 6)) {
+			lines.push(`- ${truncate(item, 240)}`);
 		}
 		lines.push("");
 	}
 	return lines;
 }
 
-/** Achados que exigem ação, em formato direto (máximo 5). */
-function technicalSection(
-	findings: readonly MergedFinding[],
-	nameOf: WatchdogNameResolver,
-): string[] {
-	const relevant = findings
-		.filter(
-			(finding) =>
-				finding.severity === "blocking" || finding.severity === "attention",
-		)
-		.slice(0, 5);
+/** Pontos técnicos estruturais (módulos, contratos, impacto) — não achados. */
+function technicalSection(summary: TechnicalSummary | null | undefined): string[] {
 	const lines = ["## Pontos técnicos", ""];
-	if (relevant.length === 0) {
-		lines.push("- Nenhum bloqueio ou ponto de atenção.", "");
+	if (!summary || (!summary.overview && summary.highlights.length === 0)) {
+		lines.push("Sem mudanças estruturais detectadas nesta revisão.", "");
 		return lines;
 	}
-	for (const finding of relevant) {
-		const location = finding.line ? `${finding.file}:${finding.line}` : finding.file;
-		const watchdogs = finding.watchdogs.map((id) => nameOf(id)).join(", ");
-		lines.push(
-			`- \`${location}\` — ${truncate(finding.message, 130)}${watchdogs ? ` _(${watchdogs})_` : ""}`,
-		);
+	if (summary.overview) lines.push(summary.overview, "");
+	for (const highlight of summary.highlights) {
+		lines.push(`- **${highlight.area}** — ${truncate(highlight.detail, 300)}`);
 	}
 	lines.push("");
 	return lines;
@@ -125,10 +109,9 @@ function clamp(markdown: string, max: number): string {
 
 /**
  * Renderiza o resumo final. Determinístico e sem chamadas externas: o texto
- * nasce do contexto já disponível e dos findings consolidados.
+ * nasce do contexto já disponível e dos pontos técnicos persistidos.
  */
 export function renderReviewResume(input: ReviewResumeInput): string {
-	const nameOf = input.nameOf ?? identityName;
 	const blockers = input.findings.filter((f) => f.severity === "blocking").length;
 	const attention = input.findings.filter((f) => f.severity === "attention").length;
 	const status =
@@ -144,7 +127,7 @@ export function renderReviewResume(input: ReviewResumeInput): string {
 		`**Data:** ${input.date ?? systemClock().slice(0, 10)} · **Status:** ${status}`,
 		"",
 		...businessSection(input),
-		...technicalSection(input.findings, nameOf),
+		...technicalSection(input.technical),
 	];
 
 	return clamp(`${lines.join("\n").trimEnd()}\n`, RESUME_MAX_CHARS);

package/src/core/report-builder.ts

@@ -63,14 +63,14 @@ export type ContextSummary = {
 const VALID_SEVERITIES = new Set<string>(SEVERITY_ORDER);
 
 /**
- * Limites do resumo da PR: mantém o relatório e os briefs enxutos — evita
- * confundir o watchdog humano e estourar o contexto da IA watchdog.
+ * Limites do resumo da PR: o contexto abre o relatório e o resumo final, mas
+ * não pode inflar os briefs — a injeção nos briefs é recortada em `brief.ts`.
  */
 const CONTEXT_LIMITS = {
-	objective: 200,
-	motivation: 240,
-	changeSummaryItem: 160,
-	changeSummaryItems: 4,
+	objective: 400,
+	motivation: 480,
+	changeSummaryItem: 240,
+	changeSummaryItems: 6,
 } as const;
 
 /** Corta `value` em `max` caracteres, sinalizando com reticências. */

package/src/core/services/worktree-manager.ts

@@ -4,13 +4,23 @@
  * Um worktree por branch revisada, criado em **detached HEAD** no commit da PR.
  * Detached evita o conflito "branch já checada" com o clone principal e é o
  * modo correto para revisão (somente leitura). Vive fora do projeto, em
- * `<HOUNDSMAN_HOME>/worktrees/<repoSlug>/<branchSlug>`.
+ * `<baseDir>/<repoSlug>/<branchSlug>`.
+ *
+ * Os dois segmentos são `<trecho-legível>-<hash8>`: o trecho legível é
+ * truncado porque o checkout de uma PR herda a profundidade dos arquivos do
+ * projeto, e o Windows (MAX_PATH = 260) estoura "Filename too long" com
+ * repo+branch longos. O hash mantém o nome determinístico e único.
+ *
+ * Cada worktree recebe o espelho da camada gerada (`.houndsman/core`) do clone
+ * principal — o checkout não traz arquivos ignorados e, sem ela, a config do
+ * projeto não importa (`../core/types`).
  */
 
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createGitRunner } from "../git-runner";
+import { CORE_DIR } from "../paths";
 import { sanitizeBranch } from "../report-builder";
 import { worktreesRoot } from "../storage/paths";
 import { GitRepository } from "./git-repository";
@@ -54,7 +64,7 @@ export type RemoveWorktreeResult = {
 /** Opções do gerenciador. */
 export type WorktreeManagerOptions = {
 	repoKey: string;
-	/** Raiz do clone principal. */
+	/** Raiz do clone principal (fonte da camada gerada espelhada). */
 	repoRoot: string;
 	/**
 	 * Raiz onde os diretórios por repositório são criados.
@@ -64,6 +74,22 @@ export type WorktreeManagerOptions = {
 	baseDir?: string;
 };
 
+/** Limite do trecho legível no diretório do repositório. */
+const REPO_SLUG_MAX = 24;
+/** Limite do trecho legível no diretório da branch. */
+const BRANCH_SLUG_MAX = 20;
+
+/**
+ * `<trecho legível truncado>-<hash8>`: curto o bastante para o MAX_PATH do
+ * Windows e estável para o mesmo par (repositório, branch).
+ */
+function hashName(key: string, readable: string, max: number, fallback: string): string {
+	const hash = createHash("sha1").update(key).digest("hex").slice(0, 8);
+	// Ponto/traço no fim do nome é descartado pelo Windows; corte antes do hash.
+	const head = readable.slice(0, max).replace(/[-._]+$/, "");
+	return `${head || fallback}-${hash}`;
+}
+
 /** Slug estável e legível para o diretório do repositório. */
 export function repoSlug(repoKey: string): string {
 	const clean = repoKey
@@ -71,8 +97,12 @@ export function repoSlug(repoKey: string): string {
 		.replace(/[^a-zA-Z0-9._-]+/g, "-")
 		.replace(/^-+|-+$/g, "")
 		.toLowerCase();
-	const hash = createHash("sha1").update(repoKey).digest("hex").slice(0, 8);
-	return `${clean.slice(-60) || "repo"}-${hash}`;
+	return hashName(repoKey, clean.slice(-REPO_SLUG_MAX), REPO_SLUG_MAX, "repo");
+}
+
+/** Slug estável e curto para o diretório de uma branch. */
+export function branchSlug(branch: string): string {
+	return hashName(branch, sanitizeBranch(branch), BRANCH_SLUG_MAX, "branch");
 }
 
 /** Normaliza um path para comparação (Windows é case-insensitive). */
@@ -87,6 +117,54 @@ function isInside(root: string, path: string): boolean {
 	return rel === "" || (!rel.startsWith("..") && !rel.split(sep).includes(".."));
 }
 
+/** Raiz do clone principal a partir do diretório git comum (ou `null`). */
+function mainRootOf(git: GitRepository): string | null {
+	const common = git.gitCommonDir();
+	if (!common) return null;
+	const gitDir = resolve(common);
+	return basename(gitDir).toLowerCase() === ".git" ? dirname(gitDir) : null;
+}
+
+/**
+ * Espelha a camada gerada (`.houndsman/core`) do clone principal no worktree.
+ *
+ * O checkout de uma PR só traz arquivos versionados e `core/` é gerado (e
+ * ignorado pelo git). Sem ele, qualquer comando dentro do worktree falha ao
+ * importar `../core/types` a partir dos watchdogs. Fail-open: nunca bloqueia
+ * a revisão.
+ */
+export function syncProjectLayer(mainRoot: string, worktreeRoot: string): boolean {
+	const source = join(mainRoot, CORE_DIR);
+	const dest = join(worktreeRoot, CORE_DIR);
+	if (normalizePath(source) === normalizePath(dest)) return false;
+	if (!existsSync(source)) return false;
+	try {
+		mkdirSync(dirname(dest), { recursive: true });
+		cpSync(source, dest, { recursive: true, force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Auto-reparo para comandos executados **dentro** de um worktree: repõe a
+ * camada gerada a partir do clone principal quando ela não existe ali. No
+ * clone principal (camada presente) é no-op. Fail-open.
+ */
+export function syncProjectLayerForRoot(root: string): boolean {
+	try {
+		const git = new GitRepository(createGitRunner(root));
+		const gitRoot = git.rootPath();
+		if (!gitRoot || existsSync(join(gitRoot, CORE_DIR))) return false;
+		const mainRoot = mainRootOf(git);
+		if (!mainRoot) return false;
+		return syncProjectLayer(mainRoot, gitRoot);
+	} catch {
+		return false;
+	}
+}
+
 /** Fatia a saída de `git worktree list --porcelain` em entradas. */
 export function parseWorktreeList(raw: string): WorktreeEntry[] {
 	const entries: WorktreeEntry[] = [];
@@ -125,11 +203,13 @@ export function parseWorktreeList(raw: string): WorktreeEntry[] {
 export class WorktreeManager {
 	private readonly git: GitRepository;
 	private readonly repoKey: string;
+	private readonly repoRoot: string;
 	private readonly rootDir: string;
 
 	constructor(git: GitRepository, options: WorktreeManagerOptions) {
 		this.git = git;
 		this.repoKey = options.repoKey;
+		this.repoRoot = options.repoRoot;
 		this.rootDir = join(
 			options.baseDir ?? worktreesRoot(),
 			repoSlug(options.repoKey),
@@ -154,8 +234,7 @@ export class WorktreeManager {
 
 	/** Caminho determinístico do worktree de uma branch. */
 	pathFor(branch: string): string {
-		const slug = sanitizeBranch(branch) || "branch";
-		return join(this.rootDir, slug);
+		return join(this.rootDir, branchSlug(branch));
 	}
 
 	/** Todos os worktrees registrados no repositório. */
@@ -190,6 +269,7 @@ export class WorktreeManager {
 
 		if (existing) {
 			if (existing.head === target) {
+				syncProjectLayer(this.repoRoot, path);
 				return { path, head: target, created: false, reused: true };
 			}
 			const checkout = new GitRepository(createGitRunner(path)).tryRun([
@@ -198,6 +278,7 @@ export class WorktreeManager {
 				target,
 			]);
 			if (checkout.ok) {
+				syncProjectLayer(this.repoRoot, path);
 				return { path, head: target, created: false, reused: true };
 			}
 			// Worktree quebrado/inacessível: remove e recria do zero.
@@ -227,6 +308,8 @@ export class WorktreeManager {
 				);
 			}
 		}
+		// A camada gerada é ignorada pelo git e não vem no checkout da PR.
+		syncProjectLayer(this.repoRoot, path);
 		return { path, head: target, created: true, reused: false };
 	}
 

package/src/core/storage/types.ts

@@ -102,6 +102,7 @@ export type ArtifactKind =
 	| "finding-report"
 	| "review"
 	| "resume"
+	| "technical"
 	| "domain-review"
 	| "verify"
 	| "ast"