@afokapu/atdd-flow 0.3.26 → 0.3.28

package/README.md

@@ -130,6 +130,8 @@ atdd-flow task done example-app runtime-rollout --by coordinator@example-app
 
 Proof is a compact PR, CI run, report, commit range, deployment, or thread reference. Dependencies gate prerequisites; independent tasks are parallel-ready. A coordinator can staff an unassigned ready task with `atdd-flow task assign <project> <task-id> --assignee <address> --by <coordinator-address>`; assignment is allowed only once while the task is `todo`. Use `task block` only for a real external blocker, then checkpoint exact state and next action. Once the blocker is resolved, only that coordinator can clear it with `atdd-flow task unblock <project> <task-id> --by <coordinator-address>` while the task remains `in_progress`. For deliveries explicitly governed by the `workflow` ATDD Bun profile, `review → done` additionally requires a durable final behavioral-review result with decision `APPROVE` for the current clean delivery commit. For an idle driver’s final task, `task done ... --retire-assignee` delegates clean-and-merged worktree retirement to ATDD Bun.
 
+At 80% context usage a seat writes a structured handover (template and process rules in the lifecycle convention), checks it with `atdd-flow handover <address> --check --file <path>`, and records it with `atdd-flow handover <address> --file <path>`. The seat keeps one durable `handover.yaml` beside its unchanged checkpoint. Recording rejects a missing header, Runtime line, or section, sections out of order, more than 150 lines, vague references such as `latest` or `that PR` without an exact ID, and a `supersedes` value that does not match the recorded handover id. A fresh session bound to the same seat reads it with `atdd-flow handover show <address>`.
+
 For topology normalization, transfer an active task through the narrow durable command, never by editing its YAML: `atdd-flow task transfer <project> <task-id> --to <main-or-named-coordinator> --reason <text> --by <current-coordinator>`; `main@project` must additionally pass `--authorization <operator-message-id>`. That message must be an immutable `task-transfer-authorization/v1` exact tuple for the project, task, current/target coordinator, reason, and target branch/head; only `operator@desk` creates it through `atdd-flow post --task-transfer-authorization <json>`. The command appends immutable source/target/reason/exact-head/effective-time provenance, keeps earlier phase/review/message evidence intact, derives the new governed base from the accepted target head, and never moves a seat, branch, runtime, or worktree. Same-target, duplicate, nested, mismatched, unauthorized, and manually rewritten transitions fail closed.
 
 ## Communicate and hand over

package/conventions/atdd-workflow.workflow/atdd-workflow.workflow.lifecycle.convention.yaml

@@ -62,6 +62,64 @@ content:
     Start from the current seat, checkpoint, assigned tasks, and relevant thread records. A replacement
     agent resumes from those records; it does not depend on a conversation with its predecessor.
 
