@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/orchestrator/dist/hookDecision.js

@@ -2,7 +2,7 @@
 // without holding the rest of the orchestrator.
 //
 // `.claude/hooks/guard.sh` fires on every Bash/Write/Edit/MultiEdit/
-// NotebookEdit call an agent makes, which makes whatever it execs the most
+// NotebookEdit/Agent/Task call an agent makes, which makes whatever it execs the most
 // frequently run code in this repo by orders of magnitude. It used to exec
 // `dist/cli.js policy hook`; cli.ts imports the whole orchestrator at module
 // scope, `db/projector.js` and so drizzle-orm among it, and that graph cost
@@ -13,8 +13,47 @@
 // same function rather than a second copy of it.
 import { accessSync, constants, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
-import { detectCurrentBranch, detectRepoRoot, evaluateCommand, loadGuardrailPolicy, } from './policy.js';
+import { roleOfAgentType } from './agentNames.js';
+import { parseDeclaredArtifactLine } from './declaredArtifactLine.js';
+import { JUDGE_ROLES } from './judgeRoles.js';
+import { detectCurrentBranch, detectRepoRoot, evaluateCommand, isProtectedBranchName, loadGuardrailPolicy, } from './policy.js';
 import { activeSandboxFor } from './sandbox.js';
+const JUDGE_ROLE_NAMES = new Set(JUDGE_ROLES);
+/**
+ * A judge-role subagent dispatch must carry `Declared artifact: <absolute path>`
+ * in its prompt, because judge-stop.sh reads the prompt (never a brief file) to
+ * know what the judge owes. Same parser as judge-stop, so what is accepted here
+ * is what it reads. Any other role, prefix or missing type is allowed silently.
+ */
+function decideAgentDispatch(input) {
+    const type = typeof input?.subagent_type === 'string' ? input.subagent_type : '';
+    // Same mapping as judge-stop: `bs-reviewer`, `blacksmith:bs-reviewer` and the
+    // bare pre-prefix names all reach the role. Another plugin's namespace
+    // (`other:reviewer`) is not a Blacksmith agent, so it is skipped, not stripped.
+    const colon = type.indexOf(':');
+    if (colon !== -1 && type.slice(0, colon) !== 'blacksmith')
+        return null;
+    const role = roleOfAgentType(type);
+    if (role === null || !JUDGE_ROLE_NAMES.has(role))
+        return null;
+    const prompt = typeof input?.prompt === 'string' ? input.prompt : '';
+    const declared = parseDeclaredArtifactLine(prompt);
+    if (declared !== null && path.isAbsolute(declared))
+        return null;
+    const found = declared === null
+        ? ''
+        : ` The prompt has "${declared}", which is relative; the path must be absolute.`;
+    return {
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'deny',
+            permissionDecisionReason: `A "${role}" dispatch must declare the artifact it writes. The prompt needs a line reading exactly ` +
+                '`Declared artifact: <absolute path>` on its own line, not indented, and in the prompt itself ' +
+                `(judge-stop reads the prompt, not a brief file the agent reads).${found} ` +
+                '`judge dispatch` prints the line to paste, as `expected_line`.',
+        },
+    };
+}
 /**
  * Reads one PreToolUse payload and answers with the envelope to print, or
  * `null` to print nothing.
@@ -38,6 +77,9 @@ export function decideHookPayload(raw, fallbackCwd,
 /** Where judge leases live; the live `state/sandboxes` unless a test points elsewhere. */
 leaseDir) {
     const payload = JSON.parse(raw);
+    if (payload.tool_name === 'Agent' || payload.tool_name === 'Task') {
+        return decideAgentDispatch(payload.tool_input);
+    }
     const toolName = typeof payload.tool_name === 'string' ? payload.tool_name : '';
     const command = typeof payload.tool_input?.command === 'string' ? payload.tool_input.command : '';
     // A `Write`/`Edit`/`MultiEdit` payload carries no command; its target is
@@ -93,6 +135,8 @@ leaseDir) {
         ? certain
         : fallbackDirectories(command, cwd).map(locate);
     let reason = null;
+    let firingRuleId = null;
+    let firingDir = null;
     for (const { dir, branch, repoRoot } of places) {
         const targetLease = dir === cwd ? null : activeSandboxFor(dir, leaseDir);
         for (const sandbox of distinctLeases(sessionLease, targetLease)) {
@@ -106,13 +150,38 @@ leaseDir) {
             // behaviour even though evaluateCommand (policy check's diagnostic
             // output) reports every rule that tripped.
             if (!decision.allowed) {
-                reason = decision.violations[0]?.reason ?? 'guardrails.yml denied this command.';
+                const violation = decision.violations[0];
+                reason = violation?.reason ?? 'guardrails.yml denied this command.';
+                firingRuleId = violation?.ruleId ?? null;
+                firingDir = dir;
                 break;
             }
         }
         if (reason !== null)
             break;
     }
+    // Rule 3 denying on the fallback (`certain === null`) because cwd itself is
+    // protected is a guess dressed as fact when the command also named another
+    // directory that is NOT protected: the fallback ran only because the shape
+    // could not be read for certain, not because cwd is provably where this
+    // runs. Swap in a reason that says so and names the readable shapes, so the
+    // same merge can go through rewritten. Every other case — no named
+    // directory, or a named directory that is protected too — keeps the
+    // original reason unchanged.
+    if (reason !== null &&
+        firingRuleId === 'merge-into-protected' &&
+        certain == null &&
+        firingDir === cwd) {
+        const namedUnprotected = places.some((p) => p.dir !== cwd &&
+            p.branch !== '' &&
+            p.branch !== 'HEAD' &&
+            p.repoRoot !== null &&
+            !isProtectedBranchName(p.branch, policy));
+        if (namedUnprotected) {
+            const cwdBranch = places.find((p) => p.dir === cwd)?.branch ?? '';
+            reason = fallbackMergeReason(cwdBranch);
+        }
+    }
     if (reason === null) {
         // Allow prints NOTHING, on purpose, and this is not a cosmetic choice.
         // Claude Code reads an explicit `permissionDecision: "allow"` from a hook
@@ -137,6 +206,26 @@ leaseDir) {
         },
     };
 }
