@josephyan/qingflow-cli 1.0.10 → 1.1.1

package/src/qingflow_mcp/cli/commands/record.py

@@ -13,7 +13,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     record_subparsers = parser.add_subparsers(
         dest="record_command",
         required=True,
-        metavar="{schema,list,access,get,insert,update,delete,code-block-run}",
+        metavar="{schema,list,access,get,logs,insert,update,delete,member-candidates,department-candidates,code-block-run}",
     )
 
     schema = record_subparsers.add_parser("schema", help="读取记录相关表结构")
@@ -47,6 +47,28 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     schema_code_block.add_argument("--app-key", required=True)
     schema_code_block.set_defaults(handler=_handle_schema_code_block, format_hint="")
 
+    member_candidates = record_subparsers.add_parser("member-candidates", help="读取成员字段候选项")
+    member_candidates.add_argument("--app-key", required=True)
+    member_candidates.add_argument("--field-id", type=int, required=True)
+    member_candidates.add_argument("--keyword", default="")
+    member_candidates.add_argument("--page-num", type=int, default=1)
+    member_candidates.add_argument("--page-size", type=int, default=20)
+    member_candidates.add_argument("--record-id")
+    member_candidates.add_argument("--workflow-node-id", type=int)
+    member_candidates.add_argument("--fields-file")
+    member_candidates.set_defaults(handler=_handle_member_candidates, format_hint="")
+
+    department_candidates = record_subparsers.add_parser("department-candidates", help="读取部门字段候选项")
+    department_candidates.add_argument("--app-key", required=True)
+    department_candidates.add_argument("--field-id", type=int, required=True)
+    department_candidates.add_argument("--keyword", default="")
+    department_candidates.add_argument("--page-num", type=int, default=1)
+    department_candidates.add_argument("--page-size", type=int, default=20)
+    department_candidates.add_argument("--record-id")
+    department_candidates.add_argument("--workflow-node-id", type=int)
+    department_candidates.add_argument("--fields-file")
+    department_candidates.set_defaults(handler=_handle_department_candidates, format_hint="")
+
     list_parser = record_subparsers.add_parser("list", help="列出记录")
     list_parser.add_argument("--app-key", required=True)
     list_parser.add_argument("--column", dest="columns", action="append", type=int, default=[])
@@ -56,7 +78,6 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     list_parser.add_argument("--query-fields-file")
     list_parser.add_argument("--where-file")
     list_parser.add_argument("--order-by-file")
-    list_parser.add_argument("--limit", type=int, default=20)
     list_parser.add_argument("--page", type=int, default=1)
     list_parser.add_argument("--view-id")
     list_parser.add_argument("--list-type", dest="legacy_list_type", type=int, help=argparse.SUPPRESS)
@@ -81,9 +102,16 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     get.add_argument("--view-id")
     get.set_defaults(handler=_handle_get, format_hint="record_get")
 
+    logs = record_subparsers.add_parser("logs", help="读取单条记录全量日志并写入本地 JSONL")
+    logs.add_argument("--app-key", required=True)
+    logs.add_argument("--record-id", required=True)
+    logs.add_argument("--view-id")
+    logs.set_defaults(handler=_handle_logs, format_hint="record_logs")
+
     insert = record_subparsers.add_parser("insert", help="新增记录")
     insert.add_argument("--app-key", required=True)
-    insert.add_argument("--fields-file", required=True)
+    insert.add_argument("--fields-file", help=argparse.SUPPRESS)
+    insert.add_argument("--items-file")
     insert.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
     insert.set_defaults(handler=_handle_insert, format_hint="")
 
@@ -207,6 +235,38 @@ def _handle_schema_code_block(args: argparse.Namespace, context: CliContext) ->
     return context.code_block.record_code_block_schema_get_public(profile=args.profile, app_key=args.app_key)
 
 