+    Context handover: every seat (main, coordinator, driver, operator) stops at 80% context usage.
+    It finishes or cleanly undoes the current atomic step (commit, post, receipt) and starts nothing
+    new. It writes a handover using the template below, validates it with
+    `atdd-flow handover <address> --check --file <path>`, fixes every reported problem, and records
+    it with `atdd-flow handover <address> --file <path>`. The seat's handover.yaml is the one durable
+    handover record; it sits beside the checkpoint and never replaces it. The old session then makes
+    no further tool calls, and a fresh session bound to the same seat continues. The new session reads
+    the instruction file, then `atdd-flow handover show <address>`, runs the handover's verification,
+    reconciles it with the live Desk (the Desk wins), reconciles its inbox, reports
+    `RESUMED; verified N/M; discrepancies: ...` through its normal reporting route, and continues.
+    A handover points to toolkit conventions and never restates or overrides them; read a convention
+    when its phase is acted on, not all on resume. 150 lines is a ceiling, not a target. List open
+    items only, use exact IDs, and mark state [verified|assumed]. Recording rejects a missing or
+    malformed header or Runtime line, a missing, duplicate, or out-of-order section, more than
+    150 lines, a supersedes value other than the recorded handover id (or none when none is recorded),
+    and vague references: the words latest, newest, and most recent, and that/this/those/these/same/
+    previous/earlier/above/last/aforementioned followed by PR, pull request, task, thread, message,
+    commit, branch, handover, session, issue, or release without an exact identifier (one containing
+    a digit, @, or /). Template:
+
+      HANDOVER <seat-address> | <UTC ts> | handover-id <id> | supersedes <id|none>
+      Runtime: <application> <session>:<pane> | <agent> session <id> | model <provider/model> | context <NN>%
+
+      1. SEAT, AUTHORITY, TOOLKIT AND HAZARDS
+      - Seat: <address> (<role>), project <project>; reports to <addr>; directs <addrs|none>
+      - Worktree: <path> @ <branch> <sha> (<clean | dirty: files>)
+      - Toolkit in force (this worktree): Flow <ver> / Bun <ver> | declared=locked=installed: <yes | NOT CURRENT: detail> | runtime binding: <Flow ver | unverified>
+      - Governing conventions for current phase: <convention ids> (pointers only)
+      - Profile/ratchet state: <profile> <reject-new|strict> | activated ratchets (never modify): <list|none>
+      - Authorizations in force: <scope> | granted by <addr> | ref <msg-id> | expires <ts|never>
+      - Seat-specific constraints (beyond the instruction file): <list|none>
+      - Hazards / known bugs / workarounds: <list|none>
+      - Dead ends (tried, failed, do not repeat): <what> | ref <id> (or none)
+
+      2. OPEN WORK AND IN-FLIGHT OPERATIONS
+      - <project>/<task-id> | <status/phase> | assignee <addr> | [verified|assumed]
+        ref: <PR#/sha/pane>; last evidence <msg-id>; state: <one line>
+      - IN-FLIGHT: <operation> | started <ts> | check: <exact command> | retry-safe: <yes|no|why>
+      - Session-only knowledge: <facts learned, not recorded in Desk> (or none)
+
+      3. DEPENDENCIES (both directions)
+      - WAITING ON: <what> | <addr> | since <ts> | ref <msg-id> | follow up at <ts>
+      - OWED BY ME: <what> | to <addr> | due <ts> | ref <msg-id>
+      - DECISION PENDING: <question> | owner <addr> | options A/B + recommendation | ref <id>
+      - RECEIVED, NOT YET ACTED ON: <msg-id> | from <addr> | needed action
+      (or: none, per subsection)
+
+      4. RESUME PROCEDURE AND NEXT ACTIONS
+      Verify first:
+      - atdd-flow status seat <address>
+      - atdd-flow task open <project> <task-id>   (each open task)
+      - git -C <worktree> status && git log -1
+      - installed toolkit versions in <worktree> match section 1 (mismatch = discrepancy; report, do not self-upgrade)
+      - <each IN-FLIGHT check command>
+      Then, in order:
+      1. Read inbox; receipt pending messages lacking my receipt.
+      2. <concrete action with exact IDs>
+
     `operator@desk` is the human authority, not an autonomous agent identity. Never post, approve,
     or make a decision while claiming that address unless the human operator actually supplied it.
     Main seats are the normal repository-main integration gateway to the operator. Coordinators may

package/extensions/pi/index.ts

@@ -5,6 +5,7 @@ import { parse, stringify } from "yaml";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { clearStaleRuntimeState, clearRuntimeState, heartbeatRuntimeState, ownsRuntimeState, registerRuntimeState, runtimeOwnerToken, withOwnedRuntimeState } from "../../src/runtime-state";
 import { paths, readYaml, type Seat } from "../../src/core";
+import { directiveNotice, nextDirective } from "../../src/tasks";
 
 type Thread = { id?: unknown; participants?: unknown; subject?: unknown };
 export type Mail = { id?: unknown; from?: unknown; to?: unknown; subject?: unknown; created_at?: unknown };
