aes-cli 0.7.0__tar.gz → 0.12.0__tar.gz

{aes_cli-0.7.0 → aes_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aes-cli
-Version: 0.7.0
+Version: 0.12.0
 Summary: CLI tool for the Agentic Engineering Standard
 Author: Hiro
 License: Apache-2.0

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/__init__.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__version__ = "0.7.0"
+__version__ = "0.12.0"

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/__main__.py

@@ -53,7 +53,7 @@ def cli(lang: Optional[str] = None) -> None:
     """
     from aes.i18n import init_locale
 
-    # Priority: --lang flag > AES_LANG env > ~/.aes/config.yaml > first-run prompt
+    # Priority: --lang flag > AES_LANG env > .agent/local.yaml > ~/.aes/config.yaml > first-run prompt
     if lang:
         init_locale(lang)
         return
@@ -63,7 +63,14 @@ def cli(lang: Optional[str] = None) -> None:
         init_locale(env_lang)
         return
 
-    from aes.global_config import get_locale
+    from pathlib import Path
+    from aes.global_config import get_locale, get_project_locale
+
+    project_locale = get_project_locale(Path.cwd())
+    if project_locale:
+        init_locale(project_locale)
+        return
+
     saved = get_locale()
     if saved is None and sys.stdin.isatty():
         _prompt_language()

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/commands/init.py

@@ -22,9 +22,17 @@ from aes.config import (
     AGENTIGNORE_FILE,
     BOM_FILE,
     DECISIONS_DIR,
+    INSTINCTS_DIR,
+    LEARNING_CONFIG_FILE,
+    LEARNING_DIR,
+    LIFECYCLE_FILE,
     LOCAL_EXAMPLE_FILE,
     LOCAL_FILE,
+    LOGS_DIR,
+    RULES_CONFIG_FILE,
+    RULES_DIR,
     SCAFFOLD_DIR,
+    SCRIPTS_DIR,
     SKILLS_DIR,
     REGISTRY_DIR,
     WORKFLOWS_DIR,
@@ -451,6 +459,8 @@ def _print_post_init_summary(
             ("Cursor", ".cursorrules"),
             ("Copilot", ".github/copilot-instructions.md"),
             ("Windsurf", ".windsurfrules"),
+            ("Codex", "AGENTS.md"),
+            ("OpenClaw", ".openclaw/openclaw.json"),
         ]
         for tool_name, file_name in sync_targets:
             if (project_root / file_name).exists():
@@ -735,6 +745,100 @@ def init_cmd(
         content = _render_template(env, "operations.md.jinja", ops_context)
         (agent_dir / MEMORY_DIR / "operations.md").write_text(content)
 
+    # Lifecycle hooks (all domains)
+    if domain_config.scaffold_lifecycle:
+        (agent_dir / SCRIPTS_DIR).mkdir(exist_ok=True)
+        (agent_dir / LOGS_DIR).mkdir(exist_ok=True)
+        lifecycle_content = (
+            "# .agent/lifecycle.yaml — Lifecycle Hooks\n"
+            "apiVersion: aes/v1\n"
+            "kind: Lifecycle\n"
+            f"\nprofile: {domain_config.lifecycle_profile}\n"
+            "\nhooks:\n"
+            "  on_session_start:\n"
+            "    - name: restore-context\n"
+            "      description: Load previous session summary into context\n"
+            "      profile: minimal\n"
+            "      action: script\n"
+            "      command: node .agent/scripts/restore-context.js\n"
+            "      timeout_seconds: 10\n"
+            "      async: false\n"
+            "      fail_strategy: warn\n"
+            "\n"
+            "  on_session_end:\n"
+            "    - name: persist-summary\n"
+            "      description: Save session summary for next session\n"
+            "      profile: minimal\n"
+            "      action: script\n"
+            "      command: node .agent/scripts/persist-summary.js\n"
+            "      timeout_seconds: 15\n"
+            "      async: true\n"
+            "      fail_strategy: warn\n"
+        )
+        (agent_dir / LIFECYCLE_FILE).write_text(lifecycle_content)
+
+    # Continuous learning (agent-integrated domains only)
+    if domain_config.scaffold_learning:
+        (agent_dir / LEARNING_DIR).mkdir(exist_ok=True)
+        (agent_dir / INSTINCTS_DIR / "active").mkdir(parents=True, exist_ok=True)
+        (agent_dir / INSTINCTS_DIR / "candidates").mkdir(exist_ok=True)
+        (agent_dir / INSTINCTS_DIR / "archived").mkdir(exist_ok=True)
+        learning_content = (
+            "# .agent/learning/config.yaml\n"
+            "apiVersion: aes/v1\n"
+            "kind: LearningConfig\n"
+            "\nextraction:\n"
+            "  enabled: true\n"
+            "  auto_extract: true\n"
+            "  min_session_length: 5\n"
+            "  max_candidates_per_session: 3\n"
+            "\nconfidence:\n"
+            "  initial_score: 0.4\n"
+            "  promotion_threshold: 0.6\n"
+            "  promotion_min_validations: 3\n"
+            "  decay_rate_per_week: 0.01\n"
+            "  min_score: 0.3\n"
+            "\ncontext_loading:\n"
+            "  max_instincts_in_context: 10\n"
+            "  sort_by: confidence_score\n"
+            "  token_budget: 2000\n"
+            "  format: compact\n"
+        )
+        (agent_dir / LEARNING_CONFIG_FILE).write_text(learning_content)
+
+    # Rules & conventions (all domains)
+    if domain_config.scaffold_rules:
+        (agent_dir / RULES_DIR).mkdir(exist_ok=True)
+        (agent_dir / RULES_DIR / "common").mkdir(exist_ok=True)
+        rules_content = (
+            "# .agent/rules/rules.yaml\n"
+            "apiVersion: aes/v1\n"
+            "kind: RulesConfig\n"
+            "\nloading:\n"
+            "  always: [common]\n"
+        )
+        (agent_dir / RULES_CONFIG_FILE).write_text(rules_content)
+
+        # Starter rule
+        starter_rule = (
+            "---\n"
+            "name: testing\n"
+            "scope: common\n"
+            "priority: high\n"
+            "---\n\n"
+            "# Testing Standards\n\n"
+            "## Requirements\n"
+            "- All public functions must have unit tests\n"
+            "- No test should take longer than 5 seconds\n\n"
+            "## Patterns\n"
+            "- Use Arrange-Act-Assert structure\n"
+            "- Mock external dependencies\n\n"
+            "## Anti-patterns\n"
+            "- Never test implementation details\n"
+            "- Never share state between tests\n"
+        )
+        (agent_dir / RULES_DIR / "common" / "testing.md").write_text(starter_rule)
+
     # Auto-sync: generate tool-specific config files
     synced_files = run_sync(project_root, force=True, quiet=True)
     _write_mcp_config(project_root)

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/commands/inspect.py

@@ -12,7 +12,11 @@ import yaml
 from rich.console import Console
 from rich.table import Table
 
-from aes.config import AGENT_DIR, BOM_FILE, DECISIONS_DIR
+from aes.config import (
+    AGENT_DIR, BOM_FILE, DECISIONS_DIR,
+    INSTINCTS_DIR, LEARNING_CONFIG_FILE, LIFECYCLE_FILE,
+    RULES_CONFIG_FILE, RULES_DIR,
+)
 from aes.i18n import t
 from aes.registry import (
     fetch_index,
@@ -246,6 +250,45 @@ def _inspect_local(path: str) -> None:
             console.print(f"  {t('inspect.decisions_count', count=dr_count)}")
             console.print()
 
+    # Lifecycle hooks
+    lifecycle_path = agent_dir / LIFECYCLE_FILE
+    if lifecycle_path.exists():
+        lc = _load_yaml(lifecycle_path)
+        hooks = lc.get("hooks", {}) or {}
+        hook_count = sum(
+            len(v) if isinstance(v, list) else (1 if isinstance(v, dict) else 0)
+            for v in hooks.values()
+        )
+        profile = lc.get("profile", "standard")
+        console.print(f"[bold]Lifecycle[/]")
+        console.print(f"  Profile: {profile} | Hooks: {hook_count}")
+        console.print()
+
+    # Learning / instincts
+    learning_config_path = agent_dir / LEARNING_CONFIG_FILE
+    if learning_config_path.exists():
+        lconf = _load_yaml(learning_config_path)
+        extraction = lconf.get("extraction", {}).get("enabled", True)
+        instincts_base = agent_dir / INSTINCTS_DIR
+        active = len(list((instincts_base / "active").glob("*.instinct.yaml"))) if (instincts_base / "active").exists() else 0
+        candidates = len(list((instincts_base / "candidates").glob("*.instinct.yaml"))) if (instincts_base / "candidates").exists() else 0
+        archived = len(list((instincts_base / "archived").glob("*.instinct.yaml"))) if (instincts_base / "archived").exists() else 0
+        console.print(f"[bold]Learning[/]")
+        console.print(f"  Extraction: {'enabled' if extraction else 'disabled'} | Active: {active} | Candidates: {candidates} | Archived: {archived}")
+        console.print()
+
+    # Rules
+    rules_config_path = agent_dir / RULES_CONFIG_FILE
+    if rules_config_path.exists():
+        rconf = _load_yaml(rules_config_path)
+        languages = rconf.get("languages", [])
+        rules_base = agent_dir / RULES_DIR
+        rule_count = len(list(rules_base.glob("**/*.md"))) if rules_base.exists() else 0
+        lang_str = ", ".join(languages) if languages else "auto-detect"
+        console.print(f"[bold]Rules[/]")
+        console.print(f"  Languages: {lang_str} | Rule files: {rule_count}")
+        console.print()
+
     # Summary
     console.print(f"[bold]{t('inspect.summary')}[/]")
     console.print(f"  {t('inspect.skills_count', count=len(skills))}")

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/commands/sync.py

@@ -16,10 +16,15 @@ from rich.console import Console
 from aes.config import (
     AGENT_DIR,
     COMMANDS_DIR,
+    INSTINCTS_DIR,
+    LEARNING_CONFIG_FILE,
+    LIFECYCLE_FILE,
     LOCAL_FILE,
     MANIFEST_FILE,
     MEMORY_DIR,
     PERMISSIONS_FILE,
+    RULES_CONFIG_FILE,
+    RULES_DIR,
     SKILLS_DIR,
 )
 from aes.i18n import t
@@ -224,6 +229,84 @@ def _load_agent_context(project_root: Path) -> AgentContext:
         if local_perms and permissions:
             permissions = _deep_merge(permissions, local_perms)
 
+    # Load lifecycle.yaml
+    lifecycle: Optional[dict] = None
+    lifecycle_path = agent_dir / LIFECYCLE_FILE
+    if lifecycle_path.exists():
+        with open(lifecycle_path) as f:
+            lifecycle = yaml.safe_load(f) or {}
+
+    # Load learning config and active instincts
+    learning_config: Optional[dict] = None
+    active_instincts: List[dict] = []
+    learning_config_path = agent_dir / LEARNING_CONFIG_FILE
+    if learning_config_path.exists():
+        with open(learning_config_path) as f:
+            learning_config = yaml.safe_load(f) or {}
+
+    instincts_active_dir = agent_dir / INSTINCTS_DIR / "active"
+    if instincts_active_dir.exists():
+        max_instincts = 10
+        if learning_config:
+            max_instincts = (
+                learning_config.get("context_loading", {})
+                .get("max_instincts_in_context", 10)
+            )
+        raw_instincts = []
+        for inst_file in sorted(instincts_active_dir.glob("*.instinct.yaml")):
+            with open(inst_file) as f:
+                inst_data = yaml.safe_load(f)
+            if inst_data:
+                raw_instincts.append(inst_data)
+        # Sort by confidence score descending
+        raw_instincts.sort(
+            key=lambda i: i.get("confidence", {}).get("score", 0),
+            reverse=True,
+        )
+        active_instincts = raw_instincts[:max_instincts]
+
+    # Load rules config and rule files
+    rules_config: Optional[dict] = None
+    rules_files: Dict[str, str] = {}
+    rules_config_path = agent_dir / RULES_CONFIG_FILE
+    if rules_config_path.exists():
+        with open(rules_config_path) as f:
+            rules_config = yaml.safe_load(f) or {}
+
+        rules_base = agent_dir / RULES_DIR
+        overrides = rules_config.get("overrides", {})
+
+        # Determine which language directories to load
+        languages = rules_config.get("languages", [])
+        if not languages:
+            # Auto-detect from project root
+            detection = rules_config.get("detection", {})
+            for lang, patterns in detection.items():
+                for pattern in patterns:
+                    if list(project_root.glob(pattern)):
+                        languages.append(lang)
+                        break
+
+        # Always-load directories (default: common)
+        always = rules_config.get("loading", {}).get("always", ["common"])
+        dirs_to_load = list(always) + languages
+
+        for dir_name in dirs_to_load:
+            rule_dir = rules_base / dir_name
+            if not rule_dir.exists():
+                continue
+            for md_file in sorted(rule_dir.glob("*.md")):
+                content = md_file.read_text()
+                # Resolve ${variable} placeholders from overrides
+                rule_name = md_file.stem
+                rule_overrides = overrides.get(rule_name, {})
+                for var_name, var_value in rule_overrides.items():
+                    content = content.replace(
+                        f"${{{var_name}}}", str(var_value)
+                    )
+                key = f"{dir_name}/{md_file.name}"
+                rules_files[key] = content
+
     return AgentContext(
         project_root=project_root,
         agent_dir=agent_dir,
@@ -236,6 +319,11 @@ def _load_agent_context(project_root: Path) -> AgentContext:
         memory_project=memory_project,
         skill_metadata=skill_metadata,
         local_config=local_config,
+        lifecycle=lifecycle,
+        learning_config=learning_config,
+        active_instincts=active_instincts,
+        rules_config=rules_config,
+        rules_files=rules_files,
     )
 
 

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/config.py

@@ -34,6 +34,14 @@ OVERRIDES_DIR = "overrides"
 LOCAL_FILE = "local.yaml"
 LOCAL_EXAMPLE_FILE = "local.example.yaml"
 BOM_FILE = "bom.yaml"
+LIFECYCLE_FILE = "lifecycle.yaml"
+LEARNING_DIR = "learning"
+LEARNING_CONFIG_FILE = "learning/config.yaml"
+INSTINCTS_DIR = "learning/instincts"
+RULES_DIR = "rules"
+RULES_CONFIG_FILE = "rules/rules.yaml"
+SCRIPTS_DIR = "scripts"
+LOGS_DIR = "logs"
 
 # Schema file mapping
 SCHEMA_MAP = {
@@ -44,4 +52,8 @@ SCHEMA_MAP = {
     "permissions": "permissions.schema.json",
     "bom": "bom.schema.json",
     "decision-record": "decision-record.schema.json",
+    "lifecycle": "lifecycle.schema.json",
+    "instinct": "instinct.schema.json",
+    "learning-config": "learning-config.schema.json",
+    "rules-config": "rules-config.schema.json",
 }

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/domains.py

@@ -154,6 +154,12 @@ class DomainConfig:
     heartbeat_checklist: str = ""
     channels: Dict[str, Dict[str, str]] = field(default_factory=dict)
 
+    # Lifecycle / Learning / Rules scaffolding
+    scaffold_lifecycle: bool = True
+    scaffold_learning: bool = False   # True for agent-integrated domains
+    scaffold_rules: bool = True
+    lifecycle_profile: str = "standard"
+
 
 # ---------------------------------------------------------------------------
 # ML domain config — drawn from examples/ml-pipeline
@@ -529,6 +535,7 @@ ML_CONFIG = DomainConfig(
         {"name": "OPTUNA_TIMEOUT", "default": "300", "description": "Seconds per model for HPO"},
         {"name": "OPTUNA_N_TRIALS", "default": "50", "description": "Max trials per model"},
     ],
+    scaffold_learning=True,
 )
 
 
@@ -1338,6 +1345,7 @@ RESEARCH_CONFIG = DomainConfig(
         {"name": "SEMANTIC_SCHOLAR_API_KEY", "default": "", "description": "Semantic Scholar API key (optional, increases rate limits)"},
         {"name": "MAX_ITEMS_PER_RUN", "default": "50", "description": "Maximum items to process per pipeline run"},
     ],
+    scaffold_learning=True,
 )
 
 
@@ -1387,6 +1395,7 @@ AGENT_INTEGRATED_BASE_CONFIG = DomainConfig(
         ),
     ],
     instructions_description="",   # empty -> falls through to TODO scaffolding in template
+    scaffold_learning=True,
 )
 
 
@@ -1476,23 +1485,40 @@ _ASSISTANT_SKILLS = [
     ),
 ]
 
-_ASSISTANT_CONVERSE_COMMAND = CommandDef(
-    id="converse",
-    trigger="/converse",
-    description="Start or resume a conversation session with the assistant",
-    runbook_purpose="Run the assistant's main conversational loop. The agent listens across configured channels, responds to messages, executes skills on demand, and proactively checks heartbeat tasks.",
-    worker_specialty="Multi-platform conversational AI assistant",
+_ASSISTANT_BUILD_COMMAND = CommandDef(
+    id="build",
+    trigger="/build",
+    description="Build the assistant project from scratch: identity, channels, skills, integrations, permissions, tests",
+    runbook_purpose="Construct the complete assistant project. The agent sets up project structure, defines identity and model config, wires channel integrations, implements skills, configures security and permissions, and verifies with tests.",
+    worker_specialty="Constructing assistant projects — identity, channels, skills, integrations",
+    runbook_phases=[
+        {"title": "Project Structure", "content": "Create directory layout matching the AES assistant convention: skills/, config/, scripts/, tests/. Set up pyproject.toml, environment files, and dependency management."},
+        {"title": "Identity & Model", "content": "Configure identity (persona, name, emoji) in agent.yaml. Set up model provider, API key environment variables, and sandbox settings. Create USER.md template for user profile."},
+        {"title": "Channel Integration", "content": "Wire messaging channels (Telegram, Discord, etc.). Set up bot token environment variables, configure channel-specific settings, and implement message routing stubs."},
+        {"title": "Skill Wiring", "content": "Implement skill manifests and runbooks for each configured skill. Wire MCP servers if needed. Set up auto-activation rules and skill dependencies."},
+        {"title": "Security & Permissions", "content": "Configure permissions.yaml with shell confirmation rules, action confirmations, and channel-specific security policies. Set up credential management via environment variables."},
+        {"title": "Tests & Verification", "content": "Write unit tests for skill execution, channel routing, and permission checks. Add integration test that validates the full config. Verify all environment variables are documented."},
+    ],
+)
+
+_ASSISTANT_RUN_COMMAND = CommandDef(
+    id="run",
+    trigger="/run",
+    description="Start the autonomous assistant loop: initialize, monitor channels, execute skills, maintain heartbeat",
+    runbook_purpose="Run the assistant's autonomous agent loop. The agent initializes from stored state, monitors connected channels for messages, executes skills on demand or automatically, persists learnings to memory, and maintains the heartbeat cycle for proactive tasks.",
+    worker_specialty="Running autonomous assistant agents — channel monitoring, skill execution, heartbeat maintenance",
     runbook_phases=[
-        {"title": "Session Setup", "content": "Load user profile from USER.md. Check HEARTBEAT.md for pending tasks. Review recent conversation history for context continuity."},
-        {"title": "Message Processing", "content": "Receive messages from connected channels. Determine intent — is this a greeting, a question, a skill invocation, or a general conversation? Route accordingly."},
-        {"title": "Skill Execution", "content": "When a skill is triggered (explicitly via command or automatically via context match), execute it and return results to the user."},
-        {"title": "Memory & Wrap-up", "content": "Persist important learnings to MEMORY.md. Update AGENTS.md if the user's preferences or context changed."},
+        {"title": "Initialization", "content": "Load user profile from USER.md. Restore session state from MEMORY.md. Check HEARTBEAT.md for pending tasks. Review recent activity log for context continuity."},
+        {"title": "Channel Monitoring", "content": "Connect to configured channels (Telegram, Discord, etc.). Listen for incoming messages. Determine intent — greeting, skill invocation, general conversation, or system command. Route accordingly."},
+        {"title": "Skill Execution", "content": "When a skill is triggered (explicitly via command or automatically via context match), execute it within permission boundaries. Return results to the originating channel. Handle errors gracefully with user-facing messages."},
+        {"title": "Memory & Learning", "content": "Persist important learnings to MEMORY.md. Update active instincts based on interaction patterns. Record conversation context for future sessions."},
+        {"title": "Heartbeat & Maintenance", "content": "Execute heartbeat checklist at configured intervals. Proactively surface important updates (calendar, PRs, unread messages). Respect quiet hours. Log heartbeat results to activity log."},
     ],
 )
 
 ASSISTANT_CONFIG = DomainConfig(
     mode="agent-integrated",
-    workflow_commands=[_ASSISTANT_CONVERSE_COMMAND],
+    workflow_commands=[_ASSISTANT_BUILD_COMMAND, _ASSISTANT_RUN_COMMAND],
 
     # Identity defaults for scaffold
     identity_persona=(
@@ -1518,7 +1544,7 @@ ASSISTANT_CONFIG = DomainConfig(
         "discord": {"enabled": "true", "bot_token_env": "DISCORD_BOT_TOKEN"},
     },
 
-    instructions_description="Personal AI assistant connected to messaging platforms via OpenClaw. Runs 24/7, responds across channels, and executes skills on demand.",
+    instructions_description="Autonomous AI assistant powered by OpenClaw. Runs 24/7, monitors channels, executes skills, and maintains proactive heartbeat tasks.",
     instructions_quick_ref=(
         "```bash\n"
         "aes sync -t openclaw           # generate .openclaw/ config\n"
@@ -1571,6 +1597,7 @@ ASSISTANT_CONFIG = DomainConfig(
         {"name": "TELEGRAM_BOT_TOKEN", "description": "Bot token for Telegram integration"},
         {"name": "DISCORD_BOT_TOKEN", "description": "Bot token for Discord integration"},
     ],
+    scaffold_learning=True,
 )
 
 

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/global_config.py

@@ -27,6 +27,23 @@ def save_global_config(config: dict) -> None:
         yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
 
 
+def get_project_locale(project_path: Path) -> Optional[str]:
+    """Return locale from .agent/local.yaml in project, or None."""
+    local_yaml = project_path / ".agent" / "local.yaml"
+    if not local_yaml.exists():
+        return None
+    try:
+        with open(local_yaml) as f:
+            data = yaml.safe_load(f)
+        if isinstance(data, dict):
+            locale = data.get("locale")
+            if isinstance(locale, str) and locale:
+                return locale
+    except (OSError, yaml.YAMLError):
+        pass
+    return None
+
+
 def get_locale() -> Optional[str]:
     """Return configured locale or None."""
     return load_global_config().get("locale")

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/i18n/_messages.py

@@ -178,7 +178,7 @@ MESSAGES: dict = {
     "init.type_skip": "Skip",
     "init.type_ml": "ML pipeline",
     "init.type_research": "Research / Content pipeline",
-    "init.type_assistant": "Assistant (24/7 AI on messaging platforms)",
+    "init.type_assistant": "Assistant (24/7 autonomous agent)",
     "init.type_custom": "Custom",
     "init.overwrite_warning": "{agent_dir}/ already exists at {path}",
     "init.overwrite_confirm": "Overwrite existing files?",

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/i18n/ja.py

@@ -178,7 +178,7 @@ MESSAGES: dict = {
     "init.type_skip": "スキップ",
     "init.type_ml": "ML パイプライン",
     "init.type_research": "研究 / コンテンツパイプライン",
-    "init.type_assistant": "アシスタント（24時間メッセージングAI）",
+    "init.type_assistant": "アシスタント（24時間自律エージェント）",
     "init.type_custom": "カスタム",
     "init.overwrite_warning": "{path} に {agent_dir}/ が既に存在します",
     "init.overwrite_confirm": "既存のファイルを上書きしますか？",

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/registry.py

@@ -15,6 +15,7 @@ from typing import Dict, List, Optional, Tuple
 REGISTRY_URL = os.environ.get("AES_REGISTRY_URL", "https://registry.aes-official.com")
 INDEX_PATH = "index.json"
 PACKAGES_PATH = "packages"
+_USER_AGENT = "aes-cli/0.11.0"
 
 
 def _validate_registry_url(url: str) -> str:
@@ -131,6 +132,7 @@ def fetch_index(registry_url: Optional[str] = None) -> dict:
     url = f"{base.rstrip('/')}/{INDEX_PATH}"
 
     req = urllib.request.Request(url)
+    req.add_header("User-Agent", _USER_AGENT)
     token = os.environ.get("AES_REGISTRY_KEY")
     if token:
         req.add_header("Authorization", f"Bearer {token}")
@@ -158,6 +160,7 @@ def download_package(
     tarball_path = dest / f"{name}-{version}.tar.gz"
 
     req = urllib.request.Request(url)
+    req.add_header("User-Agent", _USER_AGENT)
     token = os.environ.get("AES_REGISTRY_KEY")
     if token:
         req.add_header("Authorization", f"Bearer {token}")
@@ -206,6 +209,7 @@ def upload_package(
     # Upload tarball — server auto-updates index from X-AES-* headers
     upload_url = f"{base.rstrip('/')}/{PACKAGES_PATH}/{name}/{version}.tar.gz"
     req = urllib.request.Request(upload_url, data=tarball_data, method="PUT")
+    req.add_header("User-Agent", _USER_AGENT)
     req.add_header("Authorization", f"Bearer {token}")
     req.add_header("Content-Type", "application/gzip")
     req.add_header("X-AES-Description", description)

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/scaffold/agent.yaml.jinja

@@ -1,6 +1,6 @@
 {% if domain_config %}
 # .agent/agent.yaml — AES Manifest
-aes: "1.2"
+aes: "1.4"
 
 name: "{{ name }}"
 version: "0.1.0"
@@ -121,7 +121,7 @@ environment:
 {% endif %}
 {% else %}
 # .agent/agent.yaml — AES Manifest
-aes: "1.2"
+aes: "1.4"
 
 name: "{{ name }}"
 version: "0.1.0"

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/scaffold/bom.yaml.jinja

@@ -1,7 +1,7 @@
 # .agent/bom.yaml — Agent Bill of Materials (AI-BOM)
 # Tracks all components this agent depends on.
 # See: https://aes-official.com/spec/11-bom
-aes_bom: "1.2"
+aes_bom: "1.4"
 
 models: []
   # - name: "claude-sonnet-4-20250514"

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/scaffold/instructions.md.jinja

@@ -20,6 +20,7 @@
 {% for rule in domain_config.instructions_rules %}
 {{ loop.index }}. {{ rule }}
 {% endfor %}
+{{ domain_config.instructions_rules|length + 1 }}. **Memory discipline** — update `.agent/memory/operations.md` after every significant action. Run `/memory` at session end. Next session starts blind without this.
 
 ## Primary Workflow
 
@@ -51,7 +52,7 @@ When creating or editing `.agent/` files, follow these formats exactly.
 ### Skill manifest (`.skill.yaml`)
 
 ```yaml
-aes_skill: "1.2"
+aes_skill: "1.4"
 
 id: "my-skill"
 name: "My Skill"
@@ -100,7 +101,7 @@ tags:
 ### Workflow (`.yaml`)
 
 ```yaml
-aes_workflow: "1.2"
+aes_workflow: "1.4"
 
 id: "my-workflow"
 entity: "item"
@@ -165,6 +166,7 @@ Key rules: `aes_skill`/`aes_workflow` version key is **required**. `inputs` is a
      Example: "Python 3.9+ — use `from __future__ import annotations` everywhere." -->
 
 1. **Fail graceful** — Each item wrapped in try/except, log error, continue.
+2. **Memory discipline** — update `.agent/memory/operations.md` after every significant action. Run `/memory` at session end.
 
 ## Domain Model
 
@@ -226,7 +228,7 @@ When creating or editing `.agent/` files, follow these formats exactly.
 ### Skill manifest (`.skill.yaml`)
 
 ```yaml
-aes_skill: "1.2"
+aes_skill: "1.4"
 
 id: "my-skill"
 name: "My Skill"
@@ -275,7 +277,7 @@ tags:
 ### Workflow (`.yaml`)
 
 ```yaml
-aes_workflow: "1.2"
+aes_workflow: "1.4"
 
 id: "my-workflow"
 entity: "item"

{aes_cli-0.7.0 → aes_cli-0.12.0}/aes/scaffold/ja/instructions.md.jinja

@@ -20,6 +20,7 @@
 {% for rule in domain_config.instructions_rules %}
 {{ loop.index }}. {{ rule }}
 {% endfor %}
+{{ domain_config.instructions_rules|length + 1 }}. **メモリ規律** — 重要なアクションの後に `.agent/memory/operations.md` を必ず更新してください。セッション終了時に `/memory` を実行してください。これを怠ると次のセッションが盲目的に開始されます。
 
 ## 主要ワークフロー
 
@@ -165,6 +166,7 @@ idempotency:
      例: "Python 3.9+ — `from __future__ import annotations` を全ファイルで使用。" -->
 
 1. **グレースフルフェイル** — 各アイテムをtry/exceptでラップし、エラーをログして続行。
+2. **メモリ規律** — 重要なアクションの後に `.agent/memory/operations.md` を必ず更新。セッション終了時に `/memory` を実行。
 
 ## ドメインモデル