+def _candidate_context_fields(args: argparse.Namespace) -> dict[str, Any]:
+    return load_object_arg(args.fields_file, option_name="--fields-file") or {}
+
+
+def _handle_member_candidates(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_member_candidates(
+        profile=args.profile,
+        app_key=args.app_key,
+        field_id=args.field_id,
+        record_id=args.record_id,
+        workflow_node_id=args.workflow_node_id,
+        fields=_candidate_context_fields(args),
+        keyword=args.keyword,
+        page_num=args.page_num,
+        page_size=args.page_size,
+    )
+
+
+def _handle_department_candidates(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_department_candidates(
+        profile=args.profile,
+        app_key=args.app_key,
+        field_id=args.field_id,
+        record_id=args.record_id,
+        workflow_node_id=args.workflow_node_id,
+        fields=_candidate_context_fields(args),
+        keyword=args.keyword,
+        page_num=args.page_num,
+        page_size=args.page_size,
+    )
+
+
 def _validate_public_view_selector(
     *,
     view_id: str | None,
@@ -248,7 +308,6 @@ def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
         query_fields=_query_fields(args),
         where=load_list_arg(args.where_file, option_name="--where-file"),
         order_by=load_list_arg(args.order_by_file, option_name="--order-by-file"),
-        limit=args.limit,
         page=args.page,
         view_id=args.view_id,
     )
@@ -275,7 +334,33 @@ def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
+def _handle_logs(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_logs_get(
+        profile=args.profile,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        view_id=args.view_id,
+    )
+
+
 def _handle_insert(args: argparse.Namespace, context: CliContext) -> dict:
+    if args.items_file:
+        if args.fields_file:
+            raise_config_error(
+                "record insert batch mode does not accept --fields-file.",
+                fix_hint="Use `record insert --app-key APP_KEY --items-file ITEMS.json` for batch inserts.",
+            )
+        return context.record.record_insert_public(
+            profile=args.profile,
+            app_key=args.app_key,
+            items=require_list_arg(args.items_file, option_name="--items-file"),
+            verify_write=bool(args.verify_write),
+        )
+    if not args.fields_file:
+        raise_config_error(
+            "record insert requires --items-file.",
+            fix_hint="Use `record insert --app-key APP_KEY --items-file ITEMS.json`; a single insert is one item in the JSON array.",
+        )
     return context.record.record_insert_public(
         profile=args.profile,
         app_key=args.app_key,

package/src/qingflow_mcp/cli/formatters.py

@@ -190,20 +190,9 @@ def _format_record_list(result: dict[str, Any]) -> str:
         lines.append(f"- query: {lookup.get('query')}")
         lines.append(f"- confidence: {lookup.get('confidence')}")
         lines.append(f"- next_action: {lookup.get('next_action')}")
-        lines.append(f"- reported_total: {lookup.get('reported_total')}")
-        candidates = lookup.get("candidates") if isinstance(lookup.get("candidates"), list) else []
-        for candidate in candidates[:5]:
-            if not isinstance(candidate, dict):
-                continue
-            title = candidate.get("title") or "-"
-            record_id = candidate.get("record_id") or "-"
-            score = candidate.get("score")
-            lines.append(f"  - {record_id} | score={score} | {title}")
-            matches = candidate.get("matched_fields") if isinstance(candidate.get("matched_fields"), list) else []
-            if matches:
-                match = matches[0]
-                if isinstance(match, dict):
-                    lines.append(f"    match: {match.get('title')}={match.get('value')}")
+        lines.append(f"- total_count: {lookup.get('total_count')}")
+        lines.append(f"- returned_count: {lookup.get('returned_count')}")
+        lines.append(f"- truncated: {lookup.get('truncated')}")
     lines.append(f"Returned Records: {len(items)}")
     for item in items[:10]:
         if isinstance(item, dict):
@@ -256,6 +245,15 @@ def _format_record_get(result: dict[str, Any]) -> str:
     media_items = media_assets.get("items") if isinstance(media_assets.get("items"), list) else []
     downloaded_media = [item for item in media_items if isinstance(item, dict) and item.get("access_status") == "downloaded"]
     failed_media = [item for item in media_items if isinstance(item, dict) and item.get("access_status") != "downloaded"]
+    file_assets = result.get("file_assets") if isinstance(result.get("file_assets"), dict) else {}
+    file_items = file_assets.get("items") if isinstance(file_assets.get("items"), list) else []
+    downloaded_files = [item for item in file_items if isinstance(item, dict) and item.get("access_status") == "downloaded"]
+    failed_files = [item for item in file_items if isinstance(item, dict) and item.get("access_status") != "downloaded"]
+    extracted_files = [
+        item
+        for item in downloaded_files
+        if isinstance(item.get("extraction"), dict) and item["extraction"].get("status") == "ok"
+    ]
     associated_resources = result.get("associated_resources") if isinstance(result.get("associated_resources"), list) else []
     unavailable_context = result.get("unavailable_context") if isinstance(result.get("unavailable_context"), list) else []
     lines = [
@@ -267,17 +265,26 @@ def _format_record_get(result: dict[str, Any]) -> str:
         f"Data logs: {data_logs.get('status') or '-'} / loaded={data_logs.get('items_loaded')}",
         f"Workflow logs: {workflow_logs.get('status') or '-'} / loaded={workflow_logs.get('items_loaded')}",
         f"Media assets: {media_assets.get('status') or '-'} / downloaded={len(downloaded_media)} / failed={len(failed_media)}",
+        f"File assets: {file_assets.get('status') or '-'} / downloaded={len(downloaded_files)} / extracted={len(extracted_files)} / failed={len(failed_files)}",
         f"Associated resources: {len(associated_resources)}",
         f"Unavailable contexts: {len(unavailable_context)}",
     ]
     if media_assets.get("local_dir"):
         lines.append(f"Media dir: {media_assets.get('local_dir')}")
+    if file_assets.get("local_dir"):
+        lines.append(f"File dir: {file_assets.get('local_dir')}")
     if failed_media:
         failure_counts: dict[str, int] = {}
         for item in failed_media:
             key = f"{item.get('access_status') or 'unknown'} via {item.get('download_strategy') or 'unknown'}"
             failure_counts[key] = failure_counts.get(key, 0) + 1
         lines.append("Media failures: " + ", ".join(f"{key}={count}" for key, count in sorted(failure_counts.items())))
+    if failed_files:
+        failure_counts = {}
+        for item in failed_files:
+            key = f"{item.get('access_status') or 'unknown'} via {item.get('download_strategy') or 'unknown'}"
+            failure_counts[key] = failure_counts.get(key, 0) + 1
+        lines.append("File failures: " + ", ".join(f"{key}={count}" for key, count in sorted(failure_counts.items())))
     summary = result.get("summary") if isinstance(result.get("summary"), dict) else {}
     if summary.get("text"):
         lines.append(f"Summary: {summary.get('text')}")
@@ -285,6 +292,37 @@ def _format_record_get(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_record_logs(result: dict[str, Any]) -> str:
+    app = result.get("app") if isinstance(result.get("app"), dict) else {}
+    view = result.get("view") if isinstance(result.get("view"), dict) else {}
+    record = result.get("record") if isinstance(result.get("record"), dict) else {}
+    data_logs = result.get("data_logs") if isinstance(result.get("data_logs"), dict) else {}
+    workflow_logs = result.get("workflow_logs") if isinstance(result.get("workflow_logs"), dict) else {}
+    integrity = result.get("context_integrity") if isinstance(result.get("context_integrity"), dict) else {}
+    lines = [
+        f"Status: {result.get('status') or '-'}",
+        f"App: {app.get('app_name') or app.get('app_key') or '-'} ({app.get('app_key') or '-'})",
+        f"View: {view.get('name') or view.get('view_id') or '-'}",
+        f"Record: {record.get('title') or '-'} ({record.get('record_id') or '-'})",
+        f"Data logs: {data_logs.get('status') or '-'} / count={data_logs.get('items_count')} / pages={data_logs.get('pages_fetched')} / complete={data_logs.get('complete')}",
+        f"Workflow logs: {workflow_logs.get('status') or '-'} / count={workflow_logs.get('items_count')} / pages={workflow_logs.get('pages_fetched')} / complete={workflow_logs.get('complete')}",
+        f"Safe for full log conclusion: {integrity.get('safe_for_full_log_conclusion')}",
+    ]
+    if result.get("local_dir"):
+        lines.append(f"Local dir: {result.get('local_dir')}")
+    if data_logs.get("local_path"):
+        lines.append(f"Data logs file: {data_logs.get('local_path')}")
+    if workflow_logs.get("local_path"):
+        lines.append(f"Workflow logs file: {workflow_logs.get('local_path')}")
+    if result.get("summary_path"):
+        lines.append(f"Summary file: {result.get('summary_path')}")
+    _append_warnings(lines, result.get("warnings"))
+    unavailable = result.get("unavailable_context") if isinstance(result.get("unavailable_context"), list) else []
+    if unavailable:
+        lines.append(f"Unavailable contexts: {len(unavailable)}")
+    return "\n".join(lines) + "\n"
+
+
 def _format_task_list(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     items = data.get("items") if isinstance(data.get("items"), list) else []
@@ -781,11 +819,11 @@ _FORMATTERS = {
     "workspace_get": _format_workspace_get,
     "workspace_select": _format_workspace_select,
     "app_list": _format_app_items,
-    "app_search": _format_app_items,
     "app_get": _format_app_get,
     "record_list": _format_record_list,
     "record_access": _format_record_access,
     "record_get": _format_record_get,
+    "record_logs": _format_record_logs,
     "task_list": _format_task_list,
     "task_workbench": _format_task_workbench,
     "task_get": _format_task_get,

package/src/qingflow_mcp/cli/main.py

@@ -8,6 +8,7 @@ from typing import Any, Callable, TextIO
 from ..errors import QingflowApiError
 from ..public_surface import cli_public_tool_spec_from_namespace
 from ..response_trim import resolve_cli_tool_name, trim_error_response, trim_public_response
+from ..tools.ai_builder_tools import _attach_builder_apply_envelope
 from .context import CliContext, build_cli_context
 from .formatters import emit_json_result, emit_text_result
 from .commands import register_all_commands
@@ -16,8 +17,21 @@ from .commands import register_all_commands
 Handler = Callable[[argparse.Namespace, CliContext], dict[str, Any]]
 
 
+class _CliArgumentError(Exception):
+    def __init__(self, *, prog: str, message: str, usage: str) -> None:
+        super().__init__(message)
+        self.prog = prog
+        self.message = message
+        self.usage = usage
+
+
+class _QingflowArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:
+        raise _CliArgumentError(prog=self.prog, message=message, usage=self.format_usage())
+
+
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="qingflow", description="Qingflow CLI")
+    parser = _QingflowArgumentParser(prog="qingflow", description="Qingflow CLI")
     parser.add_argument("--profile", default="default", help="会话 profile，默认 default")
     parser.add_argument("--json", action="store_true", help="输出 JSON")
     subparsers = parser.add_subparsers(dest="command", required=True)
@@ -42,6 +56,21 @@ def run(
     normalized_argv = _normalize_global_args(list(argv) if argv is not None else sys.argv[1:])
     try:
         args = parser.parse_args(normalized_argv)
+    except _CliArgumentError as exc:
+        if _should_force_json_output_argv(normalized_argv):
+            payload = {
+                "category": "config",
+                "status": "failed",
+                "error_code": "ARGUMENT_ERROR",
+                "message": exc.message,
+                "details": {"usage": exc.usage.strip(), "prog": exc.prog},
+            }
+            payload = _maybe_attach_builder_apply_error_envelope_from_argv(normalized_argv, payload)
+            emit_json_result(payload, stream=out)
+            return 2
+        err.write(exc.usage)
+        err.write(f"{exc.prog}: error: {exc.message}\n")
+        return 2
     except SystemExit as exc:
         return int(exc.code or 0)
     setattr(args, "_stdin", sys.stdin)
@@ -51,8 +80,10 @@ def run(
     if handler is None:
         parser.print_help(out)
         return 2
-    context = context_factory()
     try:
+        if _should_force_json_output(args):
+            setattr(args, "json", True)
+        context = context_factory()
         if not bool(args.json):
             _emit_cli_effective_context_notice(args, context, stream=err)
         result = handler(args, context)
@@ -60,12 +91,15 @@ def run(
         return int(exc.code or 0)
     except RuntimeError as exc:
         payload = trim_error_response(_parse_error_payload(exc))
+        payload = _maybe_attach_builder_apply_error_envelope_from_args(args, payload)
         return _emit_error(payload, json_mode=bool(args.json), stdout=out, stderr=err)
     except QingflowApiError as exc:
         payload = trim_error_response(exc.to_dict())
+        payload = _maybe_attach_builder_apply_error_envelope_from_args(args, payload)
         return _emit_error(payload, json_mode=bool(args.json), stdout=out, stderr=err)
     finally:
-        context.close()
+        if "context" in locals():
+            context.close()
 
     exit_code = _result_exit_code(result)
     trimmed_result = trim_public_response(resolve_cli_tool_name(args), result) if isinstance(result, dict) else result
@@ -104,6 +138,173 @@ def _normalize_global_args(argv: list[str]) -> list[str]:
     return global_args + remaining
 
 
+def _should_force_json_output(args: argparse.Namespace) -> bool:
+    if bool(getattr(args, "force_json_output", False)):
+        return True
+    if (
+        getattr(args, "command", "") == "builder"
+        and getattr(args, "builder_app_command", "") == "repair-code-blocks"
+        and bool(getattr(args, "apply", False))
+    ):
+        return True
+    return False
+
+
+def _should_force_json_output_argv(argv: list[str]) -> bool:
+    tokens = _strip_global_args(argv)
+    if not tokens or tokens[0] not in {"builder", "build"}:
+        return False
+    if len(tokens) < 3:
+        return False
+    section = tokens[1]
+    action = tokens[2]
+    if section in {"package", "button", "associated-resource", "associated-resources", "portal", "schema", "layout", "views", "flow", "charts"}:
+        return action == "apply"
+    if section == "publish":
+        return action == "verify"
+    if section == "app":
+        if action == "release-edit-lock-if-mine":
+            return True
+        if action == "repair-code-blocks":
+            return "--apply" in tokens
+    return False
+
+
+def _maybe_attach_builder_apply_error_envelope_from_args(args: argparse.Namespace, payload: dict[str, Any]) -> dict[str, Any]:
+    operation = _builder_apply_operation_from_args(args)
+    if not operation:
+        return payload
+    enriched = dict(payload)
+    enriched.setdefault("status", "failed")
+    enriched.setdefault("ok", False)
+    enriched.setdefault("write_executed", False)
+    enriched.setdefault("safe_to_retry", False)
+    _copy_arg_identity(enriched, args)
+    return _attach_builder_apply_envelope(operation, enriched)
+
+
+def _maybe_attach_builder_apply_error_envelope_from_argv(argv: list[str], payload: dict[str, Any]) -> dict[str, Any]:
+    operation = _builder_apply_operation_from_argv(argv)
+    if not operation:
+        return payload
+    enriched = dict(payload)
+    enriched.setdefault("status", "failed")
+    enriched.setdefault("ok", False)
+    enriched.setdefault("write_executed", False)
+    enriched.setdefault("safe_to_retry", False)
+    _copy_argv_identity(enriched, argv)
+    return _attach_builder_apply_envelope(operation, enriched)
+
+
+def _builder_apply_operation_from_args(args: argparse.Namespace) -> str | None:
+    if getattr(args, "command", "") not in {"builder", "build"}:
+        return None
+    section = str(getattr(args, "builder_command", "") or "")
+    if section == "package" and getattr(args, "builder_package_command", "") == "apply":
+        return "package_apply"
+    if section == "button" and getattr(args, "builder_button_command", "") == "apply":
+        return "app_custom_buttons_apply"
+    if section in {"associated-resource", "associated-resources"} and getattr(args, "builder_associated_resource_command", "") == "apply":
+        return "app_associated_resources_apply"
+    if section == "portal" and getattr(args, "builder_portal_command", "") == "apply":
+        return "portal_apply"
+    if section == "schema" and getattr(args, "builder_schema_command", "") == "apply":
+        return "app_schema_apply"
+    if section == "layout" and getattr(args, "builder_layout_command", "") == "apply":
+        return "app_layout_apply"
+    if section == "views" and getattr(args, "builder_views_command", "") == "apply":
+        return "app_views_apply"
+    if section == "flow" and getattr(args, "builder_flow_command", "") == "apply":
+        return "app_flow_apply"
+    if section == "charts" and getattr(args, "builder_charts_command", "") == "apply":
+        return "app_charts_apply"
+    if section == "publish" and getattr(args, "builder_publish_command", "") == "verify":
+        return "app_publish_verify"
+    return None
+
+
+def _builder_apply_operation_from_argv(argv: list[str]) -> str | None:
+    tokens = _strip_global_args(argv)
+    if not tokens or tokens[0] not in {"builder", "build"} or len(tokens) < 3:
+        return None
+    section = tokens[1]
+    action = tokens[2]
+    if action != "apply" and not (section == "publish" and action == "verify"):
+        return None
+    mapping = {
+        "package": "package_apply",
+        "button": "app_custom_buttons_apply",
+        "associated-resource": "app_associated_resources_apply",
+        "associated-resources": "app_associated_resources_apply",
+        "portal": "portal_apply",
+        "schema": "app_schema_apply",
+        "layout": "app_layout_apply",
+        "views": "app_views_apply",
+        "flow": "app_flow_apply",
+        "charts": "app_charts_apply",
+        "publish": "app_publish_verify",
+    }
+    return mapping.get(section)
+
+
+def _copy_arg_identity(payload: dict[str, Any], args: argparse.Namespace) -> None:
+    for attr, key in (
+        ("app_key", "app_key"),
+        ("app_name", "app_name"),
+        ("app_title", "app_title"),
+        ("package_id", "package_id"),
+        ("dash_key", "dash_key"),
+        ("dash_name", "dash_name"),
+    ):
+        value = getattr(args, attr, None)
+        if value not in (None, ""):
+            payload.setdefault(key, value)
+
+
+def _copy_argv_identity(payload: dict[str, Any], argv: list[str]) -> None:
+    tokens = _strip_global_args(argv)
+    option_to_key = {
+        "--app-key": "app_key",
+        "--app-name": "app_name",
+        "--app-title": "app_title",
+        "--package-id": "package_id",
+        "--dash-key": "dash_key",
+        "--dash-name": "dash_name",
+    }
+    index = 0
+    while index < len(tokens):
+        token = tokens[index]
+        if token in option_to_key and index + 1 < len(tokens):
+            payload.setdefault(option_to_key[token], tokens[index + 1])
+            index += 2
+            continue
+        for option, key in option_to_key.items():
+            prefix = f"{option}="
+            if token.startswith(prefix):
+                payload.setdefault(key, token[len(prefix) :])
+                break
+        index += 1
+
+
+def _strip_global_args(argv: list[str]) -> list[str]:
+    stripped: list[str] = []
+    index = 0
+    while index < len(argv):
+        token = argv[index]
+        if token == "--json":
+            index += 1
+            continue
+        if token == "--profile":
+            index += 2
+            continue
+        if token.startswith("--profile="):
+            index += 1
+            continue
+        stripped.append(token)
+        index += 1
+    return stripped
+
+
 def _parse_error_payload(exc: RuntimeError) -> dict[str, Any]:
     raw = str(exc)
     try:

package/src/qingflow_mcp/public_surface.py

@@ -38,7 +38,6 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "workspace_get", ("workspace_get",), ("workspace", "get")),
     PublicToolSpec(USER_DOMAIN, "workspace_select", ("workspace_select",), ("workspace", "select")),
     PublicToolSpec(USER_DOMAIN, "app_list", ("app_list",), ("app", "list"), cli_show_effective_context=True),
-    PublicToolSpec(USER_DOMAIN, "app_search", ("app_search",), ("app", "search"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_get", ("app_get",), ("app", "get"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "portal_list", ("portal_list",), ("portal", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "portal_get", ("portal_get",), ("portal", "get"), cli_show_effective_context=True),
@@ -78,12 +77,13 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
         ("record_code_block_schema_get_public",),
         ("record", "schema", "code-block"),
     ),
-    PublicToolSpec(USER_DOMAIN, "record_member_candidates", ("record_member_candidates",), cli_public=False),
-    PublicToolSpec(USER_DOMAIN, "record_department_candidates", ("record_department_candidates",), cli_public=False),
+    PublicToolSpec(USER_DOMAIN, "record_member_candidates", ("record_member_candidates",), ("record", "member-candidates")),
+    PublicToolSpec(USER_DOMAIN, "record_department_candidates", ("record_department_candidates",), ("record", "department-candidates")),
     PublicToolSpec(USER_DOMAIN, "record_analyze", ("record_analyze",), ("record", "analyze"), mcp_public=False),
     PublicToolSpec(USER_DOMAIN, "record_list", ("record_list",), ("record", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_access", ("record_access",), ("record", "access"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_get", ("record_get_public",), ("record", "get"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_logs_get", ("record_logs_get",), ("record", "logs"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_insert", ("record_insert_public",), ("record", "insert"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "record_update", ("record_update_public",), ("record", "update"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "record_delete", ("record_delete_public",), ("record", "delete"), cli_show_effective_context=True, cli_context_write=True),
@@ -127,6 +127,8 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "file_upload_local", ("file_upload_local",), ("builder", "file", "upload-local"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "feedback_submit", ("feedback_submit",), ("builder", "feedback", "submit"), has_contract=True),
     PublicToolSpec(BUILDER_DOMAIN, "builder_tool_contract", ("builder_tool_contract",), ("builder", "contract"), has_contract=False),
+    PublicToolSpec(BUILDER_DOMAIN, "workspace_icon_catalog_get", ("workspace_icon_catalog_get",), ("builder", "icon", "catalog"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "package_list", ("package_list",), ("builder", "package", "list"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "package_get", ("package_get",), ("builder", "package", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "package_apply", ("package_apply",), ("builder", "package", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "solution_install", ("solution_install",), ("builder", "solution", "install"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
@@ -136,11 +138,10 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "app_release_edit_lock_if_mine", ("app_release_edit_lock_if_mine",), ("builder", "app", "release-edit-lock-if-mine"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_resolve", ("app_resolve",), ("builder", "app", "resolve"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "button_style_catalog_get", ("button_style_catalog_get",), ("builder", "button", "catalog"), has_contract=True, cli_show_effective_context=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_list", ("app_custom_button_list",), ("builder", "button", "list"), has_contract=True, cli_show_effective_context=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_get", ("app_custom_button_get",), ("builder", "button", "get"), has_contract=True, cli_show_effective_context=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_create", ("app_custom_button_create",), ("builder", "button", "create"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_update", ("app_custom_button_update",), ("builder", "button", "update"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_delete", ("app_custom_button_delete",), ("builder", "button", "delete"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_get_buttons", ("app_get_buttons",), ("builder", "button", "get"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_custom_buttons_apply", ("app_custom_buttons_apply",), ("builder", "button", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_get_associated_resources", ("app_get_associated_resources",), ("builder", "associated-resource", "get"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_associated_resources_apply", ("app_associated_resources_apply",), ("builder", "associated-resource", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_get", ("app_get",), ("builder", "app", "get", "summary"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_get_fields", ("app_get_fields",), ("builder", "app", "get", "fields"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_repair_code_blocks", ("app_repair_code_blocks",), ("builder", "app", "repair-code-blocks"), has_contract=True, cli_show_effective_context=True),
@@ -154,6 +155,8 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "chart_get", ("chart_get",), ("builder", "chart", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_schema_apply", ("app_schema_apply",), ("builder", "schema", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_layout_apply", ("app_layout_apply",), ("builder", "layout", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_flow_get_schema", ("app_flow_get_schema",), ("builder", "flow", "schema"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_flow_get", ("app_flow_get",), ("builder", "flow", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_flow_apply", ("app_flow_apply",), ("builder", "flow", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_views_apply", ("app_views_apply",), ("builder", "views", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_charts_apply", ("app_charts_apply",), ("builder", "charts", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),