@nodeint/migent 0.1.4 → 0.1.6

package/dist/session-row.d.ts

@@ -0,0 +1,20 @@
+export declare const SESSION_COLUMN: {
+    readonly updatedAt: 0;
+    readonly session: 1;
+    readonly workflow: 2;
+    readonly status: 3;
+    readonly execution: 4;
+    readonly decision: 5;
+    readonly outputs: 6;
+    readonly task: 7;
+};
+export interface SessionFields {
+    session: string;
+    workflow: string;
+    status: string;
+    execution: string;
+    decision: string;
+    outputs: string;
+    task: string;
+}
+export declare function sessionFields(row: readonly string[]): SessionFields;

package/dist/session-row.js

@@ -0,0 +1,21 @@
+export const SESSION_COLUMN = {
+    updatedAt: 0,
+    session: 1,
+    workflow: 2,
+    status: 3,
+    execution: 4,
+    decision: 5,
+    outputs: 6,
+    task: 7,
+};
+export function sessionFields(row) {
+    return {
+        session: row[SESSION_COLUMN.session] ?? "",
+        workflow: row[SESSION_COLUMN.workflow] ?? "",
+        status: row[SESSION_COLUMN.status] ?? "",
+        execution: row[SESSION_COLUMN.execution] ?? "",
+        decision: row[SESSION_COLUMN.decision] ?? "",
+        outputs: row[SESSION_COLUMN.outputs] ?? "",
+        task: row[SESSION_COLUMN.task] ?? "",
+    };
+}

package/dist/signals.d.ts

@@ -0,0 +1,3 @@
+export declare function bindCancellationSignals(): () => void;
+export declare function throwIfCliCancelled(): void;
+export declare function delay(ms: number): Promise<void>;

package/dist/signals.js

@@ -0,0 +1,56 @@
+import { CancellationRequested, raiseCancellation, resetCancellation } from "@nodeint/migent-kernel";
+let pending = null;
+const waiters = new Set();
+function note(signalNumber) {
+    pending = new CancellationRequested(signalNumber);
+    for (const waiter of waiters)
+        waiter();
+    try {
+        raiseCancellation(signalNumber);
+    }
+    catch {
+        // The pending flag is what the follow loop and provider runner observe.
+    }
+}
+export function bindCancellationSignals() {
+    const onSigint = () => note(2);
+    const onSigterm = () => note(15);
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    return () => {
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+        pending = null;
+        resetCancellation();
+    };
+}
+export function throwIfCliCancelled() {
+    const error = pending;
+    if (error === null)
+        return;
+    pending = null;
+    throw error;
+}
+export function delay(ms) {
+    throwIfCliCancelled();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            waiters.delete(wake);
+            try {
+                throwIfCliCancelled();
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        const timer = setTimeout(finish, ms);
+        const wake = () => finish();
+        waiters.add(wake);
+    });
+}

package/dist/templates/migent/SKILL.md

@@ -1,62 +1,169 @@
 ---
 name: migent
-description: Set up Migent in a project, or configure, run, inspect, and resume its workflows. Use when the user asks about Migent configuration, workflows, sessions, stages, or published outputs.
+description: Set up Migent in a project, or configure, run, inspect, and resume its workflows with the migent CLI. Use when the user asks about Migent, .migent/ configuration, workflows, roles, models, sessions, stages, doctor, or published outputs.
 ---
 
 # Migent
 
