@nowcrew/daemon 0.5.45 → 0.5.47

package/dist/local-memory-telemetry.js

@@ -0,0 +1,224 @@
+import { dslog } from "./slog.js";
+import { analyzeLocalMemoryInjection, createLocalMemoryAccessObserver, inspectLocalMemoryFilesWithinDeadline, localMemoryContentFacts, localMemoryFileChanged, } from "./local-memory-diagnostics.js";
+function safeLog(eventType, message, fields) {
+    try {
+        dslog(eventType, message, fields);
+    }
+    catch {
+        // Local-memory diagnostics must never alter Agent execution.
+    }
+}
+function errorFields(error) {
+    const code = error?.code;
+    return {
+        error_name: error instanceof Error ? error.name : "unknown",
+        ...(typeof code === "string" ? { error_code: code } : {}),
+    };
+}
+export function logLocalMemoryContextPrepareFailure(identity, phase, error) {
+    safeLog("local_memory.context_prepare_failed", "本地记忆上下文准备失败", {
+        level: "WARN",
+        execution_id: identity.executionId,
+        agent_handle: identity.agentHandle,
+        task_key: identity.taskKey,
+        failure_phase: phase,
+        ...errorFields(error),
+    });
+}
+export function logLocalMemoryDiagnosticsFailure(identity, phase, error) {
+    safeLog("local_memory.diagnostics_failed", "本地记忆诊断失败并已放行", {
+        level: "WARN",
+        execution_id: identity.executionId,
+        agent_handle: identity.agentHandle,
+        task_key: identity.taskKey,
+        diagnostics_phase: phase,
+        ...errorFields(error),
+    });
+}
+function snapshotFields(snapshot) {
+    if (snapshot === null)
+        return {};
+    return {
+        memory_exists: snapshot.memory.exists,
+        memory_size_bytes: snapshot.memory.size_bytes,
+        memory_mtime_ms: snapshot.memory.mtime_ms,
+        memory_sha256: snapshot.memory.sha256,
+        memory_hash_skipped_reason: snapshot.memory.hash_skipped_reason,
+        memory_error_code: snapshot.memory.error_code,
+        memory_markdown_heading_count: snapshot.memory.markdown_heading_count,
+        memory_lessons_reference_count: snapshot.memory.lessons_reference_count,
+        lessons_exists: snapshot.lessons.exists,
+        lessons_size_bytes: snapshot.lessons.size_bytes,
+        lessons_mtime_ms: snapshot.lessons.mtime_ms,
+        lessons_sha256: snapshot.lessons.sha256,
+        lessons_hash_skipped_reason: snapshot.lessons.hash_skipped_reason,
+        lessons_error_code: snapshot.lessons.error_code,
+        lessons_markdown_heading_count: snapshot.lessons.markdown_heading_count,
+    };
+}
+function promptDelivery(runtime, stableProtocolRuntime) {
+    if (runtime === "claude")
+        return "claude_system_prompt_file";
+    if (!stableProtocolRuntime)
+        return "combined_wake_prompt";
+    return runtime === "codex" ? "codex_developer_instructions" : "kimi_protocol_prompt";
+}
+function logAccess(options, observation, sequence) {
+    safeLog("local_memory.file_access_observed", "观察到本地记忆文件访问", {
+        execution_id: options.executionId,
+        agent_handle: options.agentHandle,
+        task_key: options.taskKey,
+        runtime: options.runtime,
+        access_sequence: sequence,
+        ...observation,
+    });
+}
+export function createLocalMemoryTelemetry(options) {
+    const accessObserver = createLocalMemoryAccessObserver({
+        homeDir: options.agentDir,
+        runDir: options.runDir,
+    });
+    let beforeSnapshot = null;
+    let diagnosticsMs;
+    let accessSequence = 0;
+    let contextWasPrepared = false;
+    let runtimeStarted = false;
+    let runtimeReady = false;
+    let runtimeExitCode;
+    let executorCompleted = false;
+    return {
+        async captureBefore() {
+            const startedAt = Date.now();
+            try {
+                beforeSnapshot = await inspectLocalMemoryFilesWithinDeadline(options.agentDir, options.diagnosticsTimeoutMs);
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "before", error);
+            }
+            finally {
+                diagnosticsMs = Date.now() - startedAt;
+            }
+        },
+        contextPrepared(context) {
+            try {
+                const sourceFacts = localMemoryContentFacts(context.memory);
+                const injectionFacts = analyzeLocalMemoryInjection(context.systemPrompt, context.memory);
+                safeLog("local_memory.context_prepared", "本地记忆上下文已准备", {
+                    execution_id: options.executionId,
+                    agent_handle: options.agentHandle,
+                    task_key: options.taskKey,
+                    runtime: options.runtime,
+                    resumed: context.resumed,
+                    is_memory_prune: options.isMemoryPrune,
+                    memory_seed_created: context.memorySeedCreated,
+                    memory_source_read: true,
+                    memory_source_size_bytes: sourceFacts.size_bytes,
+                    memory_source_sha256: sourceFacts.sha256,
+                    memory_source_scan_skipped_reason: sourceFacts.scan_skipped_reason,
+                    memory_read_matches_snapshot: sourceFacts.sha256 === undefined
+                        || beforeSnapshot?.memory.sha256 === undefined
+                        ? undefined
+                        : sourceFacts.sha256 === beforeSnapshot.memory.sha256,
+                    memory_source_nonblank: sourceFacts.nonblank,
+                    memory_source_markdown_heading_count: sourceFacts.markdown_heading_count,
+                    memory_source_lessons_reference_count: sourceFacts.lessons_reference_count,
+                    memory_injection_state: injectionFacts.state,
+                    memory_injection_source_bytes: injectionFacts.source_bytes,
+                    memory_injection_bounded_bytes: injectionFacts.bounded_bytes,
+                    memory_injected_bytes: injectionFacts.injected_bytes,
+                    system_prompt_bytes: Buffer.byteLength(context.systemPrompt, "utf8"),
+                    prompt_delivery: promptDelivery(options.runtime, options.stableProtocolRuntime),
+                    diagnostics_ms: diagnosticsMs,
+                    ...snapshotFields(beforeSnapshot),
+                });
+                contextWasPrepared = true;
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "event_observe", error);
+            }
+        },
+        observe(event) {
+            try {
+                for (const observation of accessObserver.observe(event)) {
+                    accessSequence += 1;
+                    logAccess(options, observation, accessSequence);
+                }
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "event_observe", error);
+            }
+        },
+        markRuntimeStarted() {
+            runtimeStarted = true;
+        },
+        markRuntimeReady() {
+            runtimeReady = true;
+        },
+        markRuntimeExited(exitCode) {
+            runtimeExitCode = exitCode;
+        },
+        markExecutorCompleted() {
+            executorCompleted = true;
+        },
+        async finish() {
+            let afterSnapshot = null;
+            try {
+                afterSnapshot = await inspectLocalMemoryFilesWithinDeadline(options.agentDir, options.diagnosticsTimeoutMs);
+            }
+            catch (error) {
+                logLocalMemoryDiagnosticsFailure(options, "after", error);
+            }
+            const memoryChanged = beforeSnapshot !== null && afterSnapshot !== null
+                ? localMemoryFileChanged(beforeSnapshot.memory, afterSnapshot.memory)
+                : undefined;
+            const lessonsChanged = beforeSnapshot !== null && afterSnapshot !== null
+                ? localMemoryFileChanged(beforeSnapshot.lessons, afterSnapshot.lessons)
+                : undefined;
+            const accessSummary = accessObserver.summary();
+            const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined
+                ? undefined
+                : memoryChanged || lessonsChanged;
+            const currentExecutionSharedWriteObserved = accessSummary.shared_memory_write_succeeded > 0
+                || accessSummary.shared_lessons_write_succeeded > 0;
+            safeLog("local_memory.execution_observed", "本地记忆执行观察已完成", {
+                execution_id: options.executionId,
+                agent_handle: options.agentHandle,
+                task_key: options.taskKey,
+                runtime: options.runtime,
+                is_memory_prune: options.isMemoryPrune,
+                context_prepared: contextWasPrepared,
+                runtime_started: runtimeStarted,
+                runtime_ready: runtimeReady,
+                runtime_exit_code: runtimeExitCode,
+                executor_outcome: executorCompleted ? "succeeded" : "failed",
+                memory_changed: memoryChanged,
+                lessons_changed: lessonsChanged,
+                shared_files_changed_during_execution: sharedFilesChanged,
+                unexpected_shared_write: options.isMemoryPrune
+                    ? undefined
+                    : currentExecutionSharedWriteObserved
+                        ? true
+                        : sharedFilesChanged === false ? false : undefined,
+                access_observation_count: accessSequence,
+                ...accessSummary,
+                ...(afterSnapshot === null ? {} : {
+                    memory_after_exists: afterSnapshot.memory.exists,
+                    memory_after_size_bytes: afterSnapshot.memory.size_bytes,
+                    memory_after_mtime_ms: afterSnapshot.memory.mtime_ms,
+                    memory_after_sha256: afterSnapshot.memory.sha256,
+                    memory_after_hash_skipped_reason: afterSnapshot.memory.hash_skipped_reason,
+                    memory_after_error_code: afterSnapshot.memory.error_code,
+                    memory_after_markdown_heading_count: afterSnapshot.memory.markdown_heading_count,
+                    memory_after_lessons_reference_count: afterSnapshot.memory.lessons_reference_count,
+                    lessons_after_exists: afterSnapshot.lessons.exists,
+                    lessons_after_size_bytes: afterSnapshot.lessons.size_bytes,
+                    lessons_after_mtime_ms: afterSnapshot.lessons.mtime_ms,
+                    lessons_after_sha256: afterSnapshot.lessons.sha256,
+                    lessons_after_hash_skipped_reason: afterSnapshot.lessons.hash_skipped_reason,
+                    lessons_after_error_code: afterSnapshot.lessons.error_code,
+                    lessons_after_markdown_heading_count: afterSnapshot.lessons.markdown_heading_count,
+                }),
+            });
+        },
+    };
+}

