@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/akuma/projection.js

@@ -1,6 +1,6 @@
 import { decodeAgentEvent } from "./provider.js";
-const TAIL_LIMIT = 3;
-const VOICE_LIMIT = 5;
+const DEFAULT_TAIL = 3;
+const DEFAULT_VOICE = 3;
 function duration(startedAt, completedAt) {
     const start = Date.parse(startedAt);
     const end = Date.parse(completedAt);
@@ -22,124 +22,235 @@ function narrationRow(fact, event) {
     }
     return null;
 }
-/** Project the complete retained fact window in persisted timeline order. */
-export function projectTimeline(facts) {
-    const state = { rows: [], running: new Map() };
-    for (const fact of facts) {
-        if (fact.kind === "turn-start")
-            state.rows.push({ settled: false, row: { kind: "turn", sequence: fact.sequence, turnSequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.startedAt } });
-        else if (fact.kind === "turn-end")
-            state.rows.push({ settled: true, row: { kind: "outcome", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.completedAt, outcome: fact.outcome } });
-        else if (fact.kind === "call")
-            state.rows.push({ settled: true, row: { kind: "call", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: fact.body } });
-        else if (fact.kind === "tell")
-            state.rows.push({ settled: fact.state !== "pending", row: { kind: "tell", sequence: fact.sequence, at: fact.recordedAt, tellId: fact.id, text: fact.body, state: fact.state, deliveries: fact.deliveries } });
-        else
-            projectActivityEvent(state, fact);
+function projectToolEvent(rows, running, fact, event, phase) {
+    const key = toolKey(fact.turnSequence, event.id);
+    if (event.phase === "started") {
+        running.set(key, rows.length);
+        rows.push({
+            kind: "tool",
+            sequence: fact.sequence,
+            turnSequence: fact.turnSequence,
+            at: fact.at,
+            name: event.name,
+            call: event.call,
+            state: phase === "open" ? "active" : "unsettled",
+            ...(event.truncated === true ? { truncated: true } : {}),
+        });
+        return;
+    }
+    const index = running.get(key);
+    const started = index === undefined ? undefined : rows[index];
+    if (started?.kind !== "tool") {
+        rows.push({ kind: "tool", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, name: event.name, call: event.call, state: event.result, ...(event.truncated === true ? { truncated: true } : {}) });
+        return;
     }
-    return state.rows.map((entry) => entry.row);
+    const durationMs = duration(started.at, fact.at);
+    rows[index] = {
+        kind: "tool",
+        sequence: started.sequence,
+        turnSequence: fact.turnSequence,
+        at: started.at,
+        completedAt: fact.at,
+        ...(durationMs === undefined ? {} : { durationMs }),
+        name: event.name,
+        call: event.call,
+        state: event.result,
+        ...(started.truncated === true || event.truncated === true ? { truncated: true } : {}),
+    };
+    running.delete(key);
 }
 function projectActivityEvent(state, fact) {
     const event = decodeAgentEvent(fact.event);
     const narration = narrationRow(fact, event);
     if (narration !== null) {
-        state.rows.push({ settled: true, row: narration });
+        const turn = state.turnsBySequence.get(fact.turnSequence);
+        if (turn === undefined)
+            state.orphanRows.push(narration);
+        else
+            turn.rows.push(narration);
         return;
     }
     if (event.type !== "tool")
         return;
-    const key = toolKey(fact.turnSequence, event.id);
-    if (event.phase === "started") {
-        state.running.set(key, state.rows.length);
-        state.rows.push({ settled: false, row: { kind: "tool", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, name: event.name, call: event.call, state: "running", ...(event.truncated === true ? { truncated: true } : {}) } });
-        return;
+    const turn = state.turnsBySequence.get(fact.turnSequence);
+    if (turn === undefined)
+        projectToolEvent(state.orphanRows, state.orphanRunning, fact, event, "closed");
+    else
+        projectToolEvent(turn.rows, turn.running, fact, event, turn.phase);
+}
+function demoteActive(row) {
+    if (row.kind !== "tool" || row.state !== "active")
+        return row;
+    return { ...row, state: "unsettled" };
+}
+function foldOutcomeVoice(rows, outcome) {
+    if (outcome?.outcome.kind !== "answered")
+        return rows;
+    const finalVoice = rows.findLast((row) => row.kind === "said");
+    return finalVoice?.text === outcome.outcome.answer && finalVoice.truncated !== true
+        ? rows.filter((row) => row !== finalVoice)
+        : rows;
+}
+function finishTurn(turn) {
+    const rows = foldOutcomeVoice(turn.rows, turn.outcome);
+    if (turn.phase === "closed" && turn.outcome !== undefined) {
+        return { kind: "closed", turn: turn.turn, rows: rows.map(demoteActive), outcome: turn.outcome };
     }
-    const index = state.running.get(key);
-    const started = index === undefined ? undefined : state.rows[index]?.row;
-    if (started?.kind !== "tool") {
-        state.rows.push({ settled: true, row: {
-                kind: "tool", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at,
-                name: event.name, call: event.call, state: event.result,
-                ...(event.truncated === true ? { truncated: true } : {}),
-            } });
-        return;
+    if (rows.some((row) => row.kind === "tool" && row.state === "unsettled")) {
+        throw new Error(`open Turn ${turn.turn.turnSequence} contains an unsettled tool`);
     }
-    const startedAt = started.at;
-    const durationMs = duration(startedAt, fact.at);
-    const completed = {
-        kind: "tool", sequence: started.sequence, turnSequence: fact.turnSequence, at: startedAt,
-        completedAt: fact.at, ...(durationMs === undefined ? {} : { durationMs }),
-        name: event.name, call: event.call, state: event.result,
-        ...(started?.kind === "tool" && started.truncated === true || event.truncated === true ? { truncated: true } : {}),
+    return { kind: "open", turn: turn.turn, rows: rows };
+}
+/** Fold the retained fact timeline into Turn-owned rows without inventing provider facts. */
+export function projectTurns(facts, retained = {
+    lowestRetained: facts[0]?.sequence ?? null,
+    highest: facts.at(-1)?.sequence ?? null,
+}) {
+    const state = {
+        turns: [],
+        turnsBySequence: new Map(),
+        tells: [],
+        orphanRows: [],
+        orphanOutcomes: [],
+        orphanRunning: new Map(),
     };
-    state.rows[index] = { settled: true, row: completed };
-    state.running.delete(key);
-}
-function pinned(row, latestOutcome, openTurn) {
-    return row === latestOutcome
-        || (row.kind === "turn" && row.turnSequence === openTurn)
-        || (row.kind === "call" && row.turnSequence === openTurn)
-        || (row.kind === "tool" && row.state === "running")
-        || (row.kind === "tell" && row.state === "pending");
-}
-/** Apply the bounded snapshot policy after semantic projection. */
-export function selectActivitySnapshot(facts, input = {}) {
-    const projected = projectTimeline(facts);
-    const ended = new Set(projected.filter((row) => row.kind === "outcome").map((row) => row.turnSequence));
-    const openTurn = projected.findLast((row) => row.kind === "turn" && !ended.has(row.turnSequence));
-    const latestOutcome = projected.findLast((row) => row.kind === "outcome");
-    const ordinary = projected.filter((row) => !pinned(row, latestOutcome, openTurn?.turnSequence));
-    const selected = new Set(ordinary.slice(-TAIL_LIMIT));
-    if ((input.profile ?? "status") === "status") {
-        for (const row of ordinary.filter((value) => value.kind === "said" || value.kind === "thought").slice(-VOICE_LIMIT)) {
-            selected.add(row);
+    for (const fact of facts) {
+        if (fact.kind === "turn-start") {
+            const turn = { kind: "turn", sequence: fact.sequence, turnSequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.startedAt };
+            const projected = { phase: "open", turn, rows: [], running: new Map() };
+            state.turns.push(projected);
+            state.turnsBySequence.set(turn.turnSequence, projected);
+        }
+        else if (fact.kind === "turn-end") {
+            const outcome = { kind: "outcome", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.completedAt, outcome: fact.outcome };
+            const turn = state.turnsBySequence.get(fact.turnSequence);
+            if (turn === undefined)
+                state.orphanOutcomes.push(outcome);
+            else {
+                turn.phase = "closed";
+                turn.rows = turn.rows.map(demoteActive);
+                turn.outcome = outcome;
+            }
+        }
+        else if (fact.kind === "call") {
+            const row = { kind: "call", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: fact.body };
+            const turn = state.turnsBySequence.get(fact.turnSequence);
+            if (turn === undefined)
+                state.orphanRows.push(row);
+            else
+                turn.rows.push(row);
+        }
+        else if (fact.kind === "tell") {
+            state.tells.push({ kind: "tell", sequence: fact.sequence, at: fact.recordedAt, tellId: fact.id, text: fact.body, state: fact.state, deliveries: fact.deliveries });
+        }
+        else {
+            projectActivityEvent(state, fact);
         }
     }
-    for (const row of projected)
-        if (pinned(row, latestOutcome, openTurn?.turnSequence))
-            selected.add(row);
-    const entries = [];
-    let hidden = [];
-    const flush = () => {
-        if (hidden.length === 1)
-            entries.push({ kind: "row", row: hidden[0] });
-        else if (hidden.length > 1)
-            entries.push({ kind: "gap", count: hidden.length });
-        hidden = [];
+    const turns = state.turns.map(finishTurn);
+    const rows = [
+        ...turns.flatMap((turn) => [turn.turn, ...turn.rows, ...(turn.kind === "closed" ? [turn.outcome] : [])]),
+        ...state.tells,
+        ...state.orphanRows,
+        ...state.orphanOutcomes,
+    ].sort((left, right) => left.sequence - right.sequence);
+    const frontier = turns.at(-1);
+    const openTurn = frontier?.kind === "open" ? frontier : undefined;
+    const latestOutcome = rows.findLast((row) => row.kind === "outcome");
+    return { rows, turns, retained, ...(openTurn === undefined ? {} : { openTurn }), ...(latestOutcome === undefined ? {} : { latestOutcome }) };
+}
+function entries(rows) {
+    return rows.map((row) => ({ kind: "row", row }));
+}
+function openEntries(ledger, window, selected) {
+    const windowRows = new Set(window);
+    const result = [];
+    let hidden = 0;
+    const flushGap = () => {
+        if (hidden === 0)
+            return;
+        result.push({ kind: "gap", count: hidden });
+        hidden = 0;
     };
-    for (const row of projected) {
+    for (const row of ledger.rows) {
+        if (windowRows.has(row) && !selected.has(row)) {
+            hidden += 1;
+            continue;
+        }
         if (!selected.has(row))
-            hidden.push(row);
-        else {
-            flush();
-            entries.push({ kind: "row", row });
+            continue;
+        flushGap();
+        if (row.kind !== "turn" && row.kind !== "outcome" && !(row.kind === "tool" && row.state === "unsettled")) {
+            result.push({ kind: "row", row });
         }
     }
-    flush();
+    flushGap();
+    return result;
+}
+/** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
+export function ordinarySnapshotBudget(ordinaryBudget) {
+    const tail = Math.min(DEFAULT_TAIL, Math.max(0, ordinaryBudget));
+    return { tail, voice: Math.min(DEFAULT_VOICE, Math.max(0, ordinaryBudget) - tail) };
+}
+/** Count selected ordinary rows; active tools and pending tells stay outside this total. */
+export function ordinarySelectedCount(snapshot) {
+    return snapshot.entries.reduce((count, entry) => {
+        if (entry.kind !== "row")
+            return count;
+        if (entry.row.kind === "tool" && entry.row.state === "active")
+            return count;
+        if (entry.row.kind === "tell" && entry.row.state === "pending")
+            return count;
+        return count + 1;
+    }, 0);
+}
+/** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
+export function selectSnapshot(ledger, budget = { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE }) {
+    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell"))
+        return { kind: "unborn", entries: [], omitted: 0 };
+    const pending = ledger.rows.filter((row) => row.kind === "tell" && row.state === "pending");
+    if (ledger.openTurn !== undefined) {
+        const window = ledger.openTurn.rows;
+        const active = window.filter((row) => row.kind === "tool" && row.state === "active");
+        const ordinary = window.filter((row) => !(row.kind === "tool" && row.state === "active"));
+        const tailCount = Math.max(0, budget.tail);
+        const tail = tailCount === 0 ? [] : ordinary.slice(-tailCount);
+        const tailSet = new Set(tail);
+        const voiceCount = Math.max(0, budget.voice ?? DEFAULT_VOICE);
+        const voiceCandidates = ordinary
+            .filter((row) => !tailSet.has(row) && (row.kind === "said" || row.kind === "thought"));
+        const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
+        const selected = new Set([...tail, ...voice, ...active, ...pending]);
+        const omitted = window.filter((row) => !selected.has(row)).length;
+        return { kind: "open", turn: ledger.openTurn.turn, entries: openEntries(ledger, window, selected), omitted };
+    }
     return {
-        entries,
-        lowestRetained: input.lowestRetained ?? (facts[0]?.sequence ?? null),
-        highest: input.highest ?? (facts.at(-1)?.sequence ?? null),
+        kind: "idle",
+        ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
+        entries: entries(pending),
+        omitted: 0,
     };
 }
-/** Apply cursor and limit to the one semantic timeline projection. */
-export function projectActivityHistory(slice, input) {
-    const projected = projectTimeline(slice.rows);
-    const eligible = projected.filter((row) => input.before !== undefined
-        ? row.sequence < input.before
-        : input.since !== undefined ? row.sequence > input.since : true);
-    const rows = input.since !== undefined ? eligible.slice(0, input.limit) : eligible.slice(-input.limit);
-    const forwardHistoryLost = input.since !== undefined
-        && slice.rows[0] !== undefined
-        && slice.rows[0].sequence > input.since + 1;
+/** Apply the one snapshot policy used by every public observation consumer. */
+export function selectActivitySnapshot(facts) {
+    return selectSnapshot(projectTurns(facts));
+}
+export function selectHistory(ledger, cursor) {
+    const eligible = ledger.rows.filter((row) => cursor.before !== undefined
+        ? row.sequence < cursor.before
+        : cursor.since !== undefined ? row.sequence > cursor.since : true);
+    const rows = cursor.since !== undefined ? eligible.slice(0, cursor.limit) : eligible.slice(-cursor.limit);
+    const omitted = Math.max(0, eligible.length - rows.length);
+    const historyLost = cursor.since !== undefined
+        ? (ledger.rows[0] !== undefined && ledger.rows[0].sequence > cursor.since + 1)
+        : (ledger.retained.lowestRetained !== null && ledger.retained.lowestRetained > 1 && omitted === 0);
     return {
         rows,
-        omitted: Math.max(0, eligible.length - rows.length),
-        hasEarlier: input.since === undefined && eligible.length > rows.length,
-        hasLater: input.since !== undefined && eligible.length > rows.length,
-        historyLost: forwardHistoryLost || (input.since === undefined && eligible.length === rows.length
-            && slice.lowestRetained !== null && slice.lowestRetained > 1),
-        lowestRetained: slice.lowestRetained,
-        highest: slice.highest,
+        omitted,
+        hasEarlier: cursor.since === undefined && eligible.length > rows.length,
+        hasLater: cursor.since !== undefined && eligible.length > rows.length,
+        historyLost,
+        lowestRetained: ledger.retained.lowestRetained,
+        highest: ledger.retained.highest,
     };
 }

package/build/src/akuma/provider-recipe.d.ts

@@ -0,0 +1,24 @@
+export type ProviderOptions = Readonly<{
+    model?: string;
+    effort?: string;
+    readonly?: true;
+    network?: "disabled" | "enabled";
+    systemPrompt?: string;
+}>;
+export type ReadonlyRestraint = Readonly<{
+    enforcement: "native";
+    diagnostic?: never;
+} | {
+    enforcement: "none";
+    diagnostic: string;
+}>;
+export type ProviderExecution = Readonly<{
+    name: string;
+    kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+    executable?: string;
+    config?: Readonly<Record<string, unknown>>;
+    env?: Readonly<Record<string, string>>;
+}>;
+export declare function decodeProviderOptions(value: unknown): ProviderOptions;
+export declare function decodeReadonlyRestraint(value: unknown): ReadonlyRestraint;
+export declare function decodeProviderRecipe(input: unknown): ProviderExecution;

package/build/src/akuma/provider-recipe.js

@@ -0,0 +1,100 @@
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function snapshot(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(snapshot));
+    const object = record(value);
+    if (object === null)
+        return value;
+    return Object.freeze(Object.fromEntries(Object.entries(object).map(([key, item]) => [key, snapshot(item)])));
+}
+function optionText(options, field, blank) {
+    const selected = options[field];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || (blank === "refuse" && selected.trim().length === 0)) {
+        throw new TypeError(`provider option ${field} must be ${blank === "allow" ? "a string" : "a nonblank string"}`);
+    }
+    return selected;
+}
+export function decodeProviderOptions(value) {
+    const options = record(value);
+    if (options === null)
+        throw new TypeError("provider options must be an object");
+    const allowed = ["effort", "model", "network", "readonly", "systemPrompt"];
+    const unknown = Object.keys(options).find((key) => !allowed.includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`provider options have unknown field ${unknown}`);
+    const model = optionText(options, "model", "refuse");
+    const effort = optionText(options, "effort", "refuse");
+    if (options.readonly !== undefined && options.readonly !== true) {
+        throw new TypeError("provider option readonly must be true");
+    }
+    const network = options.network;
+    if (network !== undefined && network !== "disabled" && network !== "enabled") {
+        throw new TypeError("provider option network must be disabled, enabled");
+    }
+    const systemPrompt = optionText(options, "systemPrompt", "allow");
+    return Object.freeze({
+        ...(model === undefined ? {} : { model }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(options.readonly === undefined ? {} : { readonly: true }),
+        ...(network === undefined ? {} : { network }),
+        ...(systemPrompt === undefined ? {} : { systemPrompt }),
+    });
+}
+export function decodeReadonlyRestraint(value) {
+    const restraint = record(value);
+    if (restraint === null)
+        throw new TypeError("readonly restraint must be an object");
+    const keys = Object.keys(restraint).sort();
+    if (restraint.enforcement === "native" && keys.length === 1 && keys[0] === "enforcement") {
+        return Object.freeze({ enforcement: "native" });
+    }
+    if (restraint.enforcement === "none"
+        && keys.length === 2 && keys[0] === "diagnostic" && keys[1] === "enforcement"
+        && typeof restraint.diagnostic === "string" && restraint.diagnostic.trim().length > 0) {
+        return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
+    }
+    throw new TypeError("readonly restraint must be native or none with a diagnostic");
+}
+function providerKind(value) {
+    return value === "acp" || value === "claude-agent-sdk" || value === "codex-app-server" || value === "grok-build"
+        || value === "opencode-sdk" || value === "pi";
+}
+export function decodeProviderRecipe(input) {
+    const value = record(input);
+    if (value === null)
+        throw new TypeError("provider execution must be an object");
+    const allowed = ["config", "env", "executable", "kind", "name"];
+    const unknown = Object.keys(value).find((key) => !allowed.includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`provider execution has unknown field ${unknown}`);
+    if (typeof value.name !== "string" || value.name.trim().length === 0) {
+        throw new TypeError("provider execution name must be a nonblank string");
+    }
+    if (!providerKind(value.kind))
+        throw new TypeError("provider execution has unknown kind");
+    if (value.executable !== undefined && (typeof value.executable !== "string" || value.executable.trim().length === 0)) {
+        throw new TypeError("provider execution executable must be a nonblank string");
+    }
+    const config = value.config === undefined ? undefined : record(value.config);
+    if (config === null)
+        throw new TypeError("provider execution config must be an object");
+    const env = value.env === undefined ? undefined : record(value.env);
+    if (env === null)
+        throw new TypeError("provider execution env must be an object");
+    if (env !== undefined && Object.values(env).some((item) => typeof item !== "string")) {
+        throw new TypeError("provider execution env must contain only string values");
+    }
+    return Object.freeze({
+        name: value.name,
+        kind: value.kind,
+        ...(value.executable === undefined ? {} : { executable: value.executable }),
+        ...(config === undefined ? {} : { config: snapshot(config) }),
+        ...(env === undefined ? {} : { env: Object.freeze({ ...env }) }),
+    });
+}

package/build/src/akuma/provider.d.ts

@@ -1,19 +1,25 @@
-import type { Confinement, ProviderOptions } from "./heart/index.js";
+import type { Confinement } from "./heart/index.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate, type ResumeCoordinate } from "./coordinate.js";
+import type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
-export type { ProviderOptions } from "./heart/index.js";
 export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
 export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
+export type SearchScope = "content" | "files" | "web";
 export type ToolCall = Readonly<{
     kind: "run";
     command: string;
 }> | Readonly<{
     kind: "read";
     path: string;
+    offset?: number;
+    limit?: number;
 }> | Readonly<{
     kind: "search";
     query: string;
+    scope?: SearchScope;
+    path?: string;
+    glob?: string;
 }> | Readonly<{
     kind: "fileChange";
     changes: readonly Readonly<{
@@ -67,7 +73,6 @@ export type AgentEvent = Readonly<{
     truncated?: true;
 }>;
 export { decodeResumeCoordinate, encodeResumeCoordinate };
-export declare function decodeProviderOptions(value: unknown): ProviderOptions;
 export declare function decodeAgentEvent(value: unknown): AgentEvent;
 export declare function encodeAgentEvent(event: AgentEvent): unknown;
 export declare function boundedEventText(value: string): string;
@@ -89,7 +94,7 @@ export declare class AgentEventChannel implements AsyncIterable<AgentEvent> {
 export type TurnResult = Readonly<{
     kind: "answered";
     answer: string;
-    historyId: string;
+    historyId?: string;
 }> | Readonly<{
     kind: "failed";
     diagnostic: string;
@@ -117,6 +122,7 @@ export type Session = Readonly<{
     events: AsyncIterable<AgentEvent>;
     receipts?: AsyncIterable<TellReceipt>;
     completion: Promise<TurnResult>;
+    /** Fulfills after every adapter-owned OS child or native session is disposed. */
     abort(): Promise<void>;
     tell?(tell: Readonly<{
         id: string;
@@ -131,6 +137,7 @@ export type DriveInput = Readonly<{
     }>[];
     cwd: string;
     options: ProviderOptions;
+    signal: AbortSignal;
     requests?: Readonly<{
         dir: string;
     }>;
@@ -138,6 +145,7 @@ export type DriveInput = Readonly<{
 export type ProviderOptionAdmission = Readonly<{
     kind: "admitted";
     options: ProviderOptions;
+    readonly?: ReadonlyRestraint;
 }> | Readonly<{
     kind: "refused";
     diagnostic: string;