-Use Migent as the control plane for the project's multi-stage agent workflows.
-
-## Working rules
-
-- For an existing project, work from the root containing
-  `.migent/config.yaml`. To set up a new project, run `migent init` from
-  its root and follow the CLI's provider and model prompts or flags.
-- Read `.migent/config.yaml` and the relevant file under
-  `.migent/workflows/` before changing or running a workflow.
-- Run `migent doctor` after editing configuration or workflows.
-  `migent config model` and `migent config role` run it after a write.
-- Treat `.migent/sessions/` as generated, resumable state. Do not edit its
-  files directly.
-- Preserve the user's task wording when passing `--task`.
-- Before continuing a stopped session, inspect the command's `stop_reason` and
-  latest execution. Fix the cause before retrying.
-
-## Choose the command
-
-- Start a workflow: `migent start <workflow> --task "<task>"`. `<workflow>`
-  is the workflow id, or a path to a workflow file. An omitted `id` uses the
-  file name. If its
-  `requires` block names a prerequisite workflow and decision, find a matching
-  completed session and add `--prior <session-id>`.
-- Resume an active session: `migent continue <session-id>`.
-- Advance exactly one eligible stage: `migent stage <session-id>`.
-- List recorded sessions: `migent sessions` or `migent sessions --json`.
-- Inspect a snapshot: `migent watch <session-id> --once --json`.
-- Follow new events: `migent watch <session-id>`.
-- Run a configured role outside a workflow only when the user asks for ad hoc
-  role execution: `migent agent start --role <role> --prompt "<prompt>"`.
-- Read `.migent/config.yaml`: `migent config show`.
-- Change a model entry: `migent config model <name> --provider <provider> --model <model-id>`.
-  This updates every role and stage that uses the name.
-- Point one role at a model without changing a shared entry:
-  `migent config role <role> --provider <provider> --model <model-id>`.
-  `migent config role <role> --model-name <name>` points it at a name that
-  already exists. Add `--json` to read the result.
-
-Workflow commands emit progress on stderr and one result object on stdout.
-Report the session ID, session status, stop reason, decisions, and published
-outputs that matter to the user. A stopped active session is resumable; do not
-describe it as completed.
-
-`retry_exhausted` means the stage has used its total failed-attempt allowance;
-`--attempts` on `continue` sets a new total, not extra retries.
-`revisions_exhausted` leaves the session active. `continue` resets revision
-counts for the existing session, allowing another batch up to `max_revisions`.
-`dispatch_limit` applies to the current command; continue the same session if
-further stages are appropriate. Do not start a replacement session to reset
-these limits.
-
-Published output paths are relative to
-`.migent/sessions/<session-id>/`. Prefer the paths reported by Migent over
-guessing artifact locations.
+Migent runs a project's multi-stage agent workflows from the `migent` CLI.
+A workflow is a set of stages. A stage runs a role, or runs `verify` alone when `role` is omitted. A role uses a model name
+defined in `.migent/config.yaml`. Each run is a session, stored under
+`.migent/sessions/<session-id>/`.
+
+This skill is already in the prompt. Do not open its file again.
+
+## Rules
+
+- Work from the project root, the directory containing `.migent/config.yaml`.
+- Read `.migent/config.yaml` and the relevant `.migent/workflows/` file before
+  running a workflow.
+- Before writing either, read `.agents/skills/migent/references/schema-config.yaml`
+  and `schema-workflow.yaml` in the same folder. A key absent from them is
+  ignored. Then run `migent doctor --json`; if it reports an outdated schema,
+  run `migent migrate --yes`.
+- You have no terminal for prompts. Pass `--no-input` (or set
+  `MIGENT_NO_INPUT=1`) to `init`, `config model`, and `config role`, and give
+  every value as a flag.
+- Do not edit generated session state: `manifest.yaml`, `status.json`,
+  `events.jsonl`, `metrics.json`, or anything under `executions/`.
+- Keep the user's task wording. Do not read `task.md` or the documents it
+  names; the stage agent does.
+- Never start a replacement session to reset limits or get past `blocked`.
+  Resume the same one.
+
+## Run a task
+
+`<workflow>` is a workflow id or a path to a workflow file.
+
+One-line task. The command runs until the session stops:
+
+```
+migent session run --workflow <workflow> --task "<task>"
+```
+
+Longer task. `<some-id>` is a lowercase slug such as `wave-3`:
+
+```
+migent session prepare <some-id> --workflow <workflow>
+```
+
+Write the task, unchanged, to `.migent/sessions/<some-id>/task.md` (plus any
+files next to it). Do not edit `task.md` once the first stage has started.
+Then:
+
+```
+migent session run --session <some-id> --workflow <workflow>
+```
+
+Dispatch only one stage: add `--once`.
+
+### Read the result
+
+A workflow run prints plain lines on stderr and leaves stdout empty. It does
+not print JSON, and it does not print the stage report.
+
+- `session_id: <id>` when the session is created.
+- `stage <id> · attempt <n> · <HH:MM:SS> · <provider>/<model> (<options>).` when a stage starts. A description follows the model when the stage has one.
+- `stage <id> · attempt <n> · <duration> · <outcome>.` when it finishes. A decision is `decision=<value>` on that line.
+- A completed session adds `completed · <duration>` and one `artifact: <absolute-path>` line per published file. The path starts at the filesystem root and names the published file, so the suffix stays, such as `plan.md`. Report those paths.
+- Exit 1, 3, 6, and 8 also print `response: executions/<id>/response.md`. Read that file to see why it stopped.
+- Exit 7 prints `verify: executions/<id>/turns/01/verify.md`.
+- A session that stops before it is completed ends with `Resume with:` and `migent session continue <session-id>`.
+
+- Do not pass `--verbose` or `--progress`. Do not use `session follow`.
+- If the command runs in the background, wait for its completion notice. Do not
+  add a watcher that waits on the same exit.
+
+### Exit codes
+
+Read the exit code first. Exit 0 with `completed ·` is a completed session.
+Exit 0 without that line is `--once` after a complete stage.
+
+| Exit | Meaning | What to do |
+| --- | --- | --- |
+| 0 | Completed, or with `--once` the stage is complete | Report each `artifact:` path when the session completed. |
+| 1 | Blocked, or with `--once` the stage is not complete | If the stage line says `blocked`: read the `response:` path, then resume with the user's answer (below), or plain `session continue` once the blocker is fixed in the workspace. Otherwise `session continue` keeps going. |
+| 2 | Configuration error | Run `migent doctor --json`, fix config. |
+| 3 | A stage failed and the command did not wait | Read the `response:` path, fix the cause, `session continue`. Continue runs the stage and does not sleep until an old `retry_at`. |
+| 4 | A route would exceed `max_revisions` | Review why the stage keeps being revised, then `session continue` for another batch. |
+| 5 | `--max-dispatches` spent | `session continue` if more stages are appropriate. |
+| 6 | A stage's `verify` stayed red | Read the `response:` path, fix the cause, `session continue`. |
+| 7 | A stage with no role failed `verify` | Read the `verify:` path, fix the tree, `session continue`. That reruns the commands and does not open a provider. |
+| 8 | `--once` or `--stage` hit a provider quota and did not wait | Read the `response:` path. `session continue` runs the stage and does not sleep until the recorded `retry_at`. |
+| 130 | Cancelled, including a wait that was disarmed | Ask the user before resuming. Continue does not sleep until an old `retry_at`. |
+
+A stopped session that is not `completed` is resumable. Do not call it done.
+
+### Resume
+
+```
+migent session continue <session-id>
+```
+
+Same command for a workflow session and a role session. Read `session_status`, then use one row.
+
+| Kind | When | What to run |
+| --- | --- | --- |
+| Workflow | Not `completed`, including a blocker already fixed in the workspace | The command above. Runs until the session stops and resets revision counts. A blocked stage runs again. |
+| Workflow | The user answered a blocked stage | Add `--reply "<reply>"`. That text is the whole prompt body. |
+| Workflow | One stage, then stop | Add `--once`. Revision counts stay. |
+| Role | `cancelled` | The command above. The cut-off turn resumes in the same execution. Omit `--reply`. |
+| Role | `active` | The command above. The last prompt is sent again. |
+| Role | `blocked` | Add `--reply "<reply>"`. That is the next user turn. With no reply, the agent is only told to continue. |
+| Role | `completed` | Leave it stopped. Add `--reply` only to give a new turn. |
+
+`--reply-file <path>` is a longer reply. Pass only one of `--reply` and `--reply-file`. Do not pass `--once` or `--stage` on a role session.
+
+## Check a session
+
+```
+migent session show <session-id> --json
+migent session list --latest --json
+```
+
+`show` gives status, latest execution, decision, and outputs. `list --latest`
+is the newest session, or `null`. Report the session ID, status, stop reason,
+decisions, and the outputs that matter. Output paths are relative to
+`.migent/sessions/<session-id>/`; use the paths Migent reports.
+
+## Set up a project
+
+```
+migent init --no-input --provider <provider> --model <model-id> [--preset implement|plan] [--skill]
+migent doctor --json
+```
+
+`--provider` and `--model` go together. The default preset is `implement`.
+`--skill` installs this skill; `migent skill update` refreshes it.
+
+## Change models
+
+Edit a model name (updates every role and stage that uses it):
+
+```
+migent config model <name> --provider <provider> --model <model-id> --no-input --json
+```
+
+Show the config with `migent config`, `migent config model --json`, or
+`migent config role --json`.
+
+## Look up anything else
+
+This skill covers the common path. Every command takes `--help`; use it before
+guessing a flag:
+
+```
+migent --help
+migent session run --help
+```
+
+References, read only when the task needs them:
+
+| File | Read when |
+| --- | --- |
+| `references/schema-config.yaml`, `references/schema-workflow.yaml` | Writing config or a workflow. |
+| `references/sessions.md` | Prerequisite session (`--prior`), several blocked stages (`--stage`), resuming a cancelled session, raising limits, adopting workflow edits (`--refresh-workflow`). |
+| `references/config.md` | Running one role, pointing roles at another model, overriding one role, role instructions. |
+| `references/inspect.md` | Filtering `session list`, comparing runs with `session metrics`, `session follow`. |
+
+All paths are under `.agents/skills/migent/`.