package/dist/machine-info.js

@@ -15,6 +15,8 @@ import { dirname, resolve } from "node:path";
 import { executableRuntimes } from "./runtime-capabilities.js";
 import { executionBackendCapability } from "./execution-backend.js";
 import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+import { probeHermesAcp } from "./runtimes/hermes.js";
+import { probeOpenCodeRun } from "./runtimes/opencode.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const DAEMON_CAPABILITIES = [
@@ -39,6 +41,7 @@ const RUNTIME_BINS = [
     ["codex", "codex"],
     ["cursor", "cursor-agent"],
     ["gemini", "gemini"],
+    ["hermes", "hermes"],
     ["opencode", "opencode"],
     ["copilot", "copilot"],
     ["kimi", "kimi"],
@@ -59,17 +62,29 @@ export async function detectRuntimes() {
     const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => ((await isInstalled(bin)) ? name : null)));
     return checks.filter((x) => x !== null);
 }
-async function supportsKimiAcp() {
-    return probeKimiAcp({ bin: "kimi" });
+async function supportsKimiAcp(signal) {
+    return probeKimiAcp({ bin: "kimi", ...(signal ? { signal } : {}) });
+}
+async function supportsHermesAcp(signal) {
+    return probeHermesAcp({ bin: "hermes", ...(signal ? { signal } : {}) });
+}
+async function supportsOpenCodeRun(signal) {
+    return probeOpenCodeRun(signal);
 }
 /** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
-export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp) {
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, signal) {
     const present = await installed;
-    const supported = executableRuntimes(present).filter((runtime) => runtime !== "kimi");
-    if (present.includes("kimi") && await kimiAcpProbe())
-        supported.push("kimi");
-    return supported;
+    const [kimiReady, hermesReady, openCodeReady] = await Promise.all([
+        present.includes("kimi") ? kimiAcpProbe(signal) : false,
+        present.includes("hermes") ? hermesAcpProbe(signal) : false,
+        present.includes("opencode") ? openCodeProbe(signal) : false,
+    ]);
+    return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
+        : runtime === "hermes" ? hermesReady
+            : runtime === "opencode" ? openCodeReady
+                : true));
 }
+export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, signal);
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));

package/dist/main.js

@@ -113,7 +113,12 @@ async function main() {
         process.exit(2);
     }
     process.stdout.write(formatDaemonLogLine(`🚀 ${td("Waking agent")} "${values.agent}" ${td("for channel")} ${values.channel}`) + "\n");
-    initSlog(config.serverUrl, config.machineToken); // 一次性 run 模式也上报 SLS(runner 里的埋点生效)
+    initSlog(config.serverUrl, config.machineToken, {
+        daemonVersion: daemonVersion(),
+        cliVersion: cliVersion(),
+        ...(values.profile === undefined ? {} : { profileName: values.profile }),
+        agentsRoot: config.agentsRoot,
+    }); // 一次性 run 模式也上报 SLS(runner 里的埋点生效)
     const result = await runAgent(config, {
         handle: values.agent,
         channelId: values.channel,

package/dist/normalize.js

@@ -34,7 +34,8 @@ export function classifyCommand(command) {
 /** 从各 runtime 的最终事件提取可交付文本。调用方按事件顺序保留最后一个非空值。 */
 export function extractFinalText(event) {
     const e = (event ?? {});
-    if (e.type === "kimi.acp.text_delta" && e.text)
+    if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
+        || e.type === "opencode.text_delta") && e.text)
         return e.text;
     if (e.type === "result" && !e.is_error && e.result?.trim())
         return e.result.trim();
