@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

package/skills/cosmic-build/scripts/resolve_output_path.py

@@ -34,7 +34,11 @@ def _app_context(app_root: str) -> dict:
     root = Path(app_root)
     context = _read_json(root / "_runtime" / "context.json")
     archive = _read_json(root / "archive.json")
-    app_code = str(context.get("appCode") or archive.get("appCode") or root.name).strip()
+    app_code = str(
+        context.get("appCode")
+        or archive.get("appCode")
+        or root.name
+    ).strip()
     configured_package = ""
     for source in (context, archive):
         for key in CONTEXT_PACKAGE_KEYS:
@@ -51,14 +55,21 @@ def _is_java_project(path: str | Path) -> bool:
     return root.is_dir() and (root / "src" / "main" / "java").is_dir()
 
 
-def _project_result(candidate: str, source: str, app_code: str) -> dict:
+def _project_result(candidate: str, source: str, app_code: str, prepare_source: bool = False) -> dict:
     root = Path(candidate).expanduser()
+    if prepare_source and inspect_config().get("status") == "disabled":
+        try:
+            (root / "src" / "main" / "java").mkdir(parents=True, exist_ok=True)
+        except OSError:
+            return {"projectRoot": None, "projectRootSource": source, "appCode": app_code,
+                    "errorCode": "PLUGIN_WORKSPACE_UNWRITABLE",
+                    "error": f"Cannot prepare source-only workspace at {root}; select a writable --java-project-root"}
     if not _is_java_project(root):
         return {
             "projectRoot": None,
             "projectRootSource": source,
             "errorCode": "PLUGIN_WORKSPACE_UNRESOLVED",
-            "error": f"{source} 缺少 src/main/java: {root}",
+            "error": f"{source} has no src/main/java: {root}",
             "appCode": app_code,
         }
     return {
@@ -70,13 +81,15 @@ def _project_result(candidate: str, source: str, app_code: str) -> dict:
 
 
 def _preset_app_local_java_workspace(app_root: str) -> bool:
-    """在编译关闭时预置应用内确定性的 Java 模块。
-
-    纯元数据工作区此前在此 fail-closed，把目录决策抛给用户提问 —— 首次报表交付
-    因此问过“类放哪”。compile=false 下交付以 `source_ready (compile skipped by
-    config)` 收口、全程不碰 Gradle，所以 appRoot 自身就是可靠的固定落点：按应用
-    隔离，创建之后后续每次都由第 5 级直接命中。编译开启或未决时预置不生效：
-    真实 Gradle 模块必须可解析。
+    """Create the deterministic in-app Java module when compilation is disabled.
+
+    A metadata-only workspace used to fail closed here and hand the directory
+    decision to a user question — a first report delivery asked where to put its
+    class. With compile=false the delivery completes as `source_ready (compile
+    skipped by config)` without touching Gradle, so the appRoot is a sound fixed
+    home: per-app, and picked up by rank 5 on every later run once created.
+    While compilation is enabled or undecided the preset stays off: a real
+    Gradle module must resolve.
     """
     if inspect_config().get("status") != "disabled":
         return False
@@ -90,20 +103,22 @@ def _preset_app_local_java_workspace(app_root: str) -> bool:
     return True
 
 
-def _resolve_project_root(app_root: str, cli_project_root: str | None = None) -> dict:
+def _resolve_project_root(app_root: str, cli_project_root: str | None = None, prepare_source: bool = False) -> dict:
     context = _read_json(Path(app_root) / "_runtime" / "context.json")
     app_code = _app_context(app_root)["appCode"]
     if cli_project_root:
-        return _project_result(cli_project_root, "显式 javaProjectRoot", app_code)
+        return _project_result(cli_project_root, "explicit javaProjectRoot", app_code, prepare_source)
     for key in CONTEXT_PROJECT_KEYS:
         candidate = str(context.get(key) or "").strip()
         if candidate:
             return _project_result(candidate, f"context.{key}", app_code)
-    # 绑定工程优先于 appconfig。appconfig.json 是机器级配置，其 pluginProjects 只以 appCode 为键，
-    # 因此同一个 appCode 从两个工程目录打开时共用一份映射：某次在另一个 checkout 执行过
-    # --save-plugin-project，之后该应用的插件就一直被送到那个目录，即便绑定的工程根本身就是 Java
-    # 模块——生成的报表插件因此落到了用户正在使用的工程之外。appconfig 面向的是“元数据工作区不是
-    # Java 模块”这一种情况，所以只有绑定工程根缺失或不是 Java 模块时才会走到它。
+    # The bound project outranks appconfig. appconfig.json is machine level and its pluginProjects
+    # map is keyed by appCode alone, so one appCode opened from two project directories shares one
+    # mapping: a --save-plugin-project run in another checkout kept sending later plugins there
+    # even when the bound project root was itself a Java module, which is how a generated report
+    # plugin landed outside the project the user was working in. appconfig is specified for the
+    # case where the metadata workspace is not the Java module, so it is reached only when the
+    # bound root is absent or is not one.
     metadata_project = str(context.get("projectRoot") or "").strip()
     if metadata_project and _is_java_project(metadata_project):
         return _project_result(metadata_project, "context.projectRoot", app_code)
@@ -123,10 +138,10 @@ def _resolve_project_root(app_root: str, cli_project_root: str | None = None) ->
         "projectRootSource": "unresolved",
         "errorCode": "PLUGIN_WORKSPACE_UNRESOLVED",
         "error": (
-            f"尚未给 appCode={app_code} 配置 Java 插件工程；应用本地预置目录仅在 "
-            "appconfig 中 compile=false 时生效。请执行 "
+            f"No Java plugin project is configured for appCode={app_code}, and the app-local "
+            "preset applies only while compile=false in appconfig. Configure one with "
             "appconfig_load.py --save-plugin-project "
-            f"{app_code} --plugin-project-root <moduleRoot>。"
+            f"{app_code} --plugin-project-root <moduleRoot>."
         ),
         "appCode": app_code,
     }
@@ -202,8 +217,13 @@ def _registry_type(root_dir: str, task_type: str) -> dict:
     return {}
 
 
-def resolve_output_path(app_root: str, task_type: str, project_root: str | None = None) -> dict:
-    project_resolution = _resolve_project_root(app_root, cli_project_root=project_root)
+def resolve_output_path(app_root: str, task_type: str, project_root: str | None = None,
+                        prepare_source: bool = False, source_directory: str | None = None) -> dict:
+    registry_type = _registry_type(_find_root_dir(), task_type)
+    if not registry_type.get("outputDir"):
+        return {"projectRoot": None, "packagePath": None, "outputDir": None, "classSuffix": None,
+                "errorCode": "PLUGIN_TYPE_UNSUPPORTED", "error": f"Unknown plugin type: {task_type}"}
+    project_resolution = _resolve_project_root(app_root, cli_project_root=project_root, prepare_source=prepare_source)
     resolved_project = project_resolution.get("projectRoot")
     if not resolved_project:
         return {
@@ -212,17 +232,31 @@ def resolve_output_path(app_root: str, task_type: str, project_root: str | None
             "outputDir": None,
             "classSuffix": None,
         }
-    base_path = _resolve_base_package_path(resolved_project, app_root=app_root)
-    registry_type = _registry_type(_find_root_dir(), task_type)
     type_dir = str(registry_type.get("outputDir") or "").strip("/")
-    package_path = "/".join((base_path, type_dir)) if base_path and type_dir else None
+    if source_directory:
+        java_root = (Path(resolved_project) / "src" / "main" / "java").resolve()
+        directory = Path(source_directory).expanduser().resolve()
+        try:
+            relative = directory.relative_to(java_root)
+        except ValueError:
+            return {"projectRoot": None, "packagePath": None, "outputDir": None, "classSuffix": None,
+                    "errorCode": "PLUGIN_WORKSPACE_UNRESOLVED", "error": "Source directory must be inside the selected module src/main/java"}
+        if any(not re.fullmatch(r"[A-Za-z_$][A-Za-z0-9_$]*", part) for part in relative.parts):
+            return {"projectRoot": None, "packagePath": None, "outputDir": None, "classSuffix": None,
+                    "errorCode": "PLUGIN_PACKAGE_UNRESOLVED", "error": "Source directory must identify a valid Java package"}
+        base_path = _convention_package_root(_app_context(app_root)["appCode"])
+        package_path = "/".join(relative.parts) if relative.parts else "/".join((base_path, type_dir)) if base_path and type_dir else None
+    else:
+        base_path = _resolve_base_package_path(resolved_project, app_root=app_root)
+        package_path = "/".join((base_path, type_dir)) if base_path and type_dir else None
     result = {
         "projectRoot": resolved_project,
         "projectRootSource": project_resolution.get("projectRootSource"),
         "errorCode": "0",
         "packagePath": package_path,
         "outputDir": f"src/main/java/{package_path}" if package_path else None,
-        # 未提供 className 时编码阶段追加的后缀，供调用方查找按约定本应创建的那个类。
+        # The suffix the coding step appends when no className is supplied, so a caller can look
+        # for the class that convention would have created.
         "classSuffix": str(registry_type.get("classSuffix") or "").strip() or None,
     }
     if not type_dir:

package/skills/cosmic-build/scripts/run_java_tests.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Run the bound Gradle Java test task and report observed tests, without archiving plugins."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+from compile_plugin_source import compile_handoff, inspect_compile_environment, parse_compiler_errors
+
+
+# The observer lives only for this invocation. Project build files and test assertions are unchanged.
+OBSERVER = r'''
+import groovy.json.JsonOutput
+import org.gradle.api.tasks.testing.Test
+import org.gradle.api.tasks.testing.TestResult
+
+def receipt = new File(System.getenv('APP_BUILD_TEST_RECEIPT'))
+def observed = [available: false]
+def persist = { receipt.text = JsonOutput.toJson(observed) }
+gradle.projectsEvaluated {
+    def owner = gradle.rootProject.allprojects.find {
+        it.projectDir.canonicalPath == new File(System.getenv('APP_BUILD_TEST_PROJECT')).canonicalPath
+    }
+    def task = owner?.tasks?.findByName('test')
+    if (!(task instanceof Test)) {
+        observed.reason = 'The bound module has no Gradle Test task named test'
+        persist()
+        throw new GradleException(observed.reason)
+    }
+    observed.available = true
+    observed.task = task.path
+    observed.reportsDirectory = task.reports.junitXml.outputLocation.get().asFile.absolutePath
+    observed.counts = [total: 0, passed: 0, failed: 0, skipped: 0]
+    observed.failures = []
+    persist()
+    if (System.getenv('APP_BUILD_RERUN_TESTS') == '1') {
+        task.outputs.upToDateWhen { false }
+        task.outputs.doNotCacheIf('Explicit app-build test rerun') { true }
+    }
+    task.afterTest { descriptor, result ->
+        if (result.resultType == TestResult.ResultType.FAILURE) {
+            observed.failureCount = (observed.failureCount ?: 0) + 1
+            if (observed.failures.size() < 20) {
+                observed.failures.add([className: descriptor.className, name: descriptor.name,
+                    exceptions: result.exceptions.take(5).collect { exception ->
+                        def trace = new StringWriter()
+                        exception.printStackTrace(new PrintWriter(trace))
+                        def text = trace.toString()
+                        [type: exception.class.name, message: exception.message?.take(4000),
+                         stackTrace: text.take(8000), truncated: text.length() > 8000]
+                    }])
+            }
+        }
+    }
+    task.afterSuite { descriptor, result ->
+        if (descriptor.parent == null) {
+            observed.counts = [total: result.testCount, passed: result.successfulTestCount,
+                               failed: result.failedTestCount, skipped: result.skippedTestCount]
+            persist()
+        }
+    }
+    gradle.taskGraph.afterTask { current, state ->
+        if (current.path == task.path) {
+            observed.state = [skipped: state.skipped, skipMessage: state.skipMessage,
+                              upToDate: state.upToDate, noSource: state.noSource,
+                              failure: state.failure?.toString()]
+            persist()
+        }
+    }
+}
+'''
+
+
+def run_tests(project_root: str, *, tests: list[str] | None = None, timeout_sec: int = 300,
+              rerun: bool = False) -> dict:
+    environment = inspect_compile_environment(project_root)
+    if environment.get('status') != 'ready':
+        return {'status': False, 'outcome': 'environment-unavailable', 'errorCode': 'JAVA_TEST_ENVIRONMENT_UNAVAILABLE',
+                'buildEnvironment': environment}
+    project = Path(project_root).resolve()
+    task = f"{environment['module']}:test" if environment['module'] else ':test'
+    command = [environment['wrapperPath'], task, '--console=plain']
+    for pattern in tests or []:
+        if not pattern.strip() or any(character in pattern for character in '\r\n\0'):
+            return {'status': False, 'outcome': 'invalid-input', 'errorCode': 'JAVA_TEST_SELECTOR_INVALID'}
+        command += ['--tests', pattern]
+    env = {**os.environ, 'JAVA_HOME': environment['javaHome'], 'APP_BUILD_TEST_PROJECT': str(project),
+           'APP_BUILD_RERUN_TESTS': '1' if rerun else '0'}
+    with tempfile.TemporaryDirectory(prefix='app-build-java-tests-') as temporary:
+        directory = Path(temporary)
+        observer = directory / 'observe.gradle'
+        receipt = directory / 'result.json'
+        observer.write_text(OBSERVER, encoding='utf-8')
+        env['APP_BUILD_TEST_RECEIPT'] = str(receipt)
+        try:
+            completed = subprocess.run([*command, '--init-script', str(observer)], cwd=environment['gradleRoot'],
+                                       env=env, capture_output=True, text=True, timeout=max(1, timeout_sec), check=False)
+            output = completed.stdout + completed.stderr
+            exit_code = completed.returncode
+        except subprocess.TimeoutExpired as error:
+            output = ''.join(value.decode('utf-8', 'replace') if isinstance(value, bytes) else value or ''
+                             for value in (error.stdout, error.stderr))
+            exit_code = None
+        observed = json.loads(receipt.read_text(encoding='utf-8')) if receipt.is_file() else {}
+    log = project / '.temp' / 'plugin-tests' / (hashlib.sha256(output.encode()).hexdigest() + '.log')
+    log.parent.mkdir(parents=True, exist_ok=True)
+    log.write_text(output, encoding='utf-8')
+    counts = observed.get('counts', {'total': 0, 'passed': 0, 'failed': 0, 'skipped': 0})
+    state = observed.get('state', {})
+    outcome = ('timed-out' if exit_code is None else
+               'task-unavailable' if observed.get('available') is False else
+               'test-failed' if counts['failed'] or observed.get('failureCount') else
+               'build-failed' if exit_code != 0 or state.get('failure') else
+               'up-to-date' if state.get('upToDate') else
+               'no-tests' if state.get('noSource') else
+               'skipped' if state.get('skipped') else
+               'no-tests' if not counts['total'] else
+               'skipped' if counts['skipped'] == counts['total'] else 'passed')
+    result = {'status': outcome == 'passed', 'outcome': outcome,
+              'errorCode': '0' if outcome == 'passed' else 'JAVA_TEST_' + outcome.upper().replace('-', '_'),
+              'projectRoot': str(project), 'gradleRoot': environment['gradleRoot'], 'javaHome': environment['javaHome'],
+              'task': task, 'command': command, 'exitCode': exit_code, 'selectors': tests or [],
+              'rerunTests': rerun, 'counts': counts, 'taskState': state,
+              'failures': observed.get('failures', []), 'failureCount': observed.get('failureCount', 0),
+              'reportsDirectory': observed.get('reportsDirectory'), 'logPath': str(log),
+              'diagnostics': parse_compiler_errors(output),
+              'evidenceScope': 'Observed target Gradle test events only; no plugin registration, runtime activation or business coverage beyond the executed tests is established'}
+    if observed.get('reason'):
+        result['message'] = observed['reason']
+    if result['failureCount'] > len(result['failures']):
+        result['failuresTruncated'] = True
+    return result
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    target = parser.add_mutually_exclusive_group(required=True)
+    target.add_argument('--project-root', help='Existing bound Java module root')
+    target.add_argument('--handoff', help='Reuse the verified Java module from a prepared handoff')
+    parser.add_argument('--tests', action='append', help='Gradle test class/method filter; repeat for multiple selectors')
+    parser.add_argument('--rerun-tests', action='store_true', help='Execute the selected test task again; keep compilation incremental')
+    parser.add_argument('--timeout-sec', type=int, default=300)
+    args = parser.parse_args()
+    try:
+        result = run_tests(compile_handoff(args.handoff)['projectRoot'] if args.handoff else args.project_root,
+                           tests=args.tests, timeout_sec=args.timeout_sec, rerun=args.rerun_tests)
+    except (ValueError, OSError) as error:
+        result = {'status': False, 'outcome': 'environment-unavailable',
+                  'errorCode': getattr(error, 'code', 'JAVA_TEST_ENVIRONMENT_UNAVAILABLE'),
+                  'message': str(error), **getattr(error, 'details', {})}
+    print(json.dumps(result, ensure_ascii=False))
+    return 0 if result.get('status') is True else 2
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

package/skills/cosmic-build/scripts/sync_generated_locale_assets.py

@@ -24,6 +24,23 @@ ZH_ROOT = APP_BUILD_ROOT / ".locales" / "zh"
 # unit: schema -> direct CLI normalizer/readback -> artifact validator.  The two
 # report SKILL.md files are deliberately absent because their prose is localized.
 GENERATED_FAMILIES: dict[str, tuple[str, ...]] = {
+    # 报表修复仅同步共用示例、改道实现和测试。cmd_apps.py、validators.py
+    # 保留人工中文提示，修复须精准移植并在各自入口运行同一套行为回归。
+    "report-repair-v1": (
+        "examples/java-rules/CosmicReportFilters.java",
+        "skills/cosmic-meta-api/scripts/_core/cmd_metaops.py",
+        "skills/cosmic-meta-api/scripts/_core/property_reroute.py",
+        "scripts/test/test_cosmic_sdk_examples.py",
+        "scripts/test/test_menu_creation_closure.py",
+        "scripts/test/test_property_reroute.py",
+        # 新 API 逐项回执与 no_op 的执行回归必须跟随两侧 cmd_metaops 同步。
+        "skills/cosmic-meta-api/scripts/test/test_metadata_unchanged_fail_closed.py",
+    ),
+    # The localized executable had drifted behind canonical list property support.
+    "list-execution-v1": (
+        "scripts/configure_list.py",
+        "skills/cosmic-meta-api/scripts/_core/cmd_listui.py",
+    ),
     # Batch recovery must not differ between the canonical and zh entry.
     # These files publish machine results and use the same locale-aware runtime.
     "execution-recovery-v1": (
@@ -40,6 +57,9 @@ GENERATED_FAMILIES: dict[str, tuple[str, ...]] = {
         "skills/cosmic-meta-api/scripts/_core/cmd_rules.py",
         "skills/cosmic-meta-api/scripts/_core/formatters.py",
         "skills/cosmic-meta-api/scripts/test/test_build_receipt_resume.py",
+        "skills/cosmic-meta-api/scripts/test/test_run_batch_verification_evidence.py",
+        "skills/cosmic-meta-api/scripts/test/test_run_batch_post_build_recovery.py",
+        "skills/cosmic-meta-api/scripts/test/test_build_configuration_readback.py",
         "skills/cosmic-meta-api/scripts/test/test_creation_identity_boundary.py",
         "scripts/test/test_rule_batch_evidence.py",
     ),
@@ -192,6 +212,11 @@ GENERATED_FAMILIES: dict[str, tuple[str, ...]] = {
         "scripts/prepare_plugin_handoff.py",
         "scripts/java_source.py",
         "scripts/compile_plugin_source.py",
+        "scripts/run_java_tests.py",
+        "scripts/test/test_java_toolchain_feedback.py",
+        "scripts/dcs_code_gate.py",
+        # 门禁按脚本所在目录读取规则目录，两侧必须带同一依赖资产。
+        "scripts/dcs-rule-catalog.json",
         "scripts/plugin_source_gate.py",
         "scripts/java_write_guard.js",
         "scripts/platform_api_contract.py",
@@ -202,6 +227,8 @@ GENERATED_FAMILIES: dict[str, tuple[str, ...]] = {
     # JSON pointer queries are read-only and language-neutral. Mirror the single implementation
     # and its CLI regression to the zh skill so either locale can inspect the same native handoff.
     "plugin-handoff-query-v1": (
+        "scripts/test_environment.py",
+        "scripts/test/test_test_environment.py",
         "scripts/query_plugin_handoff.py",
         "scripts/test/test_query_plugin_handoff.py",
     ),
@@ -229,6 +256,7 @@ GENERATED_FAMILIES: dict[str, tuple[str, ...]] = {
         "scripts/test/fixtures/java_context_booking_native.json",
         "scripts/test/test_guide_skeleton_contract.py",
         "scripts/test/test_compile_plugin_source.py",
+        "scripts/test/test_dcs_code_gate.py",
         "scripts/test/test_plugin_source_gate.py",
         "scripts/test/test_platform_api_contract.py",
         "scripts/test/test_java_source.py",

package/skills/cosmic-build/scripts/test/fixtures/ReportSdkCheck.java

@@ -1,36 +1,16 @@
 import kd.bos.algo.*;
-import kd.bos.designer.property.setting.TypedReportFilterFields;
-import kd.bos.metadata.entity.commonfield.ComboField;
-import kd.bos.metadata.entity.commonfield.ComboItem;
-import kd.bos.metadata.entity.commonfield.DateField;
-import kd.bos.metadata.entity.commonfield.DateRangeField;
-import kd.bos.metadata.entity.businessfield.BasedataField;
-import kd.bos.dataentity.entity.LocaleString;
 import java.util.*;
 import java.math.BigDecimal;
 import java.util.concurrent.*;
 
 public class ReportSdkCheck {
-    // Isolate logging only. All metadata, DataSet joins and aggregates are actual SDK objects.
+    // Isolate logging only. All DataSet joins and aggregates are actual SDK objects.
     public static class TestLogFactory extends kd.bos.logging.LogFactory {
         protected kd.bos.logging.Log _getLog(String name) {
             return (kd.bos.logging.Log) java.lang.reflect.Proxy.newProxyInstance(kd.bos.logging.Log.class.getClassLoader(),
                 new Class[]{kd.bos.logging.Log.class}, (proxy, method, args) -> method.getReturnType() == boolean.class ? false : null);
         }
     }
-    static void fields() {
-        BasedataField source = new BasedataField(); source.setKey("supplier");source.setBaseEntityId("bd_supplier");source.setDisplayProp("name");
-        kd.bos.metadata.entity.commonfield.Field<?> copied = TypedReportFilterFields.create(source,"67");
-        if (copied == source || !"bd_supplier".equals(((BasedataField)copied).getBaseEntityId())) throw new AssertionError("reference");
-        ComboField combo = new ComboField();combo.setItems(Arrays.asList(new ComboItem(0,new LocaleString("zero"),"0")));
-        ComboField cloned = (ComboField)TypedReportFilterFields.create(combo,"67");
-        if (cloned.getItems()==combo.getItems() || !"0".equals(cloned.getItems().get(0).getValue())) throw new AssertionError("enum");
-        if (!(TypedReportFilterFields.create(new DateField(),"13") instanceof DateRangeField)) throw new AssertionError("range");
-        if (!(TypedReportFilterFields.create(new DateField(),"105") instanceof DateField)) throw new AssertionError("date");
-        source.setOrgFieldId("source-org-id");
-        try { TypedReportFilterFields.create(source,"67");throw new AssertionError("organization dependency silently lost"); }
-        catch(IllegalArgumentException expected) { }
-    }
     static RowMeta headersMeta() {
         return new RowMeta(new Field("id",DataType.LongType),new Field("supplier",DataType.StringType),
             new Field("bill_date",DataType.DateType),new Field("base_amount",DataType.createBigDecimalType(18,2)));
@@ -53,7 +33,6 @@ public class ReportSdkCheck {
         if(count!=2) throw new AssertionError("supplier membership");result.close();
     }
     public static void main(String[] args) throws Exception {
-        fields();
         ExecutorService executor=kd.bos.threads.ThreadPools.newExecutorService("report-check",1);
         java.util.concurrent.atomic.AtomicBoolean completed=new java.util.concurrent.atomic.AtomicBoolean();
         try { executor.submit(() -> { try(AlgoContext context=Algo.newContext()) { amounts();completed.set(true); } }).get(20,TimeUnit.SECONDS); } catch(Exception error) { error.printStackTrace();System.exit(2); }