package/dist/templates/migent/references/config.md

@@ -0,0 +1,52 @@
+# Roles and model configuration
+
+Write commands take `--no-input --json`. The JSON includes the doctor result.
+
+## Run one role
+
+Without `--workflow`, `session run` runs a single role:
+
+```
+migent session run --role <role> --prompt "<prompt>"
+```
+
+| Flag | Meaning |
+| --- | --- |
+| `--file <path>`, `--stdin` | Supply a long prompt. |
+| `--task` | Labels a new role session. Cannot be combined with `--session`. |
+| `--session <session-id>` | Sends a new prompt to an earlier role session. `session continue <session-id>` resumes a stopped role session. |
+| `--provider`, `--model` | Override the role for this turn. Pass together. |
+| `--option KEY=VALUE` | Override a provider option for this turn. |
+| `--json` | Print one result object (the role result, with `outcome_status`; not the workflow result). |
+
+Without `--json` it prints a table. Exit 0 means the outcome is complete, 1
+not complete. `roles.<role>.instructions`, when set, is prepended to the prompt.
+
+## Model names
+
+Provider options on a model name: `--option KEY=VALUE` to set,
+`--clear-option KEY` to remove.
+
+```
+migent config model <name> --provider <provider> --model <model-id> --no-input --json
+```
+
+## Point roles at an existing model name
+
+The value is a name from `models`, not a provider model id.
+
+```
+migent config role <role>... --model-name <name> --no-input --json
+```
+
+## Override one role without touching the shared name
+
+```
+migent config role <role> --provider <provider> --model <model-id> --no-input --json
+```
+
+## Role instructions
+
+`roles.<name>.instructions` is an optional list of strings. A stage prompt
+includes it before that stage's instructions. A role run prepends it to the
+prompt.