@@ -61,13 +62,16 @@ function parseKimiBashCommand(args) {
 /** 把一个 stream-json 事件归一化为 0..N 个活动。 */
 export function normalizeEvent(event) {
     const e = (event ?? {});
-    if (e.type === "kimi.acp.text_delta" && e.text?.trim()) {
+    if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
+        || e.type === "opencode.text_delta") && e.text?.trim()) {
         return [{ kind: "text", label: "思考/说明", detail: e.text }];
     }
-    if (e.type === "kimi.acp.tool_call") {
+    if (e.type === "kimi.acp.tool_call" || e.type === "hermes.acp.tool_call"
+        || e.type === "opencode.tool_call") {
         return [{ kind: "tool", label: e.title ? `工具:${e.title}` : "工具调用" }];
     }
-    if (e.type === "kimi.acp.tool_result") {
+    if (e.type === "kimi.acp.tool_result" || e.type === "hermes.acp.tool_result"
+        || e.type === "opencode.tool_result") {
         return [{ kind: "tool_result", label: "工具返回" }];
     }
     if (e.type === "system" && e.subtype === "init") {
@@ -86,6 +90,12 @@ export function normalizeEvent(event) {
     if (e.type === "turn.completed") {
         return [{ kind: "done", label: "本轮结束" }];
     }
+    if (e.type === "opencode.error") {
+        const detail = typeof event.message === "string"
+            ? event.message
+            : undefined;
+        return [{ kind: "error", label: "运行出错", ...(detail ? { detail } : {}) }];
+    }
     if (e.type === "result") {
         return e.is_error
             ? [{ kind: "error", label: "运行出错", ...(e.result ? { detail: e.result } : {}) }]

package/dist/runtime-capabilities.js

@@ -1,4 +1,4 @@
-export const LOCAL_EXECUTION_RUNTIMES = ["claude", "codex", "kimi"];
+export const LOCAL_EXECUTION_RUNTIMES = ["claude", "codex", "kimi", "hermes", "opencode"];
 export const LOCAL_RUNTIME_CAPABILITIES = Object.freeze({
     claude: Object.freeze({
         transport: "claude-stream-json",
@@ -15,6 +15,16 @@ export const LOCAL_RUNTIME_CAPABILITIES = Object.freeze({
         nativeResume: true,
         systemPromptTransport: "protocol",
     }),
+    hermes: Object.freeze({
+        transport: "hermes-acp",
+        nativeResume: true,
+        systemPromptTransport: "file",
+    }),
+    opencode: Object.freeze({
+        transport: "opencode-json",
+        nativeResume: true,
+        systemPromptTransport: "file",
+    }),
 });
 export function runtimeCapability(runtime) {
     return LOCAL_RUNTIME_CAPABILITIES[runtime];

package/dist/runtime-probe.js

@@ -0,0 +1,26 @@
+import { executableRuntimes } from "./runtime-capabilities.js";
+export function conservativeExecutionRuntimes(installed) {
+    return executableRuntimes(installed)
+        .filter((runtime) => runtime === "claude" || runtime === "codex");
+}
+export function createRuntimeProbeCoordinator() {
+    const abort = new AbortController();
+    const flights = new Map();
+    return {
+        detect(installed, detector) {
+            const key = [...installed].sort().join("\0");
+            const existing = flights.get(key);
+            if (existing)
+                return existing;
+            const pending = detector(installed, abort.signal).catch((error) => {
+                flights.delete(key);
+                throw error;
+            });
+            flights.set(key, pending);
+            return pending;
+        },
+        stop() {
+            abort.abort();
+        },
+    };
+}

package/dist/runtime-startup-gate.js

@@ -77,6 +77,8 @@ export function createRuntimeStartupGate(limits, now = Date.now) {
                 claude: activeByRuntime.get("claude") ?? 0,
                 codex: activeByRuntime.get("codex") ?? 0,
                 kimi: activeByRuntime.get("kimi") ?? 0,
+                hermes: activeByRuntime.get("hermes") ?? 0,
+                opencode: activeByRuntime.get("opencode") ?? 0,
             },
         }),
     };

package/dist/runtimes/codex-app-server-runner.js

@@ -193,10 +193,20 @@ export function mapCodexNotification(method, params) {
                     type: "command_execution",
                     command: value.item.command,
                     ...(value.item.status === undefined ? {} : { status: value.item.status }),
+                    ...(typeof value.item.exitCode === "number" ? { exit_code: value.item.exitCode } : {}),
                     ...(value.item.aggregatedOutput == null ? {} : { aggregated_output: value.item.aggregatedOutput }),
                 },
             }];
     }
+    if (value.item.type === "fileChange" && Array.isArray(value.item.changes)) {
+        return [{
+                type: "diagnostic.file_change",
+                ...(value.item.status === undefined ? {} : { status: value.item.status }),
+                changes: value.item.changes.flatMap((change) => typeof change.path === "string"
+                    ? [{ path: change.path, ...(change.kind === undefined ? {} : { kind: change.kind }) }]
+                    : []),
+            }];
+    }
     return [];
 }
 async function readRunnerInput() {

package/dist/runtimes/hermes-models.js

@@ -0,0 +1,117 @@
+import { once } from "node:events";
+import { Readable, Writable } from "node:stream";
+import spawn from "cross-spawn";
+import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { augmentedPath } from "../runtime-path.js";
+const HERMES_MODEL_PROBE_TIMEOUT_MS = 8_000;
+function nonEmptyString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function selectOptions(options, category) {
+    const aliases = category === "model"
+        ? new Set(["model"])
+        : new Set(["reasoning", "effort", "thought level", "thinking level"]);
+    const matches = (options ?? []).filter((option) => (option.type === "select" && (option.category === category
+        || aliases.has(option.id.toLowerCase())
+        || aliases.has(option.name.toLowerCase()))));
+    if (matches.length !== 1)
+        return null;
+    const match = matches[0];
+    const values = match.options.flatMap((option) => "options" in option ? option.options : [option]);
+    return {
+        current: nonEmptyString(match.currentValue),
+        values: values.map((option) => ({ modelId: option.value, name: option.name })),
+    };
+}
+export function normalizeHermesModels(session) {
+    const modelConfig = selectOptions(session.configOptions, "model");
+    const effortConfig = selectOptions(session.configOptions, "thought_level");
+    const extension = session.models;
+    const rows = extension?.availableModels ?? extension?.available_models ?? modelConfig?.values ?? [];
+    const current = nonEmptyString(extension?.currentModelId)
+        ?? nonEmptyString(extension?.current_model_id)
+        ?? modelConfig?.current
+        ?? null;
+    const reasoning = [...new Set((effortConfig?.values ?? [])
+            .map((option) => nonEmptyString(option.modelId ?? option.model_id ?? option.id))
+            .filter((value) => value !== null))];
+    const seen = new Set();
+    return rows.flatMap((row) => {
+        const id = nonEmptyString(row.modelId ?? row.model_id ?? row.id);
+        if (id === null || seen.has(id))
+            return [];
+        seen.add(id);
+        return [{
+                id,
+                label: nonEmptyString(row.name) ?? id,
+                ...(id === current ? { default: true } : {}),
+                ...(reasoning.length > 0 ? { reasoning } : {}),
+            }];
+    });
+}
+async function stopChild(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = once(child, "close").then(() => undefined);
+    child.kill("SIGTERM");
+    let timer;
+    const graceful = await Promise.race([
+        closed.then(() => true),
+        new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
+    ]);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    if (!graceful && child.exitCode === null && child.signalCode === null) {
+        child.kill("SIGKILL");
+        await closed;
+    }
+}
+export async function listHermesModels(options = {}) {
+    const spawnProcess = options.spawnProcess ?? spawn;
+    const child = spawnProcess("hermes", ["acp"], {
+        cwd: process.cwd(),
+        env: { ...process.env, PATH: augmentedPath() },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (child.stdin === null || child.stdout === null || child.stderr === null)
+        return [];
+    child.stderr.resume();
+    const app = client({ name: "nowcrew-daemon-hermes-models" })
+        .onRequest(methods.client.session.requestPermission, () => ({
+        outcome: { outcome: "cancelled" },
+    }))
+        .onNotification(methods.client.session.update, () => undefined);
+    let timer;
+    try {
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const discovery = app.connectWith(stream, async (context) => {
+            await context.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: { name: "nowcrew-daemon", version: "1" },
+            });
+            const session = await context.request(methods.agent.session.new, {
+                cwd: process.cwd(),
+                mcpServers: [],
+            });
+            return normalizeHermesModels(session);
+        });
+        return await Promise.race([
+            discovery,
+            new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    void stopChild(child);
+                    resolve([]);
+                }, HERMES_MODEL_PROBE_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        await stopChild(child);
+    }
+}

package/dist/runtimes/hermes.js

@@ -0,0 +1,6 @@
+import spawn from "cross-spawn";
+import { probeKimiAcp } from "./kimi-acp-runner.js";
+/** Hermes and Kimi expose the same ACP initialize contract; execution policy stays provider-specific. */
+export function probeHermesAcp(options, spawnProcess = spawn) {
+    return probeKimiAcp({ ...options, provider: "hermes" }, spawnProcess);
+}