+/**
+ * Rule 3's fallback reason for the one case where "you are on {branch}"
+ * states a guess as fact: the command named another directory, that
+ * directory is NOT protected, and the only reason cwd was judged at all is
+ * that the command's shape was not one `shortcutDirectories` can read for
+ * certain — see its own doc comment for the two shapes it accepts. Says so
+ * plainly, and names those shapes, rather than telling an agent already
+ * standing on a side branch to "check out a side branch instead".
+ */
+function fallbackMergeReason(cwdBranch) {
+    return (`this command's shape is not one the guard can read for certain, so it ` +
+        `was also judged against your session's own directory, which is on ` +
+        `${cwdBranch}, a protected branch; git merge/pull is denied there. The ` +
+        `guard reads \`cd <dir> && git <cmd> …\` — <dir> absolute or starting ` +
+        `with \`./\`, joined only by \`&&\`, each command merge, pull or another ` +
+        `read-safe git subcommand (not checkout or switch) — or a single ` +
+        `\`git -C <dir> merge …\`; plain words only, no pipes, \`;\`, redirects, ` +
+        `quotes or variables. Write it that way and the same merge is judged in ` +
+        `<dir> alone.`);
+}
 /**
  * The one shape judged in its target alone, or `null` to fall back. An
  * allowlist, because this is the only path that drops `cwd` and so the only

package/factory/orchestrator/dist/integration.js

@@ -2,7 +2,7 @@ import { SmithError } from './errors.js';
 import { appendEvent, validateEventEnvelope } from './events.js';
 import { runGit as git } from './git.js';
 import { run } from './testgate.js';
-import { integrationBranchName, RESERVED_TASK_ID } from './worktree.js';
+import { epicBranchPrefix, integrationBranchName, RESERVED_TASK_ID } from './worktree.js';
 /**
  * D-42/P9-26, second half. Moving the worktrees outside the project root
  * (worktree.ts) fixes the tool that went red; it does not fix the reason
@@ -36,13 +36,15 @@ function branchHead(projectDir, branch) {
     }
 }
 /**
- * The current head of `smith/<epic>/integration`, or null when the epic has
- * no integration branch (never planned, never dispatched, wrong --epic).
- * Read here rather than inside epic.ts so the verdict stays git-free and
- * purely a fold over events — the CLI passes the sha in.
+ * The current head of `<prefix>/<epic>/integration` (`bs/` for a new epic,
+ * `smith/` for one that already integrates there — epicBranchPrefix decides
+ * which), or null when the epic has no integration branch (never planned,
+ * never dispatched, wrong --epic). Read here rather than inside epic.ts so
+ * the verdict stays git-free and purely a fold over events — the CLI passes
+ * the sha in.
  */
 export function integrationHeadSha(projectDir, epicId) {
-    return branchHead(projectDir, integrationBranchName(epicId));
+    return branchHead(projectDir, integrationBranchName(epicId, epicBranchPrefix(projectDir, epicId)));
 }
 /** Last-wins fold: the most recent recorded check for this epic, or null. */
 export function latestIntegrationCheck(events, epicId) {
@@ -86,7 +88,7 @@ export async function runIntegrationCheck(input, ctx, opts = {}) {
         causal_parent: ctx.causalParent,
     }, opts);
     const { epicId, projectDir } = input;
