@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

package/skills/cosmic-build/scripts/test/test_delivery_stage_boundary.py

@@ -17,7 +17,7 @@ def test_root_routes_delivery_to_the_session_boundary_reference() -> None:
     assert "Repeat `--form-number`" in delivery
     assert "after the final write" in delivery
     assert "historical forms" in delivery
-    assert "Tool output alone does not deliver a card" in delivery
+    assert "Ordinary renderer stdout alone does not deliver a card" in delivery
     assert "include it verbatim in the final assistant response" in delivery
     assert "Remaining executable implementation" in root
 

package/skills/cosmic-build/scripts/test/test_direct_cli_architecture.py

@@ -6,6 +6,8 @@ from pathlib import Path
 
 
 ROOT = Path(__file__).resolve().parents[2]
+if ROOT.name == "zh" and ROOT.parent.name == ".locales":
+    ROOT = ROOT.parent.parent
 SKILLS = (
     ROOT / "SKILL.md",
     ROOT / ".locales/zh/SKILL.md",

package/skills/cosmic-build/scripts/test/test_http_client.py

@@ -234,6 +234,12 @@ class IsTransientTest(unittest.TestCase):
         import _http_client as m
         self.assertTrue(m._is_transient(urllib.error.URLError("timed out")))
 
+    def test_http_gateway_errors_only_are_transient(self):
+        import urllib.error
+        for code in (400, 401, 403, 404, 500, 502, 503, 504):
+            self.assertEqual(_http_client._is_transient(urllib.error.HTTPError('https://example.test', code, '', {}, None)),
+                             code in (502, 503, 504))
+
     def test_non_transient_not_matched(self):
         import _http_client as m
         self.assertFalse(m._is_transient(ValueError("bad input")))

package/skills/cosmic-build/scripts/test/test_java_toolchain_feedback.py

@@ -0,0 +1,206 @@
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+SCRIPTS = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SCRIPTS))
+import compile_plugin_source as compiler
+from plugin_target_sdk import TargetSdkError, verify_target_sdk
+from run_java_tests import run_tests
+
+
+def test_configuration_gaps_survive_sdk_and_compile_without_writes(tmp_path, monkeypatch):
+    config = tmp_path / 'appconfig.json'
+    config.write_text(json.dumps({'compile': True, 'autoregister': False, 'password': 'must-not-return'}))
+    monkeypatch.setenv('KD_APPCONFIG', str(config))
+    before = config.read_bytes()
+    facts = compiler.inspect_compile_environment(str(tmp_path))
+    assert set(facts['missing']) == {'GRADLE_ROOT', 'JAVA_HOME'}
+    assert facts['invalid'] == []
+    assert facts['configPath'] == str(config)
+    assert facts['compile'] is True and facts['autoregister'] is False
+    assert facts['configCommands']['status'][-1] == '--status'
+    assert 'must-not-return' not in json.dumps(facts)
+    with pytest.raises(TargetSdkError) as error:
+        verify_target_sdk(str(tmp_path), {})
+    assert error.value.details['buildEnvironment'] == facts
+    source = tmp_path / 'src/main/java/demo/Work.java'
+    source.parent.mkdir(parents=True)
+    source.write_text('package demo; public class Work {}')
+    with pytest.raises(compiler.CompileError) as error:
+        compiler.compile_source(tmp_path, source, 'Work', 5, app_root=tmp_path / 'app',
+                                plugin_type='task', form_number='example', operation_keys=[], description='work')
+    assert error.value.details['buildEnvironment'] == facts
+    result = run_tests(str(tmp_path))
+    assert result['outcome'] == 'environment-unavailable'
+    assert result['buildEnvironment'] == facts
+    assert config.read_bytes() == before
+    assert not (tmp_path / '.temp').exists()
+
+
+def test_missing_decisions_and_invalid_paths_remain_distinct(tmp_path, monkeypatch):
+    config = tmp_path / 'appconfig.json'
+    monkeypatch.setenv('KD_APPCONFIG', str(config))
+    result = compiler.inspect_compile_environment(str(tmp_path))
+    assert result['status'] == 'missing'
+    assert result['missing'] == ['compile']
+    config.write_text(json.dumps({'compile': True, 'GRADLE_ROOT': str(tmp_path / 'missing'), 'JAVA_HOME': str(tmp_path / 'jdk')}))
+    result = compiler.inspect_compile_environment(str(tmp_path))
+    assert set(result['invalid']) == {'GRADLE_ROOT', 'JAVA_HOME'}
+    assert result['missing'] == []
+    config.write_text('{"compile":false}')
+    result = run_tests(str(tmp_path))
+    assert result['status'] is False
+    assert result['buildEnvironment']['status'] == 'disabled'
+    assert not (tmp_path / '.temp').exists()
+
+
+@pytest.mark.parametrize('required,found,reason', [
+    ('required: String,int', 'found: String', 'reason: actual and formal argument lists differ in length'),
+    ('需要: String,int', '找到: String', '原因: 实际参数列表和形式参数列表长度不同'),
+])
+def test_argument_diagnostics_keep_source_overload_and_reason(required, found, reason):
+    result = compiler.parse_compiler_errors('\n'.join([
+        '/project/src/Caller.java:7: error: method apply cannot be applied to given types;',
+        '  Helper.apply("x");', '        ^', required, found, reason,
+        '  constructor Helper.Helper(String) is not applicable', '1 error', 'BUILD FAILED']))
+    assert len(result) == 1
+    for detail in ['Helper.apply("x");', '^', required, found, reason,
+                   'constructor Helper.Helper(String) is not applicable']:
+        assert detail in result[0]['detail']
+    assert 'BUILD FAILED' not in result[0]['detail']
+    assert '1 error' not in result[0]['detail']
+
+
+def test_diagnostic_bounds_keep_later_helper_file_and_exact_count():
+    text = '\n'.join([f'/project/First.java:{i}: error: first {i}' for i in range(1, 41)] +
+                     ['/project/Helper.java:8: error: missing helper'])
+    mine, others, dropped = compiler.collect_compiler_errors(text)
+    assert mine == []
+    assert len(others) == compiler.DIAGNOSTIC_LIMIT
+    assert len(others) + dropped == 41
+    assert any(item['file'].endswith('Helper.java') for item in others)
+    result = compiler.parse_compiler_errors('/project/Call.java:2: error: overload\n' + '\n'.join(f'candidate {i}' for i in range(80)))
+    assert len(result[0]['detail']) == 40
+    assert result[0]['detailTruncated'] is True
+
+
+@pytest.fixture
+def java_project(tmp_path, monkeypatch):
+    gradle = os.environ.get('APP_BUILD_TEST_GRADLE')
+    home = os.environ.get('JAVA_HOME')
+    if not gradle or not home:
+        pytest.skip('Set APP_BUILD_TEST_GRADLE and JAVA_HOME to run the real Gradle integration')
+    root = tmp_path / 'real gradle project'
+    module = root / 'code' / 'app'
+    library = root / 'code' / 'library'
+    for directory in [module, library]:
+        (directory / 'src/main/java/sample').mkdir(parents=True)
+    (module / 'src/test/java/sample').mkdir(parents=True)
+    wrapper = root / ('gradlew.bat' if os.name == 'nt' else 'gradlew')
+    shutil.copy2(gradle, wrapper)
+    # The installed Gradle launcher resolves its libraries relative to its own path.
+    if os.name == 'nt':
+        wrapper.write_text('@echo off\r\ncall "' + gradle + '" %*\r\n')
+    else:
+        wrapper.write_text('#!/bin/sh\nexec "' + gradle.replace('"', '\\"') + '" "$@"\n')
+        wrapper.chmod(0o755)
+    (root / 'settings.gradle').write_text("include(':app', ':library')\nproject(':app').projectDir=new File('code/app')\nproject(':library').projectDir=new File('code/library')\n")
+    (root / 'gradle.properties').write_text('org.gradle.daemon=false\n')
+    (root / 'build.gradle').write_text("allprojects { apply plugin: 'java' }\n")
+    junit = Path(gradle).resolve().parents[1] / 'lib' / 'junit-4.13.2.jar'
+    hamcrest = next((Path(gradle).resolve().parents[1] / 'lib').glob('hamcrest-core-*.jar'))
+    assert junit.is_file()
+    (module / 'build.gradle').write_text("dependencies { implementation project(':library'); testImplementation files(" +
+                                       json.dumps(str(junit)) + ', ' + json.dumps(str(hamcrest)) + ') }\n')
+    (library / 'src/main/java/sample/Shared.java').write_text('package sample; public class Shared { public static int value() { return 7; } }')
+    (module / 'src/main/java/sample/Caller.java').write_text('package sample; public class Caller { public int value() { return Shared.value(); } }')
+    test = module / 'src/test/java/sample/CallerTest.java'
+    test.write_text('package sample; import org.junit.Test; import static org.junit.Assert.*; public class CallerTest { @Test public void actualProductionMethod() { assertEquals(7, new Caller().value()); } }')
+    config = tmp_path / 'appconfig.json'
+    config.write_text(json.dumps({'compile': True, 'autoregister': False, 'GRADLE_ROOT': str(root), 'JAVA_HOME': home}))
+    monkeypatch.setenv('KD_APPCONFIG', str(config))
+    return root, module, library, test
+
+
+def test_real_multi_module_tests_report_pass_failure_and_keep_assertions(java_project):
+    root, module, library, test = java_project
+    original = test.read_bytes()
+    passed = run_tests(str(module), rerun=True)
+    assert passed['status'] is True, passed
+    assert passed['counts'] == {'total': 1, 'passed': 1, 'failed': 0, 'skipped': 0}
+    assert passed['task'] == ':app:test'
+    source = library / 'src/main/java/sample/Shared.java'
+    source.write_text(source.read_text().replace('return 7', 'return 8'))
+    failed = run_tests(str(module), rerun=True)
+    assert failed['status'] is False and failed['outcome'] == 'test-failed', failed
+    assert failed['counts']['failed'] == 1
+    assert failed['failures'][0]['className'] == 'sample.CallerTest'
+    assert failed['failures'][0]['name'] == 'actualProductionMethod'
+    assert 'expected:<7> but was:<8>' in json.dumps(failed['failures'])
+    assert test.read_bytes() == original
+    assert not (module / 'archive.json').exists()
+    assert not list((module / '.temp').glob('*-gate'))
+
+
+def test_real_no_tests_skipped_missing_task_and_build_failure_are_not_pass(java_project):
+    root, module, library, test = java_project
+    assert run_tests(str(library), rerun=True)['outcome'] == 'no-tests'
+    build = module / 'build.gradle'
+    original = build.read_text()
+    build.write_text(original + '\ntest.enabled=false\n')
+    assert run_tests(str(module), rerun=True)['outcome'] == 'skipped'
+    root_build = root / 'build.gradle'
+    root_original = root_build.read_text()
+    root_build.write_text("project(':library') { apply plugin: 'java' }\n")
+    build.write_text('')
+    assert run_tests(str(module))['outcome'] == 'task-unavailable'
+    root_build.write_text(root_original)
+    build.write_text(original)
+    source = library / 'src/main/java/sample/Shared.java'
+    source.write_text(source.read_text().replace('return 7', 'return absent'))
+    result = run_tests(str(module), rerun=True)
+    assert result['status'] is False and result['outcome'] == 'build-failed'
+    assert result['counts']['total'] == 0
+    assert any('Shared.java' in item['file'] for item in result['diagnostics'])
+
+
+def test_real_unmatched_filter_timeout_and_up_to_date_do_not_claim_pass(java_project):
+    root, module, library, test = java_project
+    assert run_tests(str(module), rerun=True)['status'] is True
+    assert run_tests(str(module))['outcome'] == 'up-to-date'
+    assert run_tests(str(module), tests=['sample.Absent'], rerun=True)['status'] is False
+    build = module / 'build.gradle'
+    build.write_text(build.read_text() + '\ntest.doFirst { Thread.sleep(5000) }\n')
+    result = run_tests(str(module), timeout_sec=1, rerun=True)
+    assert result['status'] is False and result['outcome'] == 'timed-out'
+
+
+def test_config_diagnostics_reach_native_single_and_batch_cli(tmp_path, monkeypatch):
+    config = tmp_path / 'appconfig.json'
+    config.write_text('{"compile":true}')
+    monkeypatch.setenv('KD_APPCONFIG', str(config))
+    entries = []
+    for name in ['First', 'Second']:
+        source = tmp_path / 'src/main/java/demo' / (name + '.java')
+        source.parent.mkdir(parents=True, exist_ok=True)
+        source.write_text('package demo; public class ' + name + ' {}')
+        entries.append({'sourcePath': str(source), 'className': name, 'type': 'task',
+                        'formNumber': 'example', 'operationKeys': [], 'description': 'test'})
+    batch = tmp_path / 'sources.json'
+    batch.write_text(json.dumps(entries))
+    common = [sys.executable, str(SCRIPTS / 'compile_plugin_source.py'), '--project-root', str(tmp_path), '--app-root', str(tmp_path / 'app')]
+    runs = [subprocess.run([*common, '--sources-file', str(batch)], capture_output=True, text=True),
+            subprocess.run([*common, '--source-path', entries[0]['sourcePath'], '--class-name', 'First', '--plugin-type', 'task', '--form-number', 'example', '--description', 'test'], capture_output=True, text=True)]
+    assert all(run.returncode == 2 for run in runs)
+    batch_result, single_result = [json.loads(run.stdout) for run in runs]
+    for result in [*batch_result['results'], single_result]:
+        assert result['errorCode'] == 'PLUGIN_COMPILE_CONFIG_UNAVAILABLE'
+        assert set(result['buildEnvironment']['missing']) == {'GRADLE_ROOT', 'JAVA_HOME'}
+        assert result['buildEnvironment']['configPath'] == str(config)
+    assert config.read_text() == '{"compile":true}'

