@event4u/agent-config 9.8.0 → 9.10.0

package/src/scripts/check_site_links.ts

@@ -10,8 +10,9 @@
  * (`http(s):`, `mailto:`, `data:`, protocol-relative `//`) links and pure `#`
  * anchors are skipped — this gate owns *internal* integrity only.
  *
- * Read-only. Exit 0 clean / 1 on any broken internal link, 2 if the site has not
- * been built yet (run `cd site && npm run build` first).
+ * Read-only. Exit 0 clean / 1 on any broken internal link, 2 if the build is
+ * missing OR stale (run `cd site && npm run build` first). Staleness matters as much
+ * as absence: a green verdict over an old partial build is a gate that cannot fail.
  *
  * Usage:
  *   ./scripts-run src/scripts/check_site_links            # scan site/dist
@@ -117,19 +118,77 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         process.stderr.write(`❌  site not built: ${distDir} is missing. Run \`cd site && npm ci && npm run build\` first.\n`);
         return 2;
     }
+    // A missing dist was already an exit-2; a STALE one was not, so the checker
+    // reported green over an old partial build (measured: 6 pages against 25 content
+    // sources, every source newer than the build). Green over a build that does not
+    // contain the pages being checked is worse than red — it is a gate that cannot
+    // fail. Same silent-green class as the per-pack matrix removed alongside this.
+    const stale = _stalenessVerdict(distDir);
+    if (stale !== null) {
+        process.stderr.write(`❌  site build is stale: ${stale}. Run \`cd site && npm ci && npm run build\` first.\n`);
+        return 2;
+    }
     const broken = findBrokenLinks(distDir, base);
     if (broken.length > 0) {
         process.stdout.write(`❌  ${broken.length} broken internal link(s) in the built site:\n`);
         for (const b of broken) process.stdout.write(`  - ${b.page}: ${b.link}\n`);
+        process.stderr.write(`scanned: ${_walkHtml(distDir).length}\n`);
         return 1;
     }
+    const pages = _walkHtml(distDir).length;
+    // Machine-readable count for check_gate_coverage — emitted regardless of
+    // --quiet, and on every exit path above too, so a gate with real findings
+    // still reports what it inspected (the emission bug found on #1047).
+    process.stderr.write(`scanned: ${pages}\n`);
     if (!quiet) {
-        const pages = _walkHtml(distDir).length;
         process.stdout.write(`✅  site links: ${pages} page(s), no broken internal links (base ${base}).\n`);
     }
     return 0;
 }
 