-    const branch = integrationBranchName(epicId);
+    const branch = integrationBranchName(epicId, epicBranchPrefix(projectDir, epicId));
     // testgate.run([]) returns pass: true for an empty list — correct there
     // (a task claiming no checks has nothing to short-circuit), and a silent
     // forgery here. "No checks configured" must never read back as "the

package/factory/orchestrator/dist/judgePreflight.js

@@ -28,7 +28,8 @@
 // locally: is the key set, is the binary on PATH, and does the arithmetic of
 // the promotions add up.
 import { readFileSync } from 'node:fs';
-import { parseCrosscheckPolicy } from './crosscheck.js';
+import { loadProjectProviderOverlay, parseCrosscheckPolicy, } from './crosscheck.js';
+import { readEnv } from './env.js';
 import { CROSSCHECK_POLICY_PATH } from './paths.js';
 import { apiKeyPresent, commandOnPath } from './preconditions.js';
 function inspect(config) {
@@ -49,6 +50,7 @@ function inspect(config) {
         kind: config.kind,
         enabled: config.enabled,
         mode: config.mode,
+        configSource: config.configSource,
     };
     if (config.transport === 'api') {
         const set = apiKeyPresent(config.apiKeyEnv);
@@ -63,6 +65,22 @@ function inspect(config) {
                     : `Disabled in the policy, so ${config.apiKeyEnv} is not read.`,
             };
         }
+        // Substitution keeps the provider's own name, mode and gating power
+        // (operator decision 1a) -- only the transport target and model changed
+        // underneath it, so this reads as the same provider succeeding, not a
+        // new one appearing.
+        if (config.via === 'openrouter') {
+            return {
+                ...base,
+                transport: 'api',
+                precondition: config.apiKeyEnv,
+                status: set ? 'ok' : 'unmet',
+                via: 'openrouter',
+                detail: set
+                    ? `Running via openrouter as ${config.model}: its own precondition is unmet on this box, and ${config.apiKeyEnv} is set.`
+                    : `Running via openrouter as ${config.model}, but ${config.apiKeyEnv} is unset or empty. Every quorum trigger will spend a call that cannot be sent, and record it as provider.missing-api-key.`,
+            };
+        }
         return {
             ...base,
             transport: 'api',
@@ -91,7 +109,7 @@ function inspect(config) {
         precondition: config.command,
         status: resolvable ? 'ok' : 'unmet',
         detail: resolvable
-            ? `${config.command} is executable on PATH. Whether it is authenticated is not knowable without spending a call — run "smith judge run --provider ${config.name}" to find out.`
+            ? `${config.command} is executable on PATH. Whether it is authenticated is not knowable without spending a call — run "bs judge run --provider ${config.name}" to find out.`
             : `${config.command} is not executable on PATH. Every quorum trigger will spend a call that cannot start.`,
     };
 }
@@ -99,11 +117,14 @@ function inspect(config) {
  * Read the policy as written and report what it would cost and buy. Pure
  * except for `process.env` and PATH lookups; appends nothing and calls nobody.
  */
-export function judgePreflight(policyPath = CROSSCHECK_POLICY_PATH) {
+export function judgePreflight(policyPath = CROSSCHECK_POLICY_PATH, options = {}) {
     // parseCrosscheckPolicy with `offline: false` rather than
     // loadCrosscheckPolicy: see `offlineSwitch` above.
     const policy = parseCrosscheckPolicy(readFileSync(policyPath, 'utf8'), {
         offline: false,
+        providerOverlay: options.projectDir
+            ? loadProjectProviderOverlay(options.projectDir)
+            : undefined,
     });
     const providers = Object.values(policy.providers)
         .map(inspect)
@@ -146,7 +167,7 @@ export function judgePreflight(policyPath = CROSSCHECK_POLICY_PATH) {
             : `${activeExternal.length} active external provider(s) against min_providers ${minProviders}: nothing can be decided.`;
     return {
         policyPath,
-        offlineSwitch: Boolean(process.env.SMITH_CROSSCHECK_OFFLINE),
+        offlineSwitch: Boolean(readEnv(process.env, 'SMITH_CROSSCHECK_OFFLINE')),
         providers,
         gating: { activeExternal, shadowExternal, minProviders, canDecide, detail },
         problems,

package/factory/orchestrator/dist/judgeRoles.js

@@ -0,0 +1,47 @@
+/**
+ * The epic criterion's six judge roles (task 5 and task 6 objectives both
+ * name this exact set: spec-reviewer, reviewer, verifier, grader,
+ * security-reviewer, auditor) -- the roles whose dispatch declares an
+ * artifact and whose SubagentStop is guarded by judge-stop.sh.
+ *
+ * A leaf module with no local imports of its own, so both `dispatchLint.ts`
+ * (which needs `readJudgeTurns` from `judges.ts`) and `judges.ts` (which
+ * needs this set for `foldJudgeTurns` and `recordJudgeDispatch`) can import
+ * it without forming a cycle between the two. `dispatchLint.ts` re-exports
+ * this set for its existing callers (judgeStopHook.ts, pluginManifest tests)
+ * — one array, never copied.
+ *
+ * Not the same six as dispatch.md's "Fingerprint the worktree around every
+ * judge" list, which swaps `auditor` for `uiux`: that section is about
+ * which judges run inside a task's worktree (auditor runs over a whole
+ * project at HEAD, never per-task, so a worktree fingerprint does not apply
+ * to it; uiux does run per-task). This list is about which roles owe a
+ * declared artifact and a blocked Stop, and `auditor` is one of them.
+ */
+export const JUDGE_ROLES = [
+    'reviewer',
+    'verifier',
+    'grader',
+    'spec-reviewer',
+    'security-reviewer',
+    'auditor',
+];
+/**
+ * `JUDGE_ROLES` plus `uiux`: every role a `smith judge dispatch` / `smith
+ * judge report` pair can open and close a turn for. wave.md's steps 5-7
+ * bracket the uiux visual pass with those same two verbs, same as grader,
+ * reviewer, verifier and security-reviewer (wave.md:242-253) — so
+ * `foldJudgeTurns` and `recordJudgeDispatch` (judges.ts) need uiux in scope
+ * too, or a real uiux dispatch throws `judges.non-judge-role` and its turn
+ * never folds.
+ *
+ * Deliberately NOT folded into `JUDGE_ROLES` itself: that set's meaning
+ * ("owes a declared-artifact line and a blocked Stop") stays exactly the six
+ * roles it always was for `dispatchLint.ts`'s `checkArtifact()` and
+ * `judgeStopHook.ts`'s SubagentStop guard — uiux's artifact is always the
+ * OBJECT `{run_status, structured_output, artifacts}` (bs-uiux.md), never the
+ * array shape those two callers check for, so widening `JUDGE_ROLES` itself
+ * would start demanding a declared-artifact line and a blocked Stop uiux was
+ * never designed to carry.
+ */
+export const JUDGE_TURN_ROLES = [...JUDGE_ROLES, 'uiux'];

package/factory/orchestrator/dist/judgeStopHook.js

@@ -2,7 +2,7 @@
 /**
  * `.claude/hooks/judge-stop.sh` — the SubagentStop decision for a judge-class
  * agent (reviewer, verifier, grader, spec-reviewer, security-reviewer,
- * auditor; `JUDGE_ROLES` in dispatchLint.ts is the authoritative set).
+ * auditor; `JUDGE_ROLES` in judgeRoles.ts is the authoritative set).
  *
  * A judge can end its turn without ever writing the artifact its dispatch
  * declared, and today that gap is found only downstream, when `smith judge
@@ -11,10 +11,11 @@
  * while the declared path does not exist, allow it once it does. A harness
  * `maxTurns` cap is out of scope; this hook cannot override it.
  *
- * The declared-artifact line and its parser come from `dispatchLint.ts`,
- * never redefined — `dispatch lint` already refuses, before dispatch, any
- * judge prompt whose line is missing, relative, or mismatched, so this hook
- * only asks "does the file exist yet", never "is the line well-formed".
+ * The declared-artifact line and its parser come from
+ * `declaredArtifactLine.ts`, never redefined — in this clone the PreToolUse
+ * guard refuses, before dispatch, any judge dispatch whose prompt lacks an
+ * absolute line (and `dispatch lint` checks it against the ledger), so this
+ * hook only asks "does the file exist yet", never "is the line well-formed".
  *
  * Fail open on anything this hook cannot read: a non-judge `agent_type`, a
  * prompt with no declared-artifact line, a relative path, unparseable stdin,
@@ -25,12 +26,26 @@
  *
  * Fail closed ONLY on a readable absolute declared path that does not exist.
  *
+ * The hook reads the subagent's first non-meta user text -- its dispatch
+ * prompt -- from `agent_transcript_path`. Per
+ * https://code.claude.com/docs/en/hooks#subagentstop: "The `transcript_path`
+ * is the main session's transcript, while `agent_transcript_path` is the
+ * subagent's own transcript stored in a nested `subagents/` folder." Later
+ * user-role entries (meta reminders, resumes, compaction notices) are never
+ * the prompt. An older CLI that sends no `agent_transcript_path` falls back
+ * to `transcript_path`: the main session's first prompt, which carries no
+ * Declared line unless that session was itself dispatched as a judge, so the
+ * hook fails open there.
+ *
  * SubagentStop stdin fields: https://code.claude.com/docs/en/hooks
  */
-import { existsSync, readFileSync } from 'node:fs';
+import { closeSync, existsSync, openSync, readFileSync, readSync } from 'node:fs';
 import path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
 import { pathToFileURL } from 'node:url';
-import { JUDGE_ROLES, parseDeclaredArtifactLine } from './dispatchLint.js';
+import { roleOfAgentType } from './agentNames.js';
+import { parseDeclaredArtifactLine } from './declaredArtifactLine.js';
+import { JUDGE_ROLES } from './judgeRoles.js';
 const JUDGE_ROLE_SET = new Set(JUDGE_ROLES);
 /**
  * The pure decision: given the hook's stdin and the subagent's prompt text
@@ -39,8 +54,10 @@ const JUDGE_ROLE_SET = new Set(JUDGE_ROLES);
  * exists -- the one question this hook exists to ask.
  */
 export function decideJudgeStop(input, promptText) {
-    const agentType = input.agent_type;
-    if (agentType === undefined || !JUDGE_ROLE_SET.has(agentType)) {
+    // `bs-reviewer`, `blacksmith:bs-reviewer` and (transition) the bare old names
+    // all map to the role; a name that maps to nothing is not a judge.
+    const role = input.agent_type === undefined ? null : roleOfAgentType(input.agent_type);
+    if (role === null || !JUDGE_ROLE_SET.has(role)) {
         // Not one of the six judge roles -- a coder's turn carries no declared
         // artifact at all, so there is nothing for this hook to check.
         return { decision: 'allow' };
@@ -58,7 +75,7 @@ export function decideJudgeStop(input, promptText) {
         return {
             decision: 'allow',
             note: 'judge-stop: no "Declared artifact: <path>" line in this prompt; allowing ' +
-                "the stop. dispatch lint refuses this before dispatch, and judge report's " +
+                "the stop. The PreToolUse guard refuses this before dispatch in this clone, and judge report's " +
                 'judges.artifact-missing catches it downstream.',
         };
     }
@@ -66,7 +83,7 @@ export function decideJudgeStop(input, promptText) {
         return {
             decision: 'allow',
             note: `judge-stop: declared artifact "${declared}" is not an absolute path; ` +
-                'allowing the stop. dispatch lint refuses this before dispatch, and judge ' +
+                'allowing the stop. The PreToolUse guard refuses this before dispatch in this clone, and judge ' +
                 "report's judges.artifact-missing catches it downstream.",
         };
     }
@@ -82,37 +99,73 @@ export function decideJudgeStop(input, promptText) {
     return { decision: 'allow' };
 }
 /**
- * The last user-role message's text in a Claude Code JSONL transcript --
- * where a dispatch prompt and its "Declared artifact:" line live. Walks
- * backward from the end, since a subagent's transcript can carry many turns
- * and the dispatch prompt need not be the only user turn. Returns `null` on
- * any read or parse failure.
+ * The text of the first non-meta user-role entry in a Claude Code JSONL
+ * transcript -- in a subagent's own transcript that is its dispatch prompt,
+ * where the "Declared artifact:" line lives; meta reminders, resumes, tool
+ * results and compaction notices all come after it or are skipped. Streams
+ * the file in fixed-size chunks (a transcript can pass 512 MB, where a
+ * whole-file read throws), splitting on `\n` only, and stops reading as soon
+ * as the prompt is found; work is linear in the bytes read because only the
+ * newly read chunk is scanned for line breaks. A torn or unparseable line is
+ * skipped. Returns `null` on any read failure or when no such entry exists.
  */
-export function extractLastUserPromptText(transcriptPath) {
-    let raw;
+export function extractDispatchPromptText(transcriptPath, chunkSize = 64 * 1024) {
+    let fd;
     try {
-        raw = readFileSync(transcriptPath, 'utf8');
+        fd = openSync(transcriptPath, 'r');
     }
     catch {
         return null;
     }
-    const lines = raw.split('\n');
-    for (let i = lines.length - 1; i >= 0; i--) {
-        const line = lines[i];
-        if (line === undefined || line.trim() === '')
-            continue;
+    const consume = (line) => {
+        if (line.trim() === '')
+            return null;
         let entry;
         try {
             entry = JSON.parse(line);
         }
         catch {
-            continue;
+            return null;
+        }
+        if (entry?.isMeta === true)
+            return null;
+        return userTextOf(entry);
+    };
+    try {
+        const buf = Buffer.alloc(chunkSize);
+        const decoder = new StringDecoder('utf8');
+        let carry = [];
+        for (;;) {
+            const n = readSync(fd, buf, 0, chunkSize, null);
+            if (n === 0)
+                break;
+            const chunk = decoder.write(buf.subarray(0, n));
+            let start = 0;
+            for (let nl = chunk.indexOf('\n'); nl !== -1; nl = chunk.indexOf('\n', start)) {
+                carry.push(chunk.slice(start, nl));
+                const found = consume(carry.join(''));
+                if (found !== null)
+                    return found;
+                carry = [];
+                start = nl + 1;
+            }
+            if (start < chunk.length)
+                carry.push(chunk.slice(start));
+        }
+        carry.push(decoder.end());
+        return consume(carry.join(''));
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch {
+            // nothing to do about a failed close
         }
-        const text = userTextOf(entry);
-        if (text !== null)
-            return text;
     }
-    return null;
 }
 function userTextOf(entry) {
     if (typeof entry !== 'object' || entry === null)
@@ -154,9 +207,14 @@ export function runJudgeStopHook(rawStdin) {
                 "judge report's judges.artifact-missing remains the backstop.\n",
         };
     }
-    const promptText = input.transcript_path
-        ? extractLastUserPromptText(input.transcript_path)
-        : null;
+    // Older CLIs send no agent_transcript_path; the fallback then reads the
+    // main session's transcript, whose first prompt carries no declared line
+    // unless that session was itself dispatched as a judge, so the hook
+    // fails open there.
+    const promptPath = typeof input.agent_transcript_path === 'string' && input.agent_transcript_path !== ''
+        ? input.agent_transcript_path
+        : input.transcript_path;
+    const promptText = promptPath ? extractDispatchPromptText(promptPath) : null;
     const result = decideJudgeStop(input, promptText);
     if (result.decision === 'block') {
         return {