package/dist/templates/migent/references/inspect.md

@@ -0,0 +1,32 @@
+# Inspecting many sessions
+
+For one session use `migent session show <session-id> --json` (SKILL.md).
+
+## List
+
+```
+migent session list --workflow <id> --status completed --limit 5 --json
+```
+
+- Output is a JSON array. `--latest` gives one object, or `null`; do not
+  combine it with `--limit`.
+- `--status` is one of `active|prepared|completed|blocked|cancelled|corrupt`.
+  A session whose `status.json` does not parse is listed as `corrupt`.
+- JSON rows omit the task text.
+
+## Metrics
+
+```
+migent session metrics --json
+```
+
+- One session prints its `metrics.json`. Several print one object per
+  line, newest first. Only a completed session has this file. `--workflow`,
+  `--status`, and `--limit` filter those rows.
+- Read `usage_missing` and `uncaptured_turns` before comparing totals.
+- `stage_attempt` is not a retry count.
+
+## Follow
+
+`session follow` streams the event trace for a person at a terminal. Do not use
+it or `--cursor` to coordinate a run.

package/dist/templates/migent/references/schema-config.yaml

@@ -0,0 +1,35 @@
+# A missing schema_version is 0. Commands refuse the file while it is older than this Migent.
+schema_version: 2
+
+# models.<name>.model is the provider model id.
+# roles.<name>.default_model and a stage model are this name.
+# Options merge in order: model, then role, then stage.
+# Only keys the adapter marks overridable are stored on the provider session.
+models:
+  planner:
+    provider: grok
+    model: grok-4.7
+    # grok accepts reasoning-effort (overridable), max_turns, tools, disallowed_tools,
+    # permission_mode (default, acceptEdits, auto, dontAsk, bypassPermissions, plan),
+    # rules, allow, deny, and sandbox.
+    # agy accepts effort (low, medium, high, xhigh, max; overridable), mode (accept-edits, auto, plan),
+    # agent, sandbox (true or false), and skip_permissions (true or false).
+    # claude accepts effort (low, medium, high, xhigh, max; overridable), permission_mode
+    # (acceptEdits, auto, bypassPermissions, manual, dontAsk, plan), tools, allowed_tools,
+    # disallowed_tools, max_budget_usd, fallback_model, and append_system_prompt.
+    # codex accepts model_reasoning_effort (overridable). Any other key of letters, digits,
+    # dots, underscores, and hyphens is passed through as codex exec -c.
+    options:
+      reasoning-effort: high
+
+roles:
+  planner:
+    default_model: planner
+    # Included in every prompt for this role, before stage instructions.
+    # A role run prepends the same list to the prompt.
+    instructions:
+      - Break the task into a reviewable plan.
+    options:
+      reasoning-effort: medium
+  reviewer:
+    default_model: planner