+/**
+ * Why the built site cannot be trusted, or `null` when it looks current.
+ *
+ * Two independent signals, because they catch different failures:
+ *  - a content source newer than every built page  → the build predates an edit;
+ *  - materially fewer pages than content sources   → the build is partial.
+ *
+ * Both are cheap `stat` walks. Exported for the test.
+ */
+export function _stalenessVerdict(distDir: string, contentDir?: string): string | null {
+    const content = contentDir ?? path.join(REPO, 'site', 'src', 'content');
+    if (!fs.existsSync(content)) {
+        return null; // nothing to compare against — not this checker's verdict to make
+    }
+    const sources = _walkFiles(content).filter((f) => f.endsWith('.md') || f.endsWith('.mdx'));
+    if (sources.length === 0) {
+        return null;
+    }
+    const pages = _walkHtml(distDir);
+    if (pages.length === 0) {
+        return 'the build contains no HTML pages';
+    }
+    const newestPage = Math.max(...pages.map((p) => fs.statSync(p).mtimeMs));
+    const newer = sources.filter((s) => fs.statSync(s).mtimeMs > newestPage);
+    if (newer.length > 0) {
+        return `${newer.length} of ${sources.length} content source(s) are newer than the newest built page`;
+    }
+    if (pages.length < sources.length) {
+        return `only ${pages.length} page(s) built for ${sources.length} content source(s)`;
+    }
+    return null;
+}
+
+function _walkFiles(dir: string): string[] {
+    const out: string[] = [];
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) out.push(..._walkFiles(full));
+        else if (e.isFile()) out.push(full);
+    }
+    return out;
+}
+
 function _isCliEntry(): boolean {
     if (process.argv[1] === undefined) {
         return false;

package/src/scripts/check_source_pointer_freshness.ts

@@ -17,9 +17,12 @@
  * genuinely-historical line inside an allowlisted file is exempted with an
  * inline `<!-- pointer-freshness: historical -->` marker.
  *
- * Extend AUTHORING_FILES as the broader `.agent-src.uncondensed` cleanup lands
- * (186 files still carry the token; see road-to-doc-follows-code Phase 4/5
- * follow-up).
+ * Extend AUTHORING_FILES as the broader `.agent-src.uncondensed` cleanup lands.
+ * road-to-retire-stale-authoring-pointers (2026-07-28) migrated the stale
+ * *authoring-source* pointers (43 `.md` lines) to `src/` and added the now
+ * token-free files here; the remaining `.agent-src.uncondensed/` references in
+ * `src/` are live code constants / pipeline descriptions / catalog paths that
+ * are correct and must stay (not authoring pointers).
  *
  * Exit codes: 0 = clean, 1 = a retired pointer in an allowlisted authoring
  * file, 2 = usage / self-test failure.
@@ -41,8 +44,30 @@ const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 // name the retired `.agent-src.uncondensed/` tree as current. Extend as the
 // broader cleanup lands.
 const AUTHORING_FILES: readonly string[] = [
+    // Seeded by #989 (the source-of-truth README + thin-root skill).
     'src/agent-src/README.md',
     'src/skills/agents-md-thin-root/SKILL.md',
+    // Added by road-to-retire-stale-authoring-pointers (2026-07-28): files whose
+    // stale "edit `.agent-src.uncondensed/`" authoring pointers were migrated to
+    // `src/` and are now token-free — locking them against regression. Files that
+    // retain legitimate `.agent-src.uncondensed/` references (pipeline
+    // descriptions, catalog-asset paths, validator_ignore config, fenced code)
+    // are intentionally NOT listed — they are guarded behaviorally by the
+    // downstream-changes § Doc-Impact rule, not by this any-occurrence scan.
+    'src/agent-src/templates/persona.md',
+    'src/domains/ai-video/image/command.md',
+    'src/domains/ai-video/video/command.md',
+    'src/domains/engineering-base/fix/portability/command.md',
+    'src/domains/engineering-base/fix/refs/command.md',
+    'src/domains/gtm-marketing/post-as/command.md',
+    'src/domains/meta/agents/command.md',
+    'src/domains/meta/agents/user/command.md',
+    'src/domains/meta/optimize/augmentignore/command.md',
+    'src/domains/product-basic/roadmap/ai-council/command.md',
+    'src/domains/product-discovery/research/command.md',
+    'src/skills/md-language-check/SKILL.md',
+    'src/skills/override-management/SKILL.md',
+    'src/skills/rule-refactor/SKILL.md',
 ];
 
 // Retired source-of-truth pointer. Matches both the bare token and the older

package/src/scripts/code_graph/cli.ts

@@ -4,26 +4,73 @@
  *
  *   build    [--root P] [--out P] [--force]   (re)build the deterministic graph
  *   validate [--graph P]                       schema-gate a graph.json
+ *   detect   [--root P] [--format json]        three-state freshness verdict
+ *   refresh  [--root P] [--out P] [--budget-seconds N]
+ *                                               build --update (STALE) / no-op
+ *                                               (FRESH) / full build (ABSENT)
  *
- * Query subcommands (query/path/explain/affected/detect) are added by the
- * Phase-3 query tier. Deterministic, LLM-free, no network. Exit codes:
- * 0 ok · 1 not-found / validation-failed · 2 usage · 3 internal.
+ * `detect --format json` (Phase 2, road-to-reachable-code-memory) emits a
+ * single-line, stable-key-order JSON verdict on stdout — no timestamps, safe
+ * to diff or pipe to `jq`:
+ *
+ *   { "verdict": "ABSENT" | "STALE" | "FRESH",
+ *     "behind_commits": <n> | null,
+ *     "source": { "kind": "consumer" | "scip" | "native", "path": "…" } | null,
+ *     "sources": [ { "kind": …, "path": "…", "present": true, … }, … ] }
+ *
+ * `refresh` never blocks on a hung build: it spawns the actual `build` in a
+ * CHILD process against a temp `--out` path, under a hard wall-clock
+ * `--budget-seconds` (default 60, via SIGKILL). The real cache at `--out` is
+ * only ever touched by a same-directory atomic rename of that child's
+ * completed temp output — on budget-exceeded, build failure, or the child
+ * never producing output, the rename never happens and the OLD cache is left
+ * byte-for-byte untouched. The cache itself (default
+ * `agents/runtime/state/code-graph-v1.json`) is local-only and disposable —
+ * gitignored, rebuildable from source at any time; never a source of truth.
+ *
+ * Query subcommands (query/path/explain/affected) are added by the Phase-3
+ * query tier. Deterministic, LLM-free, no network. Exit codes:
+ * 0 ok · 1 not-found / validation-failed / refresh-budget-exceeded ·
+ * 2 usage · 3 internal.
+ *
+ *   suggest-verb "<question>"                  (Phase 9 D3) print the verb
+ *                                               (query/affected/path/explain)
+ *                                               a regex table thinks best
+ *                                               answers a free-text structure
+ *                                               question — a standalone hint,
+ *                                               never auto-run against a
+ *                                               graph.
  */
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 
 import { hardenedSpawnEnv } from '../_lib/spawn_env.js';
-import { buildFromRepo } from './build.js';
-import { detectSources, pickSource } from './detect.js';
-import { affected, explain, loadGraph, type LoadedGraph, path as graphPath, query, type QueryResult } from './query.js';
+import { buildFromRepo, sidecarPath } from './build.js';
+import { computeVerdict, detectSources, pickSource } from './detect.js';
+import { suggestVerb } from './intent.js';
+import {
+    affected,
+    explain,
+    loadGraph,
+    type LoadedGraph,
+    mergeRecommendedReads,
+    path as graphPath,
+    query,
+    type QueryResult,
+} from './query.js';
 import { validateGraph } from './validate.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..', '..');
 export const DEFAULT_CACHE = path.join(REPO_ROOT, 'agents', 'runtime', 'state', 'code-graph-v1.json');
+/** Local `tsx` binary — `refresh` spawns `build` as a child of THIS file
+ * through it, so a budget-exceeded kill only ever terminates the child. */
+const TSX_BIN = path.join(REPO_ROOT, 'node_modules', '.bin', process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
+const DEFAULT_BUDGET_SECONDS = 60;
 
 function flag(argv: string[], name: string): string | null {
     const i = argv.indexOf(name);
@@ -93,6 +140,10 @@ function render(r: QueryResult, staleNote: string): number {
     for (const l of r.lines) process.stdout.write(`  ${l}\n`);
     if (r.truncated) process.stdout.write('  … (budget reached — narrow the seed or raise --budget)\n');
     if (!r.lines.length) process.stdout.write('  (no matching relations)\n');
+    if (r.recommended_reads.length) {
+        process.stdout.write('recommended reads (dropped by the budget, or a low-confidence seed match):\n');
+        for (const rr of r.recommended_reads) process.stdout.write(`  ${rr.path}${rr.lines ? `:${rr.lines[0]}-${rr.lines[1]}` : ''}\n`);
+    }
     return 0;
 }
 
@@ -130,12 +181,16 @@ function cmdQuery(kind: 'query' | 'explain' | 'affected' | 'path', argv: string[
     if (kind === 'affected' && flag(argv, '--since')) {
         const root = flag(argv, '--root') ?? REPO_ROOT;
         const seeds = changedNodeSeeds(r.g, root, flag(argv, '--since') as string);
-        const merged: QueryResult = { source: r.g.source, seeds: [], lines: [], truncated: false };
+        const merged: QueryResult = { source: r.g.source, seeds: [], lines: [], truncated: false, recommended_reads: [] };
+        const perSeed: QueryResult[] = [];
         for (const s of seeds) {
             const one = affected(r.g, s, 2, budget);
             merged.seeds.push(...one.seeds);
             merged.lines.push(...one.lines);
+            merged.truncated = merged.truncated || one.truncated;
+            perSeed.push(one);
         }
+        merged.recommended_reads = mergeRecommendedReads(perSeed);
         return render(merged, r.note);
     }
     const a = positional[0];
@@ -162,6 +217,12 @@ function isFlagValue(argv: string[], token: string): boolean {
 
 function cmdDetect(argv: string[]): number {
     const root = flag(argv, '--root') ?? REPO_ROOT;
+    if (flag(argv, '--format') === 'json') {
+        // Machine-readable three-state verdict (Phase 2). Existing human-text
+        // output below is unchanged for existing consumers.
+        process.stdout.write(`${JSON.stringify(computeVerdict(root, DEFAULT_CACHE))}\n`);
+        return 0;
+    }
     const verdicts = detectSources(root, DEFAULT_CACHE);
     if (!verdicts.length) {
         process.stdout.write('no code-graph source detected\n');
@@ -176,16 +237,127 @@ function cmdDetect(argv: string[]): number {
     return 0;
 }
 
+function budgetSecondsOf(argv: string[]): number {
+    const raw = flag(argv, '--budget-seconds');
+    if (raw === null) return DEFAULT_BUDGET_SECONDS;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : DEFAULT_BUDGET_SECONDS;
+}
+
+/** Best-effort removal of a temp build output + its sidecar. Never throws —
+ * cleanup failure must not mask the real result (budget-exceeded / error). */
+function cleanupTemp(tmpOut: string): void {
+    for (const p of [tmpOut, sidecarPath(tmpOut)]) {
+        try {
+            fs.unlinkSync(p);
+        } catch {
+            /* already absent, or never materialised — fine */
+        }
+    }
+}
+
+/**
+ * Run `build` (optionally `--update`) as a CHILD process against a temp
+ * `--out` path, under a hard wall-clock budget. Only on a clean, in-budget
+ * exit does the temp output get promoted into `out` — via a same-directory
+ * `renameSync`, atomic at the OS level, exactly the technique `write_atomic`
+ * itself uses. Any other outcome (timeout, non-zero exit, missing output)
+ * cleans up the temp files and leaves `out` untouched.
+ */
+function runBudgetedBuild(root: string, out: string, update: boolean, budgetSeconds: number): number {
+    if (!(budgetSeconds > 0)) {
+        // Node's own `timeout` option treats 0 as "no limit" — a genuinely
+        // zero-or-negative budget is an immediate, deterministic abort
+        // instead of silently becoming unlimited.
+        process.stderr.write(`code-graph: refresh budget exceeded (${budgetSeconds}s) — old cache kept\n`);
+        return 1;
+    }
+    const dir = path.dirname(out);
+    const tmpOut = path.join(dir, `.${path.basename(out)}.refresh-tmp-${process.pid}-${randomBytes(4).toString('hex')}.json`);
+    if (update) {
+        const realSidecar = sidecarPath(out);
+        if (fs.existsSync(realSidecar)) {
+            try {
+                fs.copyFileSync(realSidecar, sidecarPath(tmpOut));
+            } catch {
+                /* fall back to a full re-extraction inside the child */
+            }
+        }
+    }
+    const args = ['build', '--root', root, '--out', tmpOut, ...(update ? ['--update'] : [])];
+    const res = spawnSync(TSX_BIN, [_HERE, ...args], {
+        env: hardenedSpawnEnv(),
+        stdio: 'ignore',
+        timeout: Math.round(budgetSeconds * 1000),
+        killSignal: 'SIGKILL',
+    });
+    const timedOut = res.signal !== null || (res.error !== undefined && (res.error as NodeJS.ErrnoException).code === 'ETIMEDOUT');
+    if (timedOut) {
+        cleanupTemp(tmpOut);
+        process.stderr.write(`code-graph: refresh budget exceeded (${budgetSeconds}s) — old cache kept\n`);
+        return 1;
+    }
+    if (res.status !== 0) {
+        cleanupTemp(tmpOut);
+        const detail = res.error ? `: ${res.error.message}` : res.status !== null ? ` (exit ${res.status})` : '';
+        process.stderr.write(`code-graph: refresh build failed${detail} — old cache kept\n`);
+        return 1;
+    }
+    if (!fs.existsSync(tmpOut)) {
+        cleanupTemp(tmpOut);
+        process.stderr.write('code-graph: refresh produced no output — old cache kept\n');
+        return 3;
+    }
+    fs.renameSync(tmpOut, out); // same-dir → atomic; real cache only ever changes here
+    const tmpSidecar = sidecarPath(tmpOut);
+    if (fs.existsSync(tmpSidecar)) fs.renameSync(tmpSidecar, sidecarPath(out));
+    process.stdout.write(`✅  code-graph refreshed — cache: ${path.relative(REPO_ROOT, out)}\n`);
+    return 0;
+}
+
+function cmdRefresh(argv: string[]): number {
+    const root = flag(argv, '--root') ?? REPO_ROOT;
+    const out = flag(argv, '--out') ?? DEFAULT_CACHE;
+    const budgetSeconds = budgetSecondsOf(argv);
+    if (!fs.existsSync(root)) {
+        process.stderr.write(`code-graph: root not found: ${root}\n`);
+        return 1;
+    }
+    const v = computeVerdict(root, out);
+    if (v.verdict === 'FRESH') {
+        process.stdout.write('fresh — nothing to do\n');
+        return 0;
+    }
+    return runBudgetedBuild(root, out, v.verdict === 'STALE', budgetSeconds);
+}
+
+/**
+ * `suggest-verb "<question>"` (Phase 9 D3) — print the `code_graph` verb a
+ * pure regex table thinks best answers a free-text structure question. A
+ * standalone hint only: never resolves a graph, never runs a query itself.
+ */
+function cmdSuggestVerb(argv: string[]): number {
+    const question = argv.filter((a) => !a.startsWith('--')).join(' ').trim();
+    if (!question) {
+        process.stderr.write('usage: code_graph/cli.ts suggest-verb "<question>"\n');
+        return 2;
+    }
+    process.stdout.write(`${suggestVerb(question)}\n`);
+    return 0;
+}
+
 export async function main(argv: string[] = process.argv.slice(2)): Promise<number> {
     const sub = argv[0];
     try {
         if (sub === 'build') return await cmdBuild(argv.slice(1));
         if (sub === 'validate') return cmdValidate(argv.slice(1));
         if (sub === 'detect') return cmdDetect(argv.slice(1));
+        if (sub === 'refresh') return cmdRefresh(argv.slice(1));
         if (sub === 'query' || sub === 'explain' || sub === 'affected' || sub === 'path')
             return cmdQuery(sub, argv.slice(1));
+        if (sub === 'suggest-verb') return cmdSuggestVerb(argv.slice(1));
         process.stderr.write(
-            'usage: code_graph/cli.ts <build|validate|detect|query|explain|affected|path> [options]\n',
+            'usage: code_graph/cli.ts <build|validate|detect|refresh|query|explain|affected|path|suggest-verb> [options]\n',
         );
         return 2;
     } catch (e) {

package/src/scripts/code_graph/detect.ts

@@ -132,3 +132,55 @@ export function pickSource(verdicts: SourceVerdict[]): SourceVerdict | null {
     if (native) return native;
     return verdicts.find((v) => v.kind === 'consumer') ?? null;
 }
+
+/** A single detected source, JSON-shaped (only defined fields are emitted —
+ * key order fixed by construction so `JSON.stringify` output is stable). */
+export interface DetectedSourceJSON {
+    kind: SourceKind;
+    path: string;
+    present: boolean;
+    stale?: boolean;
+    commits_behind?: number;
+    note?: string;
+}
+
+/** The `code-graph detect --format json` verdict shape (Phase 2). Deterministic:
+ * fixed key order, no timestamps, paths relative to `root`. */
+export interface VerdictJSON {
+    verdict: 'ABSENT' | 'STALE' | 'FRESH';
+    /** commits behind, when known from the picked source; else null. */
+    behind_commits: number | null;
+    /** the source `refresh`/queries would use, or null when ABSENT. */
+    source: { kind: SourceKind; path: string } | null;
+    /** every detected source (for diagnostics), not just the picked one. */
+    sources: DetectedSourceJSON[];
+}
+
+/**
+ * Three-state freshness verdict for `root`, reusing `detectSources` +
+ * `pickSource` (no duplicated precedence logic). ABSENT = no usable source
+ * (a bare `scip` presence or nothing at all); STALE = the picked source is
+ * stale; FRESH = picked source is fresh, or freshness is unknown (mirrors the
+ * nudge hook's `picked.stale ? STALE : FRESH` reading — unknown is not
+ * treated as stale).
+ */
+export function computeVerdict(root: string, nativeCache: string): VerdictJSON {
+    const abs = path.resolve(root);
+    const verdicts = detectSources(root, nativeCache);
+    const picked = pickSource(verdicts);
+    const rel = (p: string): string => path.relative(abs, p).split(path.sep).join('/');
+    const verdict: VerdictJSON['verdict'] = picked === null ? 'ABSENT' : picked.stale ? 'STALE' : 'FRESH';
+    const sources: DetectedSourceJSON[] = verdicts.map((v) => {
+        const s: DetectedSourceJSON = { kind: v.kind, path: rel(v.path), present: v.present };
+        if (v.stale !== undefined) s.stale = v.stale;
+        if (v.commits_behind !== undefined) s.commits_behind = v.commits_behind;
+        if (v.note !== undefined) s.note = v.note;
+        return s;
+    });
+    return {
+        verdict,
+        behind_commits: picked?.commits_behind ?? null,
+        source: picked ? { kind: picked.kind, path: rel(picked.path) } : null,
+        sources,
+    };
+}

package/src/scripts/code_graph/intent.ts

@@ -0,0 +1,45 @@
+/**
+ * Intent-conditioned verb selection (Phase 9 D3, road-to-reachable-code-memory)
+ * — a PURE regex table, no model call. `suggestVerb` maps a natural-language
+ * structure question to the `code_graph` subcommand most likely to answer it:
+ *
+ *   affected — "who calls / uses / references this", "what would break",
+ *              "blast radius" — a reverse (who-depends-on-it) lookup.
+ *   path     — "how does X reach/connect to Y", "is A reachable from B",
+ *              "trace the route between A and B" — connectivity between
+ *              two named seeds.
+ *   explain  — "overview", "what's around X", "the neighbourhood of X",
+ *              "walk me through X" — a broader 2-hop neighbourhood, not a
+ *              single direct-relations answer.
+ *   query    — the default: a seed's own direct (1-hop) relations.
+ *
+ * Order matters — first pattern class to match wins: affected → path →
+ * explain → query. Ship gate (pre-registered in
+ * `tests/fixtures/code-graph-intent/queries.json`, written BEFORE this file):
+ * `suggestVerb` must beat the always-`query` baseline's correct-verb rate
+ * over that 30-query set, or this module stays unwired (evidence only, per
+ * the D3 evidence note in `agents/evidence/reports/`).
+ */
+
+export type Verb = 'query' | 'affected' | 'path' | 'explain';
+
+const AFFECTED_RE =
+    /\b(who\s+(calls?|uses?|else|references?)|where\s+(is|are|'s)?\s*.*\bused\b|impact(s|ed|ing)?|blast\s+radius|break(s|ing)?|would\s+break|caller(s)?|referenc(e|es|ed|ing)|touch(es|ed)?)\b/i;
+
+const PATH_RE =
+    /\b(reach(able|es|ing)?|connect(s|ed|ion|ing)?|\btrace\b|\broute\b|\bpath\b|shortest)\b/i;
+
+const EXPLAIN_RE =
+    /\b(overview|explain(s|ed|ing)?|\baround\b|surround(ing|s)?|\bcontext\b|big\s+picture|neighbo[u]?rhood|walk\s+me\s+through|summar(y|ize|ise))\b/i;
+
+/**
+ * Suggest the `code_graph` verb a free-text structure question most likely
+ * needs. Deterministic, side-effect-free, no network, no model call.
+ */
+export function suggestVerb(question: string): Verb {
+    const q = question.trim();
+    if (AFFECTED_RE.test(q)) return 'affected';
+    if (PATH_RE.test(q)) return 'path';
+    if (EXPLAIN_RE.test(q)) return 'explain';
+    return 'query';
+}