package/skills/cosmic-build/scripts/test/test_kd_api.py

@@ -279,6 +279,27 @@ if __name__ == "__main__":
 
 
 class WriteTransportBoundaryTest(unittest.TestCase):
+    def test_gateway_get_retries_are_bounded_and_writes_never_replay(self):
+        # 保留真实 facade 和 retry_call，仅替换网络传输边界。
+        for code in (502, 503, 504):
+            with mock.patch.object(_http_client, 'http_get_json', side_effect=[_http_error(code), {'status': True}]) as transport, \
+                    mock.patch.object(_http_client.time, 'sleep'):
+                result = kd_api._request_once('https://example.test/read', {}, 'fixture',
+                    method='GET', body=None, params=None, style='kapi')
+                self.assertTrue(result['status'])
+                self.assertEqual(transport.call_count, 2)
+            with mock.patch.object(_http_client, 'http_get_json', side_effect=_http_error(code)) as transport, \
+                    mock.patch.object(_http_client.time, 'sleep'):
+                with self.assertRaises(urllib.error.HTTPError):
+                    kd_api._request_once('https://example.test/read', {}, 'fixture',
+                        method='GET', body=None, params=None, style='kapi')
+                self.assertEqual(transport.call_count, 3)
+            with mock.patch.object(_http_client, 'http_post_json', side_effect=_http_error(code)) as transport:
+                with self.assertRaises(urllib.error.HTTPError):
+                    kd_api._request_once('https://example.test/write', {}, 'fixture',
+                        method='POST', body={}, params=None, style='kapi')
+                self.assertEqual(transport.call_count, 1)
+
     def test_lost_post_response_is_not_replayed_but_get_can_retry(self):
         import http.client
         import socket