package/dist/templates/migent/references/schema-workflow.yaml

@@ -0,0 +1,71 @@
+# A missing schema_version is 0. Commands refuse the file while it is older than this Migent.
+schema_version: 2
+concurrency: 1
+
+# When id is omitted, the id is the file name without .yaml.
+id: reference
+
+constraints:
+  - Stay within the task.
+
+# requires.workflow names another file in .migent/workflows.
+requires:
+  workflow: plan
+
+stages:
+  - id: prepare
+    description: Check the tree before the draft.
+    # No role: Migent runs verify and does not start an agent.
+    verify:
+      - pnpm build
+    verify_timeout: 1800
+    depends_on: []
+
+  - id: draft
+    description: Write the draft.
+    role: planner
+    # model is a name under models in config.yaml, not a provider model id.
+    model: planner
+    # Options merge in order: model, then role, then stage.
+    # Only keys the adapter marks overridable are stored on the provider session.
+    options:
+      reasoning-effort: high
+    depends_on:
+      - prepare
+    # max_revisions is allowed only when a route returns to this stage.
+    max_revisions: 2
+    instructions:
+      - Write the draft.
+    produces:
+      artifact: draft.md
+
+  - id: review
+    role: reviewer
+    depends_on:
+      - draft
+    # resume_from must be one entry in depends_on. It continues that stage's provider session.
+    session:
+      resume_from: draft
+    instructions:
+      - Review the draft.
+    # verify runs after status complete and must sit on every path to complete.
+    # A stage artifact cannot be named verify.md.
+    verify:
+      - pnpm test
+    # max_verify defaults to 3. verify_timeout is seconds for the whole list. Both require verify.
+    max_verify: 3
+    verify_timeout: 900
+    # Route keys must match decision.values. A destination is a stage id, complete, or a non-empty list of stage ids.
+    decision:
+      values:
+        - approved
+        - revise
+      routes:
+        approved: complete
+        revise: draft
+
+# An output artifact must match produces.artifact on from_stage.
+outputs:
+  - name: draft
+    from_stage: draft
+    artifact: draft.md

package/dist/templates/migent/references/sessions.md