@@ -316,6 +317,18 @@ export async function awaitLaunchActivation({ root, seat, piSession, herdrSessio
   throw new Error("Timed out waiting for verified Flow launch receipt and binding.");
 }
 
+/** Injects the current task-derived action; failure to derive never blocks mail or startup. */
+async function sendTaskDirective(pi: ExtensionAPI, root: string, seat: string) {
+  try {
+    const directive = await nextDirective(root, seat);
+    if (!directive) return;
+    pi.sendMessage({
+      customType: "atdd-flow-next-action", content: directiveNotice(seat, directive), display: true,
+      details: { project: directive.project, task: directive.task, lifecycle: directive.lifecycle, role: directive.role, authority: "task" },
+    }, { triggerTurn: true, deliverAs: "followUp" });
+  } catch { /* The durable task remains authoritative and is re-derived at the next startup or wake. */ }
+}
+
 /** Desk mail is authoritative; the queue is a bounded delivery index and fs.watch only shortens latency. */
 export default function (pi: ExtensionAPI) {
   const root = process.env.ATDD_WORKFLOW_ROOT;
@@ -325,7 +338,9 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_start", async (_event, ctx) => {
     runtime = createPiRuntime({ root, seat, deferActivation: true, deliver: async (mail, thread, path, sendIfOwned) => {
       if (!sendIfOwned) return false;
-      return sendIfOwned(() => {
+      return sendIfOwned(async () => {
+        // Task state is re-read at every wake, so queued mail cannot carry a stale action.
+        await sendTaskDirective(pi, root, seat);
         pi.sendMessage({
           customType: "atdd-flow-mail",
           content: mailNotice(typeof thread.id === "string" ? thread.id : "unknown", { ...mail, subject: typeof thread.subject === "string" ? thread.subject : undefined }),
@@ -344,6 +359,7 @@ export default function (pi: ExtensionAPI) {
       activate: async () => {
         if (!await current.activate()) return;
         pi.sendMessage({ customType: "atdd-flow-start", content: `SYSTEM: you are ${seat}. Read your durable seat and assigned work with: atdd-flow open ${seat}. Convention: ${lifecycleConventionPath}. Continue assigned in_progress work until it is review-ready or explicitly blocked.`, display: true, details: { seat, root } }, { triggerTurn: true, deliverAs: "followUp" });
+        await sendTaskDirective(pi, root, seat);
         if (ctx.hasUI) ctx.ui.notify(`ATDD Flow native mail active for ${seat}`, "info");
       },
     }).catch(() => undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afokapu/atdd-flow",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "description": "Filesystem-first Desk registry for projects, seats, tasks, threads, and handoffs.",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -13,6 +13,7 @@ import { status } from "./overview";
 import { multiplexer } from "./multiplexer";
 import * as cleanup from "./ephemeral-resources";
 import * as ownerAlerts from "./owner-escalations";
+import { recordHandover, showHandover } from "./handover";
 
 const usage = `atdd-flow — filesystem-first agent seats and tasks
 
@@ -34,6 +35,8 @@ Usage:
   atdd-flow multiplexer status|apply herdr [--session <name>]
   atdd-flow describe <address> --purpose <one-line responsibility>
   atdd-flow checkpoint <address> --summary <text> --next <text> [--status active|standby|blocked|complete|unverified]
+  atdd-flow handover <address> --file <path> [--check]
+  atdd-flow handover show <address>
   atdd-flow task add <project> <task-id> --title <text> --coordinator <address> [--assignee <address>] [--body <text>] [--source <reference>] [--depends-on <task-id,...>] --done-when <text> [--done-when <text> ...]
   atdd-flow task assign <project> <task-id> --assignee <address> --by <coordinator-address>
   atdd-flow task transfer <project> <task-id> --to <main-or-named-coordinator> --reason <text> --by <actor> [--authorization <operator-message-id>]
@@ -112,6 +115,7 @@ async function main() {
     multiplexer: () => multiplexer(root, rest),
     describe: () => describe(root, required(rest[0], "address"), rest.slice(1)),
     checkpoint: () => checkpoint(root, required(rest[0], "address"), rest.slice(1)),
+    handover: () => rest[0] === "show" ? showHandover(root, required(rest[1], "address")) : recordHandover(root, required(rest[0], "address"), rest.slice(1)),
     task: async () => {
       const [subcommand, projectName, taskId, ...tail] = rest;
       if (subcommand === "add") return tasks.add(root, required(projectName, "project"), required(taskId, "task id"), tail);

package/src/core.ts

@@ -159,6 +159,7 @@ export const paths = (root: string) => ({
   },
   seatFile: (address: string) => join(paths(root).seat(address), "seat.yaml"),
   checkpointFile: (address: string) => join(paths(root).seat(address), "checkpoint.yaml"),
+  handoverFile: (address: string) => join(paths(root).seat(address), "handover.yaml"),
   tasks: (project: string) => join(root, "work", project, "tasks"),
   taskFile: (project: string, task: string) => join(root, "work", project, "tasks", `${taskId(task)}.yaml`),
   behavioralReviewFile: (project: string, task: string) => join(root, "work", project, "tasks", `${taskId(task)}.reviews.yaml`),

package/src/handover.ts

@@ -0,0 +1,90 @@
+import { readFile } from "node:fs/promises";
+import { atomicYaml, canonicalAddress, exists, has, now, paths, readYaml, required, seat, words } from "./core";
+
+export type Handover = {
+  schema: "atdd-workflow/handover/v1";
+  seat: string;
+  handover_id: string;
+  supersedes: string;
+  recorded_at: string;
+  text: string;
+};
+
+export const maxHandoverLines = 150;
+export const handoverSections = [
+  "SEAT, AUTHORITY, TOOLKIT AND HAZARDS",
+  "OPEN WORK AND IN-FLIGHT OPERATIONS",
+  "DEPENDENCIES",
+  "RESUME PROCEDURE AND NEXT ACTIONS",
+] as const;
+
+const header = /^HANDOVER (\S+) \| (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?Z) \| handover-id ([^\s|]+) \| supersedes ([^\s|]+)$/;
+const headerForm = "`HANDOVER <seat-address> | <UTC ts> | handover-id <id> | supersedes <id|none>`";
+/** Words that name a moving target instead of an exact record. */
+const vagueWords = /\b(latest|newest|most recent)\b/gi;
+/** A demonstrative reference to a record kind, vague unless an exact identifier (one containing a digit, `@`, or `/`) follows. */
+const vagueDemonstrative = /\b(?:that|this|those|these|same|previous|earlier|above|last|aforementioned)\s+(PRs?|pull requests?|tasks?|threads?|messages?|commits?|branch(?:es)?|handovers?|sessions?|issues?|releases?)\b(?!\s+\S*[\d@/])/gi;
+
+/** Every reason a handover text is not acceptable for `seat`, given the currently recorded handover id. */
+export function handoverProblems(text: string, seatAddress: string, recorded?: string) {
+  const problems: string[] = [];
+  const lines = text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
+  if (lines.length > maxHandoverLines) problems.push(`handover has ${lines.length} lines; the maximum is ${maxHandoverLines}.`);
+  const match = header.exec(lines[0] ?? "");
+  if (!match) problems.push(`line 1: missing or malformed header; expected ${headerForm}.`);
+  else {
+    const [, writer, , id, supersedes] = match as unknown as [string, string, string, string, string];
+    if (writer !== seatAddress) problems.push(`line 1: header seat ${writer} does not match ${seatAddress}.`);
+    if (id === "none") problems.push("line 1: handover-id must be an exact identifier, not none.");
+    if (recorded === undefined && supersedes !== "none") problems.push(`line 1: supersedes ${supersedes}, but ${seatAddress} has no recorded handover; use supersedes none.`);
+    if (recorded !== undefined && supersedes !== recorded) problems.push(`line 1: supersedes ${supersedes} must name the recorded handover ${recorded}.`);
+    if (recorded !== undefined && id === recorded) problems.push(`line 1: handover-id ${id} is already recorded; use a new id.`);
+  }
+  if (!/^Runtime:\s*\S/.test(lines[1] ?? "")) problems.push("line 2: missing Runtime line; expected `Runtime: <runtime> | <session> | model <provider/model> | context <NN>%`.");
+  const found: number[] = [];
+  handoverSections.forEach((title, index) => {
+    const heading = `${index + 1}. ${title}`;
+    const at = lines.flatMap((line, position) => line.trim().startsWith(heading) ? [position] : []);
+    if (!at.length) problems.push(`missing section ${index + 1} (\`${heading}\`).`);
+    else if (at.length > 1) problems.push(`line ${at[1]! + 1}: duplicate section ${index + 1}.`);
+    found[index + 1] = at[0] ?? -1;
+  });
+  for (let section = 2; section <= handoverSections.length; section++) {
+    const earlier = found[section - 1]!, later = found[section]!;
+    if (earlier >= 0 && later >= 0 && later < earlier) problems.push(`line ${later + 1}: section ${section} appears before section ${section - 1}; sections are out of order (expected 1, 2, 3, 4).`);
+  }
+  lines.forEach((line, index) => {
+    for (const vague of [...line.matchAll(vagueWords), ...line.matchAll(vagueDemonstrative)]) {
+      problems.push(`line ${index + 1}: vague reference "${vague[0]}"; name the exact ID (task, message, PR number, commit sha, or address).`);
+    }
+  });
+  return problems;
+}
+
+async function recorded(root: string, address: string) {
+  const file = paths(root).handoverFile(address);
+  return await exists(file) ? await readYaml<Handover>(file) : undefined;
+}
+
+/** Validate a handover file and, unless `--check`, record it as the seat's durable handover. Checkpoints are never touched. */
+export async function recordHandover(root: string, address: string, args: string[]) {
+  const resolved = await canonicalAddress(root, address);
+  await seat(root, resolved);
+  const text = await readFile(required(words(args, "--file"), "--file"), "utf8");
+  const prior = await recorded(root, resolved);
+  const problems = handoverProblems(text, resolved, prior?.handover_id);
+  if (problems.length) throw new Error(`Handover rejected for ${resolved}; nothing was recorded:\n${problems.map((problem) => `- ${problem}`).join("\n")}`);
+  const [, , , id, supersedes] = header.exec(text.split(/\r?\n/, 1)[0]!)! as unknown as [string, string, string, string, string];
+  if (has(args, "--check")) return console.log(`Handover valid: ${id} for ${resolved} (checked only; not recorded).`);
+  const record: Handover = { schema: "atdd-workflow/handover/v1", seat: resolved, handover_id: id, supersedes, recorded_at: now(), text };
+  await atomicYaml(paths(root).handoverFile(resolved), record);
+  console.log(`Recorded handover ${id} for ${resolved}.`);
+}
+
+export async function showHandover(root: string, address: string) {
+  const resolved = await canonicalAddress(root, address);
+  await seat(root, resolved);
+  const record = await recorded(root, resolved);
+  if (!record) throw new Error(`No handover is recorded for ${resolved}.`);
+  process.stdout.write(record.text.endsWith("\n") ? record.text : `${record.text}\n`);
+}

package/src/tasks.ts

@@ -1,7 +1,7 @@
 import { readdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import {
-  type Checkpoint, atomicYaml, canonicalAddress, now, paths, project, readYaml, required, runOutput, seat, taskId, values, words,
+  type Checkpoint, type Seat, atomicYaml, canonicalAddress, now, paths, project, readYaml, required, runOutput, seat, taskId, values, words,
 } from "./core";
 
 export type TaskStatus = "todo" | "in_progress" | "review" | "done";
@@ -498,3 +498,83 @@ export async function list(root: string, projectName: string, args: string[]) {
 export async function open(root: string, projectName: string, id: string) {
   console.log(Bun.YAML.stringify(await readTask(root, projectName, taskId(id))));
 }
+
+export type TaskDirective = {
+  project: string;
+  task: string;
+  lifecycle: "TODO" | "PLAN" | "RED" | "GREEN" | "REFACTOR" | "REVIEW" | "DONE" | "BLOCKED";
+  role: "assignee" | "coordinator";
+  action: string;
+  command?: string;
+};
+
+const phaseActions: Record<TaskPhase, string> = {
+  plan: "Prepare and submit PLAN handoff",
+  red: "Commit focused test-only RED handoff",
+  green: "Implement the accepted GREEN scope",
+  refactor: "Refactor only after GREEN acceptance, then submit the REFACTOR handoff",
+};
+
+/** Pure projection of an existing task record; it creates no durable state. */
+async function directiveFor(root: string, projectName: string, id: string, task: Task, address: string): Promise<TaskDirective | undefined> {
+  const base = { project: projectName, task: id };
+  if (task.assignee === address) {
+    const as = { ...base, role: "assignee" as const };
+    if (task.status === "done") return { ...as, lifecycle: "DONE", action: "Perform DONE housekeeping only; start no new implementation." };
+    if (task.blocker) return { ...as, lifecycle: "BLOCKED", action: `Remain blocked and await coordinator resolution (${task.blocker}). Continue only independent required work.` };
+    if (task.status === "review") return { ...as, lifecycle: "REVIEW", action: "Await coordinator review; do not continue implementation." };
+    if (task.status === "todo") {
+      const waiting = await ready(root, projectName, task);
+      return waiting.length
+        ? { ...as, lifecycle: "TODO", action: `Wait; dependencies are unfinished: ${waiting.join(", ")}.` }
+        : { ...as, lifecycle: "TODO", action: "Start assigned ready task.", command: `atdd-flow task start ${projectName} ${id} --by ${address}` };
+    }
+    const current = task.phase ?? "plan";
+    const lifecycle = current.toUpperCase() as TaskDirective["lifecycle"];
+    if (task.handoff?.state === "awaiting_coordinator") return { ...as, lifecycle, action: `Await coordinator response to the ${lifecycle} handoff; do not continue to the next phase.` };
+    return {
+      ...as, lifecycle, action: `${phaseActions[current]}.`,
+      command: `atdd-flow task handoff ${projectName} ${id} --by ${address} --phase ${current} --evidence <message-or-reference>`,
+    };
+  }
+  if (task.coordinator === address && task.status !== "done") {
+    const as = { ...base, role: "coordinator" as const };
+    if (task.blocker) return { ...as, lifecycle: "BLOCKED", action: `Resolve the blocker (${task.blocker}) and then unblock the task.`, command: `atdd-flow task unblock ${projectName} ${id} --by ${address}` };
+    if (task.status === "review") return { ...as, lifecycle: "REVIEW", action: "Review the submitted task; complete it or return it to work.", command: `atdd-flow task open ${projectName} ${id}` };
+    if (task.status === "in_progress" && task.handoff?.state === "awaiting_coordinator") {
+      const current = task.phase ?? "plan";
+      return { ...as, lifecycle: current.toUpperCase() as TaskDirective["lifecycle"], action: `Accept or return the ${current.toUpperCase()} handoff.`, command: `atdd-flow task respond ${projectName} ${id} --by ${address} --outcome <accept|return> --phase <plan|red|green|refactor>` };
+    }
+  }
+  return undefined;
+}
+
+const directiveRank = (directive: TaskDirective, task: Task) =>
+  directive.lifecycle === "DONE" ? 4 : directive.lifecycle === "BLOCKED" ? 3 : task.status === "todo" ? 2 : task.status === "review" ? 1 : 0;
+
+/**
+ * Derives the one next required action for an address from authoritative task
+ * records. Mail is intentionally not an input, and nothing is persisted.
+ */
+export async function nextDirective(root: string, address: string): Promise<TaskDirective | undefined> {
+  const owner = await readYaml<Seat>(paths(root).seatFile(address));
+  if (owner.retired) return undefined;
+  const entries = await seatTasks(root, owner.project, address);
+  const candidates: { directive: TaskDirective; task: Task }[] = [];
+  for (const entry of entries) {
+    const directive = await directiveFor(root, owner.project, entry.id, entry.task, address);
+    if (directive) candidates.push({ directive, task: entry.task });
+  }
+  const best = (role: "assignee" | "coordinator") => {
+    const pool = candidates.filter((entry) => entry.directive.role === role)
+      .sort((left, right) => directiveRank(left.directive, left.task) - directiveRank(right.directive, right.task));
+    // Completed housekeeping names the most recent completed task, not the oldest.
+    return pool[0] && directiveRank(pool[0].directive, pool[0].task) === 4 ? pool.at(-1) : pool[0];
+  };
+  return (best("assignee") ?? best("coordinator"))?.directive;
+}
+
+/** Compact wake text; task state is named as the authority over any mail. */
+export function directiveNotice(address: string, directive: TaskDirective) {
+  return `SYSTEM: authoritative next action for ${address} on ${directive.project}/${directive.task} [${directive.lifecycle}] from task state: ${directive.action}${directive.command ? ` Command: ${directive.command}.` : ""} Task state outranks mail; mail is notification only.`;
+}