package/skills/cosmic-build/scripts/test/test_list_configuration_closure.py

@@ -661,3 +661,187 @@ def test_empty_list_mutation_cannot_claim_verified_noop_or_discover_identity(con
     assert result["errorCode"] == "LIST_CONFIGURATION_INPUT_REQUIRED"
     assert result["mutation"]["outcome"] == "failed_preflight"
     resolve.assert_not_called()
+
+
+@pytest.fixture
+def column_properties(monkeypatch):
+    """Stateful boundary; actual list compiler and real captured declarations are exercised."""
+    import copy
+    declarations = json.loads((Path(__file__).parent / "fixtures/list_column_property_declarations.json").read_text())
+    state = {"values": {}, "writes": [], "adds": [], "existing": True, "family": "integer", "fieldType": "IntegerField", "dropWrite": False}
+    def schema(*args):
+        return _schema([{"key": "typed_column", "listFieldId": "value"}] if state["existing"] else [])
+    def add(*args, **kwargs):
+        state["adds"].extend(kwargs["ops"])
+        state["existing"] = True
+        return {"status": True, "errorCode": "0"}
+    def set_values(_cfg, _token, _form, key, values):
+        state["writes"].append((key, copy.deepcopy(values)))
+        if not state["dropWrite"]:
+            state["values"].update(values)
+        return {"status": True, "errorCode": "0"}
+    monkeypatch.setattr(LISTUI, "_resolve_form_id", lambda *args: "form-id")
+    monkeypatch.setattr(LISTUI, "do_list_elements", lambda *args, **kwargs: {"status": True, "data": [{"key": "value", "name": "测试字段", "type": state["fieldType"]}]})
+    monkeypatch.setattr(LISTUI, "do_get_form_schema", schema)
+    monkeypatch.setattr(LISTUI, "do_load_full_metadata", lambda *args: _metadata())
+    monkeypatch.setattr(LISTUI, "do_get_entity_type", lambda *args: _entity_type("value"))
+    monkeypatch.setattr(LISTUI, "do_get_property_schema", lambda *args: {"status": True, "data": copy.deepcopy(declarations[state["family"]])})
+    monkeypatch.setattr(LISTUI, "do_get_properties", lambda *args: {"status": True, "data": copy.deepcopy(state["values"])})
+    monkeypatch.setattr(LISTUI, "do_set_properties", set_values)
+    monkeypatch.setattr(METAOPS, "do_modify_meta", add)
+    return state
+
+
+@pytest.mark.parametrize("field_type,family,properties,expected", [
+    *[(kind, "integer", {"汇总方式": "合计", "为零显示": True}, {"Summary": 1, "ZeroShow": True}) for kind in
+      ["IntegerField", "BigIntField", "DecimalField", "AmountField", "QtyField", "PriceField"]],
+    *[(kind, "date", {"格式化": "yyyy-MM-dd", "Mask": "yyyy-MM-dd"}, {"DisplayFormatString": "yyyy-MM-dd", "Mask": "yyyy-MM-dd"}) for kind in
+      ["DateField", "DateTimeField", "CreateDateField", "ModifyDateField"]],
+    *[(kind, "combo", {"ShowStyle": 0, "Editable": True}, {"ShowStyle": 0, "Editable": True}) for kind in
+      ["ComboField", "MulComboField", "BillStatusField"]],
+    *[(kind, "text", {"宽度": "160px", "文本对齐方式": "居中"}, {"Width": "160px", "TextAlign": "center"}) for kind in
+      ["TextField", "TextAreaField", "BasedataField", "UserField", "CheckBoxField", "TimeField", "MuliLangTextField"]],
+])
+@pytest.mark.parametrize("existing", [True, False])
+def test_typed_column_properties_round_trip_for_existing_and_new_columns(column_properties, field_type, family, properties, expected, existing):
+    state = column_properties
+    state.update({"fieldType": field_type, "family": family, "existing": existing})
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": properties}]})
+    assert result["status"] is True, result
+    assert state["values"] == expected
+    assert state["writes"][0][0] == "typed_column"  # use the persisted key returned after creation
+    assert len(state["adds"]) == (not existing)
+    assert all(row["matched"] for row in result["verification"]["columns"][0]["properties"].values())
+    state["writes"].clear()
+    second = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": properties}]})
+    assert second["status"] is True and state["writes"] == []
+
+
+@pytest.mark.parametrize("properties", [
+    {"Summary": "unknown"}, {"Summary": True}, {"Summary": False}, {"ListFieldId": "other"}, {"Key": "other"},
+    {"FieldFontSize": "large"}, {"Width": {"bad": 1}}, {"MissingProperty": 1}, {"Style": {"border": "x"}},
+])
+def test_column_property_errors_do_not_write_existing_columns(column_properties, properties):
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": properties}]})
+    assert result["status"] is False
+    assert result["data"]["writeAttempted"] is False
+    assert column_properties["writes"] == [] and column_properties["adds"] == []
+
+
+def test_non_numeric_columns_reject_aggregation(column_properties):
+    column_properties["family"] = "text"
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": {"Summary": "合计"}}]})
+    assert result["status"] is False and column_properties["writes"] == []
+
+
+def test_zero_and_false_are_verified_and_not_replayed(column_properties):
+    properties = {"Summary": 0, "ZeroShow": False, "ColumnOrderAndFilter": "0"}
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": properties}]})
+    assert result["status"] is True
+    assert column_properties["values"] == properties
+    column_properties["writes"].clear()
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": properties}]})
+    assert result["status"] is True and not column_properties["writes"]
+
+
+def test_column_property_write_receipt_does_not_replace_readback(column_properties):
+    column_properties["dropWrite"] = True
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": {"Summary": 1}}]})
+    assert result["status"] is False and result["errorCode"] == "LIST_CONFIGURATION_VERIFY_FAILED"
+    assert result["verification"]["columns"][0]["properties"]["Summary"]["matched"] is False
+
+
+def test_conflicting_legacy_and_property_options_fail_before_writes(column_properties):
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "displayName": "Title", "properties": {"名称": "Other title"}}]})
+    assert result["status"] is False and column_properties["writes"] == []
+
+
+def test_list_visibility_reuses_observed_list_flags_without_guessing_new_ones():
+    rows = [{"propertyName": "Visible", "displayName": "可见性", "editable": True, "complexity": "simple",
+             "editorType": "mcombo", "currentValue": "default,lookup,view",
+             "options": [{"id": "view", "name": "查看可见"}]}]
+    properties, _, error = LISTUI._compile_list_column_properties(rows, {"properties": {"Visible": ["default", "lookup"]}})
+    assert error is None and properties == {"Visible": "default,lookup"}
+    assert rows[0]["options"] == [{"id": "view", "name": "查看可见"}]
+    _, _, error = LISTUI._compile_list_column_properties(rows, {"properties": {"Visible": "invented_flag"}})
+    assert error is not None
+
+
+def test_conflicting_aliases_within_one_property_map_are_rejected():
+    rows = [{"propertyName": "Summary", "displayName": "汇总方式", "editable": True, "complexity": "simple",
+             "editorType": "combo", "options": [{"id": 0, "name": "不汇总"}, {"id": 1, "name": "合计"}]}]
+    _, _, error = LISTUI._compile_list_column_properties(rows, {"properties": {"Summary": 0, "汇总方式": 1}})
+    assert error["errorCode"] == "LIST_COLUMN_PROPERTY_CONFLICT"
+
+
+def test_duplicate_column_requests_and_invalid_sort_fail_without_writes(column_properties):
+    for columns in [[{"fieldKey": "value", "properties": {"Summary": 1}}, {"fieldKey": "value", "properties": {"Summary": 2}}],
+                    [{"fieldKey": "value", "order": "up"}]]:
+        result = LISTUI.do_configure_list({}, "token", "demo", {"columns": columns})
+        assert result["status"] is False
+        assert column_properties["writes"] == [] and column_properties["adds"] == []
+
+
+def test_real_2136_wrap_align_payload_maps_to_live_properties_without_discovery(column_properties):
+    column_properties["family"] = "text"
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value",
+        "properties": {"Width": "240px", "Wrap": True, "Align": "左"}}]})
+    assert result["status"] is True
+    assert column_properties["values"] == {"Width": "240px", "AutoTextWrap": True, "TextAlign": "left"}
+    column_properties["writes"].clear()
+    repeated = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value",
+        "properties": {"列宽": "240px", "自动换行": True, "文本对齐": "左对齐"}}]})
+    assert repeated["status"] is True and column_properties["writes"] == []
+    assert repeated["data"]["completion"]["nextAction"] == "respond_no_change"
+
+
+def test_all_invalid_properties_have_candidates_and_exact_column_recovery(column_properties):
+    column_properties["family"] = "text"
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value",
+        "properties": {"AutoTextWrapp": True, "TextAliggn": "left"}}]})
+    assert result["status"] is False
+    data = result["data"]
+    assert len(data["propertyError"]["data"]["errors"]) == 2
+    assert data["recovery"]["command"] == "getPropertySchema"
+    assert data["recovery"]["arguments"] == ["--formNumber", "demo", "--elementKey", "typed_column"]
+    assert data["columnKey"] == "typed_column"
+    assert data["completion"]["nextAction"] == "repair_only_reported_input"
+    errors = data["propertyError"]["data"]["errors"]
+    assert all(error["data"]["suggestions"] for error in errors)
+    assert column_properties["writes"] == []
+
+
+def test_known_unsupported_aggregation_has_terminal_no_card_result(column_properties):
+    column_properties["family"] = "text"
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "value", "properties": {"Summary": "合计"}}]})
+    assert result["data"]["completion"]["nextAction"] == "respond_unmet_property"
+    assert result["data"]["completion"]["requiresArtifactFinalization"] is False
+    assert column_properties["writes"] == []
+
+
+@pytest.mark.parametrize("literal_caption", [False, True])
+def test_explicit_header_prefix_is_scoped_but_exact_captions_are_preserved(column_properties, monkeypatch, literal_caption):
+    state = column_properties
+    state["family"] = "text"
+    monkeypatch.setattr(LISTUI, "do_list_elements", lambda *args, **kwargs: {"status": True, "data": [
+        {"key": "header_note", "name": "备注", "type": "TextField", "parentKey": "demo"},
+        {"key": "entry_note", "name": "表头备注" if literal_caption else "备注", "type": "TextField", "parentKey": "entries"}]})
+    monkeypatch.setattr(LISTUI, "do_get_entity_type", lambda *args: _entity_type("header_note", "entry_note"))
+    monkeypatch.setattr(LISTUI, "do_get_form_schema", lambda *args: _schema([
+        {"key": "header_column", "listFieldId": "header_note"}, {"key": "entry_column", "listFieldId": "entry_note"}]))
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [{"fieldKey": "表头备注", "properties": {"Wrap": True}}]})
+    assert result["status"] is True
+    assert state["writes"][0][0] == ("entry_column" if literal_caption else "header_column")
+
+
+def test_all_bad_column_values_are_reported_before_any_write(column_properties, monkeypatch):
+    monkeypatch.setattr(LISTUI, "do_list_elements", lambda *args, **kwargs: {"status": True, "data": [
+        {"key": "value", "name": "第一列", "type": "IntegerField"}, {"key": "other", "name": "第二列", "type": "IntegerField"}]})
+    monkeypatch.setattr(LISTUI, "do_get_entity_type", lambda *args: _entity_type("value", "other"))
+    monkeypatch.setattr(LISTUI, "do_get_form_schema", lambda *args: _schema([
+        {"key": "typed_column", "listFieldId": "value"}, {"key": "other_column", "listFieldId": "other"}]))
+    result = LISTUI.do_configure_list({}, "token", "demo", {"columns": [
+        {"fieldKey": "value", "properties": {"Width": 150}}, {"fieldKey": "other", "properties": {"Width": 150}}]})
+    assert result["status"] is False
+    assert {error["fieldKey"] for error in result["data"]["columnErrors"]} == {"value", "other"}
+    assert column_properties["writes"] == [] and column_properties["adds"] == []