@@ -0,0 +1,65 @@
+# Sessions: uncommon run and resume cases
+
+The everyday commands are in SKILL.md. This file covers the rest.
+
+## Prerequisite session (`--prior`)
+
+If the workflow's `requires` block names a prerequisite workflow and decision,
+find the session:
+
+```
+migent session list --workflow <workflow-id> --status completed --json
+```
+
+Then pass its id with `--prior <session-id>`. `session continue` accepts
+`--prior` too.
+
+## Several blocked stages
+
+When more than one stage is blocked, `session continue` needs the stage:
+
+```
+migent session continue <session-id> --stage <stage> --reply "<reply>"
+```
+
+The other stages stay blocked.
+
+## Cancelled session (exit 130)
+
+Ask the user first. `session continue <session-id>` resumes that same
+execution. A cut-off verify runs again. A cancelled stage with no role
+reruns its verify list in place and does not open a provider. Role status
+and `--reply` are in the skill's Resume section.
+
+## Limits
+
+Accepted by workflow `session run` and by `session continue`.
+
+| Flag | Meaning |
+| --- | --- |
+| `--max-dispatches <n>` | Stage dispatches allowed in this command (default 20). |
+| `--unlimited-dispatches` | Removes the dispatch ceiling. Use only if the user agrees. |
+
+A failed stage stays stopped until `session continue`. That command runs the
+stage and does not sleep until an old `retry_at`. Exit 3 is `stage_failed`.
+Exit 8 is `quota` for `--once` and `--stage`, which do not wait. Exit 130
+during a wait disarms the timer. A single role result uses 0, 1, and 130.
+Exit 6 remains only the path that reopened more than one role execution.
+
+## `--once` and revision counts
+
+`session continue <id>` resets revision counts. `session continue <id> --once`
+advances one stage and does not.
+
+## Config changed during a session
+
+A session keeps the workflow, models, and role instructions it started with.
+Later edits warn on stderr and do not change it. Run `migent doctor --json`
+and tell the user. To adopt the current versions:
+
+```
+migent session continue <session-id> --refresh-workflow
+migent session run --session <session-id> --workflow <workflow> --refresh-workflow
+```
+
+The second form is for starting a prepared session.

package/dist/text.d.ts

@@ -0,0 +1,4 @@
+export declare function text(value: string | null | undefined): string | null;
+export declare function optionalText(value: unknown): string | null;
+/** Keep leading and trailing breaks so a one-line task check sees them. */
+export declare function rawText(value: unknown): string | null;

package/dist/text.js

@@ -0,0 +1,13 @@
+export function text(value) {
+    if (typeof value !== "string")
+        return null;
+    const stripped = value.trim();
+    return stripped === "" ? null : stripped;
+}
+export function optionalText(value) {
+    return text(typeof value === "string" ? value : null);
+}
+/** Keep leading and trailing breaks so a one-line task check sees them. */
+export function rawText(value) {
+    return typeof value === "string" ? value : null;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION: string;

package/dist/version.js

@@ -0,0 +1,3 @@
+import { createRequire } from "node:module";
+const { version } = createRequire(import.meta.url)("../package.json");
+export const PACKAGE_VERSION = version;

package/dist/workspace.js

@@ -1,6 +1,7 @@
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { ConfigurationError } from "@nodeint/migent-kernel";
+import { isFile } from "./fs-utils.js";
 let invocationCwd = null;
 export function setInvocationCwd(cwd) {
     invocationCwd = cwd === undefined ? null : path.resolve(cwd);
@@ -24,12 +25,12 @@ export function resolvePrompt(args) {
     if (args.promptStdin) {
         const text = readFileSync(0, "utf8");
         if (text === "")
-            throw new Error("Prompt from stdin is empty.");
+            throw new ConfigurationError("Prompt from stdin is empty.");
         return text;
     }
     if (args.promptFile == null) {
         if (args.prompt == null)
-            throw new Error("Pass one of --prompt, --file, or --stdin.");
+            throw new ConfigurationError("Pass one of --prompt, --file, or --stdin.");
         return args.prompt;
     }
     try {
@@ -37,14 +38,6 @@ export function resolvePrompt(args) {
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
-        throw new Error(`Unable to read prompt file: ${args.promptFile} (${reason})`);
-    }
-}
-function isFile(filePath) {
-    try {
-        return statSync(filePath).isFile();
-    }
-    catch {
-        return false;
+        throw new ConfigurationError(`Unable to read prompt file: ${args.promptFile} (${reason})`);
     }
 }