package/skills/cosmic-build/scripts/test/test_mcp_cli.py

@@ -34,8 +34,8 @@ def _platform_ok(data):
     return {"status": True, "errorCode": "0", "message": None, "data": data}
 
 
-def _platform_fail(error_code, message):
-    return {"status": False, "errorCode": error_code, "message": message, "data": None}
+def _platform_fail(error_code, message, data=None):
+    return {"status": False, "errorCode": error_code, "message": message, "data": data}
 
 
 class EndpointContractTest(unittest.TestCase):
@@ -296,6 +296,143 @@ class CallFoldingTest(unittest.TestCase):
         self.assertEqual(flat["outputDir"], "datamodel")
 
 
+class BatchFailureTest(unittest.TestCase):
+    """兼容旧平台缺明细、新平台带明细及外层成功但业务失败的批量响应。"""
+
+    def test_platform_failure_preserves_counts_and_item_reasons(self):
+        data = {
+            "success": False, "successCount": 0, "failCount": 1,
+            "items": [{"id": 42, "success": False, "message": "当前环境不允许维护标品预置的MCP服务。"}],
+        }
+        for command in ("delete", "resetStatus", "unshelves", "importYaml"):
+            with self.subTest(command=command), mock.patch.object(
+                mcp_cli.kd_api, "post", return_value=_platform_fail("DELETE_FAIL", "成功0条，失败1条。", data)
+            ):
+                result = mcp_cli._call(command, {"ids": [42]}, cfg={})
+            self.assertFalse(result["status"])
+            self.assertEqual(result["errorCode"], "DELETE_FAIL")
+            self.assertEqual(result["message"], "成功0条，失败1条。")
+            self.assertEqual(result["data"], data)
+
+    def test_legacy_delete_failure_does_not_fabricate_details(self):
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=_platform_fail(
+            "DELETE_FAIL", "成功0条，失败1条。"
+        )):
+            result = mcp_cli._call("delete", {"ids": [42]}, cfg={})
+        self.assertEqual(result, mcp_cli._fail("DELETE_FAIL", "成功0条，失败1条。"))
+        self.assertIsNone(result["data"])
+
+    def test_outer_success_with_failed_count_is_not_full_success(self):
+        data = {
+            "success": True, "successCount": 1, "failCount": 1,
+            "message": "一条下架已受理，一条状态不允许。",
+            "items": [
+                {"id": 1, "success": True, "message": None},
+                {"id": 2, "success": False, "message": "仅已发布或待更新状态的数据可下架。"},
+            ],
+        }
+        for command in ("delete", "resetStatus", "unshelves", "importYaml"):
+            with self.subTest(command=command), mock.patch.object(
+                mcp_cli.kd_api, "post", return_value=_platform_ok(data)
+            ):
+                result = mcp_cli._call(command, {}, cfg={})
+            self.assertFalse(result["status"])
+            self.assertEqual(result["errorCode"], "PARTIAL_SUCCESS")
+            self.assertEqual(result["message"], data["message"])
+            self.assertEqual(result["data"], data)
+
+    def test_inner_failure_overrides_misleading_success_count(self):
+        data = {
+            "success": False, "errorCode": "DELETE_FAIL", "message": "实体删除操作失败。",
+            "successCount": 1, "failCount": 0, "items": [],
+        }
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=_platform_ok(data)):
+            result = mcp_cli._call("delete", {"ids": [42]}, cfg={})
+        self.assertFalse(result["status"])
+        self.assertEqual(result["errorCode"], "DELETE_FAIL")
+        self.assertEqual(result["data"], data)
+
+    def test_batch_failure_without_code_keeps_partial_and_total_distinct(self):
+        for success_count, expected in ((0, "PLATFORM_ERROR"), (1, "PARTIAL_SUCCESS")):
+            data = {"successCount": success_count, "failCount": 1}
+            with self.subTest(success_count=success_count), mock.patch.object(
+                mcp_cli.kd_api, "post", return_value=_platform_ok(data)
+            ):
+                result = mcp_cli._call("delete", {}, cfg={})
+            self.assertEqual(result["errorCode"], expected)
+            self.assertEqual(result["data"], data)
+
+    def test_zero_failure_batch_remains_successful(self):
+        data = {"success": True, "successCount": 1, "failCount": 0, "ignoreCount": 2, "items": []}
+        for command in ("delete", "resetStatus", "unshelves", "importYaml"):
+            with self.subTest(command=command), mock.patch.object(
+                mcp_cli.kd_api, "post", return_value=_platform_ok(data)
+            ):
+                result = mcp_cli._call(command, {}, cfg={})
+            self.assertEqual(result, mcp_cli._ok(data))
+
+    def test_gateway_registration_failure_does_not_invalidate_saved_record(self):
+        data = {"id": 42, "registerInfo": {"success": False, "failCount": 1}}
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=_platform_ok(data)):
+            result = mcp_cli._call("save", {}, cfg={})
+        self.assertEqual(result, mcp_cli._ok(data))
+
+    def test_message_sanitization_does_not_discard_failure_data(self):
+        data = {"items": [{"id": 42, "success": False, "message": "实体操作拒绝删除。"}]}
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=_platform_fail(
+            "DELETE_FAIL", "实体操作失败，TraceId：abc\n====Stack====\nJava stack", data
+        )):
+            result = mcp_cli._call("delete", {}, cfg={})
+        self.assertIn("TraceId：abc", result["message"])
+        self.assertNotIn("====Stack====", result["message"])
+        self.assertEqual(result["data"], data)
+
+    def test_main_batch_failure_exits_one_with_details_without_replaying(self):
+        data = {
+            "success": False, "errorCode": "DELETE_FAIL", "successCount": 0, "failCount": 1,
+            "items": [{"id": 42, "success": False, "message": "实体操作拒绝删除。"}],
+        }
+        for platform in (_platform_fail("DELETE_FAIL", "成功0条，失败1条。", data), _platform_ok(data)):
+            with self.subTest(platform_status=platform["status"]), \
+                 mock.patch.object(mcp_cli, "_load_config", return_value={}), \
+                 mock.patch.object(mcp_cli.kd_api, "post", return_value=platform) as post, \
+                 contextlib.redirect_stdout(io.StringIO()) as output:
+                code = mcp_cli.main(["delete", "--ids", "42", "--confirm"])
+            self.assertEqual(code, 1)
+            self.assertEqual(len(output.getvalue().splitlines()), 1)
+            result = json.loads(output.getvalue())
+            self.assertFalse(result["status"])
+            self.assertEqual(result["data"], data)
+            post.assert_called_once()
+
+    def test_main_partial_unshelves_is_failure_without_replaying(self):
+        data = {"success": True, "successCount": 1, "failCount": 1, "items": []}
+        with mock.patch.object(mcp_cli, "_load_config", return_value={}), \
+             mock.patch.object(mcp_cli.kd_api, "post", return_value=_platform_ok(data)) as post, \
+             contextlib.redirect_stdout(io.StringIO()) as output:
+            code = mcp_cli.main(["unshelves", "--ids", "1,2", "--confirm"])
+        self.assertEqual(code, 1)
+        self.assertEqual(json.loads(output.getvalue())["data"], data)
+        post.assert_called_once()
+
+
+class DeleteGuidanceTest(unittest.TestCase):
+    """两种语言的技能入口必须保留相同的删除条件与失败取证字段。"""
+
+    def test_delete_contract_covers_status_source_and_entity_operation(self):
+        with open(os.path.join(os.path.dirname(_SCRIPTS_DIR), "skills", "mcp-server", "SKILL.md"), encoding="utf-8") as handle:
+            text = handle.read()
+        paragraph = text.split("- `delete`", 1)[1].split("\n- ", 1)[0]
+        for token in ("FAILED", "UNSHELVESED", "source_type", "open_mcp_ext"):
+            self.assertIn(token, paragraph)
+
+    def test_delete_failure_guidance_requires_item_details_and_legacy_boundary(self):
+        with open(os.path.join(os.path.dirname(_SCRIPTS_DIR), "skills", "mcp-server", "SKILL.md"), encoding="utf-8") as handle:
+            text = handle.read()
+        for token in ("data.items[].message", "data: null", "OperationResult", "DELETE_FAIL"):
+            self.assertIn(token, text)
+
+
 class MessageSanitizationTest(unittest.TestCase):
     """Platform failure messages carry TraceId/WebInstance/Java stacks that can
     run kilobytes long (e.g. bos.orm.read.dataNotExist on a deleted record);