@blxzer/cursor-trellis 0.3.4 → 0.3.6

package/dist/templates/trellis/scripts/common/parent_orchestration.py

@@ -12,6 +12,7 @@ import re
 from datetime import datetime, timezone
 from pathlib import Path
 
+from .io import read_json
 from .paths import get_repo_root
 from .task_gates import (
     build_spec_update_scaffold,
@@ -22,6 +23,7 @@ from .task_map import (
     PARENT_TERMINAL_STATES,
     get_child_entry,
     load_task_map,
+    resolve_child_map_id,
     validate_parent_child_integration,
 )
 
@@ -100,7 +102,7 @@ def _child_prompt_section(
     *,
     include_artifacts: bool,
 ) -> str:
-    child_name = child_dir.name
+    child_name = child_entry.get("id") or child_dir.name
     parent_rel = _repo_rel(parent_dir, repo_root)
     child_rel = _repo_rel(child_dir, repo_root)
     state = child_entry.get("state", "open")
@@ -164,12 +166,15 @@ def build_child_prompt(
     """Build an implementation prompt for a linked child task."""
     errors: list[str] = []
     repo_root = get_repo_root()
-    child_name = child_dir.name
 
     parent_json = parent_dir / "task.json"
     if not parent_json.is_file():
         return None, [f"parent task.json missing: {parent_dir}"]
 
+    parent_data = read_json(parent_json) or {}
+    child_data = read_json(child_dir / "task.json") or {}
+    child_name = resolve_child_map_id(parent_data, child_dir, child_data)
+
     data, body = load_task_map(parent_dir)
     if data is None:
         return None, ["parent task-map.md missing or invalid"]
@@ -289,6 +294,457 @@ def build_child_prompt(
     return "\n".join(lines), errors
 
 
+
+def _children_by_id(data: dict) -> dict[str, dict]:
+    return {
+        item.get("id"): item
+        for item in data.get("children", [])
+        if isinstance(item, dict) and isinstance(item.get("id"), str)
+    }
+
+
+def _normalize_stages(data: dict) -> tuple[list[dict], list[str], bool]:
+    """Return (stages, errors, used_legacy_default)."""
+    errors: list[str] = []
+    children = _children_by_id(data)
+    raw_stages = data.get("stages") or []
+    if not isinstance(raw_stages, list):
+        return [], ["task-map stages must be a list"], False
+
+    if not raw_stages:
+        units = list(children.keys())
+        return (
+            [{"id": "default", "title": "All children (no stages declared)", "units": units}],
+            [],
+            True,
+        )
+
+    stages: list[dict] = []
+    seen_units: set[str] = set()
+    for idx, stage in enumerate(raw_stages):
+        if not isinstance(stage, dict):
+            errors.append(f"stages[{idx}] must be a mapping")
+            continue
+        stage_id = stage.get("id")
+        if not isinstance(stage_id, str) or not stage_id.strip():
+            errors.append(f"stages[{idx}] missing id")
+            continue
+        units = stage.get("units") or []
+        if not isinstance(units, list):
+            errors.append(f"stage `{stage_id}` units must be a list")
+            continue
+        norm_units: list[str] = []
+        for unit in units:
+            if not isinstance(unit, str) or not unit.strip():
+                errors.append(f"stage `{stage_id}` has invalid unit entry")
+                continue
+            if unit not in children:
+                errors.append(f"stage `{stage_id}` unit `{unit}` not in children[]")
+                continue
+            if unit in seen_units:
+                errors.append(f"unit `{unit}` appears in multiple stages")
+                continue
+            seen_units.add(unit)
+            norm_units.append(unit)
+        stages.append(
+            {
+                "id": stage_id,
+                "title": stage.get("title") if isinstance(stage.get("title"), str) else "",
+                "units": norm_units,
+            }
+        )
+    return stages, errors, False
+
+
+def _unit_readiness(
+    unit_id: str,
+    children_by_id: dict[str, dict],
+) -> tuple[str, list[str]]:
+    entry = children_by_id.get(unit_id) or {}
+    blocked = _unmet_dependencies(entry, children_by_id)
+    return ("ready" if not blocked else "blocked", blocked)
+
+
+_PACK_GENERATED_RE = re.compile(r"^- Generated:\s*(.+)$", re.MULTILINE)
+_PACK_DASH = r"[\u2014\-]"
+_PACK_UNIT_LINE_RE = re.compile(
+    rf"^- `([^`]+)` {_PACK_DASH} `([^`]+)` {_PACK_DASH} \*\*(ready|blocked)\*\*",
+    re.MULTILINE,
+)
+
+
+def _parse_iso_timestamp(raw: str) -> datetime | None:
+    text = raw.strip()
+    if not text:
+        return None
+    normalized = text[:-1] + "+00:00" if text.endswith("Z") else text
+    try:
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError:
+        try:
+            parsed = datetime.strptime(text, "%Y-%m-%d")
+        except ValueError:
+            return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed
+
+
+def _parse_pack_generated(pack_text: str) -> datetime | None:
+    match = _PACK_GENERATED_RE.search(pack_text)
+    if not match:
+        return None
+    return _parse_iso_timestamp(match.group(1))
+
+
+def _last_integrate_event_time(body: str) -> datetime | None:
+    last: datetime | None = None
+    for line in body.splitlines():
+        stripped = line.strip()
+        if not stripped.startswith("- "):
+            continue
+        remainder = stripped[2:]
+        parts = remainder.split(" - ", 1)
+        if len(parts) != 2:
+            continue
+        ts_raw, message = parts[0].strip(), parts[1]
+        lowered = message.lower()
+        if "integration state" not in message and "integrate-through" not in lowered:
+            continue
+        parsed = _parse_iso_timestamp(ts_raw)
+        if parsed is not None and (last is None or parsed > last):
+            last = parsed
+    return last
+
+
+def _pack_ready_units(pack_text: str) -> set[str]:
+    ready: set[str] = set()
+    for unit_id, _state, readiness in _PACK_UNIT_LINE_RE.findall(pack_text):
+        if readiness == "ready":
+            ready.add(unit_id)
+    return ready
+
+
+def _expected_pack_ready_units(
+    data: dict,
+    children_by_id: dict[str, dict],
+) -> set[str]:
+    stages, _, _ = _normalize_stages(data)
+    ready: set[str] = set()
+    for stage in stages:
+        for unit in stage.get("units") or []:
+            if not isinstance(unit, str):
+                continue
+            readiness, _ = _unit_readiness(unit, children_by_id)
+            if readiness == "ready":
+                ready.add(unit)
+    return ready
+
+
+def _pack_unit_states_mismatch(
+    pack_text: str,
+    children_by_id: dict[str, dict],
+) -> bool:
+    for unit_id, pack_state, _readiness in _PACK_UNIT_LINE_RE.findall(pack_text):
+        entry = children_by_id.get(unit_id) or {}
+        current_state = entry.get("state", "?")
+        if str(current_state) != pack_state:
+            return True
+    return False
+
+
+def _compute_stale_pack(
+    parent_dir: Path,
+    data: dict,
+    body: str,
+    children_by_id: dict[str, dict],
+) -> bool | None:
+    pack_path = parent_dir / "child-prompts" / "PACK.md"
+    if not pack_path.is_file():
+        return None
+    try:
+        pack_text = pack_path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    generated = _parse_pack_generated(pack_text)
+    if generated is None:
+        return None
+
+    stale = False
+    last_integrate = _last_integrate_event_time(body)
+    if last_integrate is not None and generated < last_integrate:
+        stale = True
+    if _pack_unit_states_mismatch(pack_text, children_by_id):
+        stale = True
+    expected_ready = _expected_pack_ready_units(data, children_by_id)
+    if _pack_ready_units(pack_text) != expected_ready:
+        stale = True
+    return stale
+
+
+def _compute_newly_ready(children_by_id: dict[str, dict]) -> list[str]:
+    ready_ids: list[str] = []
+    for unit_id in sorted(children_by_id):
+        entry = children_by_id[unit_id]
+        if entry.get("state") != "open":
+            continue
+        readiness, _ = _unit_readiness(unit_id, children_by_id)
+        if readiness == "ready":
+            ready_ids.append(unit_id)
+    return ready_ids
+
+
+def _child_prompt_filename(unit_id: str) -> str:
+    """Flat filename for child-prompts (nested slash unit ids use `--`)."""
+    return f"{unit_id.replace('/', '--')}.md"
+
+
+def build_publish_pack(
+    parent_dir: Path,
+    *,
+    stage_id: str | None = None,
+    mode: str = "inline",
+    dry_run: bool = False,
+) -> tuple[str | None, list[str]]:
+    """Build campaign PACK index + per-unit prompts under child-prompts/."""
+    errors: list[str] = []
+    repo_root = get_repo_root()
+    parent_rel = _repo_rel(parent_dir, repo_root)
+
+    if not (parent_dir / "task.json").is_file():
+        return None, [f"parent task.json missing: {parent_dir}"]
+
+    data, _ = load_task_map(parent_dir)
+    if data is None:
+        return None, ["parent task-map.md missing or invalid"]
+
+    stages, stage_errors, legacy = _normalize_stages(data)
+    errors.extend(stage_errors)
+    if errors:
+        return None, errors
+
+    if stage_id:
+        stages = [s for s in stages if s.get("id") == stage_id]
+        if not stages:
+            return None, [f"unknown stage id: {stage_id}"]
+
+    children_by_id = _children_by_id(data)
+    prompts_dir = parent_dir / "child-prompts"
+    ready_rows: list[tuple[str, str, str]] = []
+    blocked_rows: list[tuple[str, str, list[str]]] = []
+
+    pack_lines = [
+        f"# Campaign PACK — `{parent_dir.name}`",
+        "",
+        f"- Parent: `{parent_rel}`",
+        f"- Generated: {_utc_now()}",
+        f"- Mode: `{mode}`",
+        "- Path rule: every worker must `task.py select <explicit-child-path>`; "
+        "do not rely on selected_task inheritance across windows.",
+        "",
+        "## Manual window path (PACK)",
+        "",
+        "1. Run `publish-pack` (this file) on the Parent.",
+        "2. For each **ready** unit: IDE **New Chat** or Agents Window → paste `child-prompts/<child>.md`.",
+        "3. In that session run `python ./.cstl/scripts/task.py select <child-path>`.",
+        "4. Parent retains `review-child` / `integrate-child`. PACK is not RUN auto-dispatch.",
+        "",
+        "## Stages",
+        "",
+    ]
+    if legacy:
+        pack_lines.append(
+            "> Warning: no `stages:` in task-map; using implicit `default` stage "
+            "with all children. Declare `stages:` for HYBRID campaign packs."
+        )
+        pack_lines.append("")
+
+    written: list[str] = []
+    for stage in stages:
+        sid = stage["id"]
+        title = stage.get("title") or ""
+        heading = f"### `{sid}`" + (f" — {title}" if title else "")
+        pack_lines.append(heading)
+        pack_lines.append("")
+        for unit in stage.get("units") or []:
+            readiness, blocked = _unit_readiness(unit, children_by_id)
+            child_dir = parent_dir.parent / unit
+            child_rel = _repo_rel(child_dir, repo_root)
+            state = (children_by_id.get(unit) or {}).get("state", "?")
+            if readiness == "ready":
+                prompt, prompt_errors = build_child_prompt(
+                    parent_dir,
+                    child_dir,
+                    include_artifacts=False,
+                    mode=mode,
+                )
+                if prompt_errors or not prompt:
+                    errors.extend(prompt_errors or [f"could not build prompt for `{unit}`"])
+                    continue
+                out_name = _child_prompt_filename(unit)
+                out_rel = f"{parent_rel}/child-prompts/{out_name}"
+                if not dry_run:
+                    prompts_dir.mkdir(parents=True, exist_ok=True)
+                    (prompts_dir / out_name).write_text(prompt + "\n", encoding="utf-8")
+                    written.append(out_rel)
+                ready_rows.append((sid, unit, out_rel))
+                pack_lines.append(
+                    f"- `{unit}` — `{state}` — **ready** — prompt: `child-prompts/{out_name}` "
+                    f"(select `{child_rel}`)"
+                )
+            else:
+                blocked_rows.append((sid, unit, blocked))
+                stub = "\n".join(
+                    [
+                        f"# BLOCKED — `{unit}`",
+                        "",
+                        f"- Parent: `{parent_rel}`",
+                        f"- Child: `{child_rel}`",
+                        f"- Stage: `{sid}`",
+                        "- Do not start implementation until dependencies reach "
+                        "`integrated` or `cancelled`.",
+                        "",
+                        "Unmet dependencies:",
+                        *[f"- {item}" for item in blocked],
+                        "",
+                    ]
+                )
+                out_name = _child_prompt_filename(unit)
+                out_rel = f"{parent_rel}/child-prompts/{out_name}"
+                if not dry_run:
+                    prompts_dir.mkdir(parents=True, exist_ok=True)
+                    (prompts_dir / out_name).write_text(stub, encoding="utf-8")
+                    written.append(out_rel)
+                pack_lines.append(
+                    f"- `{unit}` — `{state}` — **blocked** — {', '.join(blocked)}"
+                )
+        pack_lines.append("")
+
+    pack_lines.extend(["## Ready", ""])
+    if ready_rows:
+        for sid, unit, path in ready_rows:
+            pack_lines.append(f"- `{sid}` / `{unit}` → `{path}`")
+    else:
+        pack_lines.append("(none)")
+    pack_lines.extend(["", "## Blocked", ""])
+    if blocked_rows:
+        for sid, unit, deps in blocked_rows:
+            pack_lines.append(f"- `{sid}` / `{unit}` — {', '.join(deps)}")
+    else:
+        pack_lines.append("(none)")
+    pack_lines.append("")
+
+    pack_body = "\n".join(pack_lines)
+    pack_rel = f"{parent_rel}/child-prompts/PACK.md"
+    if not dry_run:
+        prompts_dir.mkdir(parents=True, exist_ok=True)
+        (prompts_dir / "PACK.md").write_text(pack_body + "\n", encoding="utf-8")
+        written.append(pack_rel)
+
+    if errors:
+        return None, errors
+
+    summary = [
+        f"# publish-pack — `{parent_dir.name}`",
+        "",
+        f"- Parent: `{parent_rel}`",
+        f"- dry_run: {dry_run}",
+        f"- legacy_no_stages: {legacy}",
+        f"- ready: {len(ready_rows)}",
+        f"- blocked: {len(blocked_rows)}",
+        f"- pack_index: `{pack_rel}`",
+        "",
+    ]
+    if written:
+        summary.append("## Written")
+        summary.append("")
+        for path in written:
+            summary.append(f"- `{path}`")
+        summary.append("")
+    elif dry_run:
+        summary.append("(dry-run: no files written)")
+        summary.append("")
+    summary.append(pack_body)
+    return "\n".join(summary), []
+
+
+def build_parent_status_dict(parent_dir: Path) -> dict | None:
+    """Machine-readable parent orchestration snapshot (campaign UI / MCP)."""
+    repo_root = get_repo_root()
+    parent_rel = _repo_rel(parent_dir, repo_root)
+    data, _ = load_task_map(parent_dir)
+    if data is None:
+        return None
+
+    children_by_id = _children_by_id(data)
+    stages, stage_errors, legacy = _normalize_stages(data)
+    _, body = load_task_map(parent_dir)
+    stale_pack = _compute_stale_pack(parent_dir, data, body, children_by_id)
+    newly_ready = _compute_newly_ready(children_by_id)
+
+    stage_rows: list[dict] = []
+    for stage in stages:
+        units: list[dict] = []
+        for unit in stage.get("units") or []:
+            entry = children_by_id.get(unit) or {}
+            readiness, blocked = _unit_readiness(unit, children_by_id)
+            units.append(
+                {
+                    "id": unit,
+                    "state": entry.get("state", "?"),
+                    "readiness": readiness,
+                    "blockedBy": blocked,
+                }
+            )
+        stage_rows.append(
+            {
+                "id": stage["id"],
+                "title": stage.get("title") or "",
+                "units": units,
+            }
+        )
+
+    children_rows: list[dict] = []
+    for child in data.get("children") or []:
+        if not isinstance(child, dict):
+            continue
+        cid = child.get("id")
+        if not isinstance(cid, str):
+            continue
+        child_dir = parent_dir.parent / cid
+        children_rows.append(
+            {
+                "id": cid,
+                "state": child.get("state", "?"),
+                "dependsOn": child.get("depends_on") or [],
+                "touches": child.get("touches") or [],
+                "isolation": child.get("isolation"),
+                "branch": child.get("branch"),
+                "worktreePath": child.get("worktree_path"),
+                "evidence": child.get("evidence"),
+                "ref": child.get("ref"),
+                "verifyMd": (child_dir / "verify.md").is_file(),
+                "handoffMd": (child_dir / "handoff.md").is_file(),
+            }
+        )
+
+    return {
+        "id": parent_dir.name,
+        "path": parent_rel,
+        "contractEpoch": data.get("contract_epoch"),
+        "executionTopology": data.get("execution_topology"),
+        "mergeLimit": data.get("merge_limit"),
+        "stages": stage_rows,
+        "children": children_rows,
+        "integrationQueue": data.get("integration_queue") or [],
+        "stageErrors": stage_errors,
+        "legacyStages": legacy,
+        "stalePack": stale_pack,
+        "newlyReady": newly_ready,
+    }
+
+
 def build_parent_status(parent_dir: Path) -> str:
     """Render a parent task-map status summary for the reviewer."""
     repo_root = get_repo_root()
@@ -305,10 +761,48 @@ def build_parent_status(parent_dir: Path) -> str:
         f"- execution_topology: {data.get('execution_topology', '?')}",
         f"- merge_limit: {data.get('merge_limit', '?')}",
         "",
-        "## Children",
-        "",
     ]
 
+    children_by_id = _children_by_id(data)
+    stages, stage_errors, legacy = _normalize_stages(data)
+    _, body = load_task_map(parent_dir)
+    stale_pack = _compute_stale_pack(parent_dir, data, body, children_by_id)
+    newly_ready = _compute_newly_ready(children_by_id)
+    lines.append("## Pack freshness")
+    lines.append("")
+    lines.append(f"- stalePack: {stale_pack}")
+    if newly_ready:
+        lines.append(f"- newlyReady: {', '.join(newly_ready)}")
+    else:
+        lines.append("- newlyReady: (none)")
+    lines.append("")
+    lines.append("## Stages")
+    lines.append("")
+    if stage_errors:
+        for err in stage_errors:
+            lines.append(f"- error: {err}")
+        lines.append("")
+    elif legacy:
+        lines.append("stages: (none declared — implicit `default` for publish-pack)")
+        lines.append("")
+    else:
+        for stage in stages:
+            sid = stage["id"]
+            title = stage.get("title") or ""
+            heading = f"### `{sid}`" + (f" — {title}" if title else "")
+            lines.append(heading)
+            for unit in stage.get("units") or []:
+                entry = children_by_id.get(unit) or {}
+                state = entry.get("state", "?")
+                readiness, blocked = _unit_readiness(unit, children_by_id)
+                if readiness == "ready":
+                    lines.append(f"- `{unit}` — `{state}` — ready")
+                else:
+                    lines.append(f"- `{unit}` — `{state}` — blocked ({', '.join(blocked)})")
+            lines.append("")
+
+    lines.extend(["## Children", ""])
+
     children = data.get("children") or []
     if not children:
         lines.append("(no children in task-map)")
@@ -354,6 +848,7 @@ def build_parent_status(parent_dir: Path) -> str:
     lines.append("")
     lines.append("```bash")
     lines.append(f"python ./.cstl/scripts/task.py parent-status {parent_rel}")
+    lines.append(f"python ./.cstl/scripts/task.py publish-pack {parent_rel}")
     lines.append(f"python ./.cstl/scripts/task.py generate-child-prompt {parent_rel} <child> --mode subagent")
     lines.append(f"python ./.cstl/scripts/task.py generate-child-prompt {parent_rel} <child> --mode inline")
     lines.append(f"python ./.cstl/scripts/task.py review-child {parent_rel} <child> --check")
@@ -451,7 +946,7 @@ def build_review_report(
     notes: str | None,
 ) -> tuple[str, list[str], dict]:
     """Build review summary and validate integration transitions for a decision."""
-    child_name = child_dir.name
+    child_name = resolve_child_map_id(parent_data, child_dir, child_data)
     summary = _summarize_handoff(child_dir)
     errors: list[str] = []
     actions: dict = {"integrate": None, "gates": []}

package/dist/templates/trellis/scripts/common/retrieval_agent_instructions.py

@@ -138,10 +138,15 @@ def _cursor_step_for_route(
         return (
             f"使用 **codegraph_search**，路径侧重 `extensions/`，符号 `{symbol}`。"
         )
+    if route_id == "definition-jump-native":
+        return (
+            f"**Prefer 原生**：用 **Grep** 定位 `{symbol}` 的定义行，再用 **Read** 验证文件与行号 "
+            "（Agent 无 GO_TO_DEFINITION）。仅当跨包 trap、重载歧义或需 blast 时再上 codegraph。"
+        )
     if route_id == "lsp-navigation":
         return (
-            f"使用 **codegraph_node**（`includeCode=true`）或 **codegraph_search** 定位 `{symbol}` "
-            "的定义/引用（Agent 无 GO_TO_DEFINITION）；再用 **Read** 验证行号与正文。"
+            f"**Own/codegraph**：用 **codegraph_explore** / **codegraph_search** 定位 `{symbol}` "
+            "的定义/引用（Grep+Read 不足或计划含 trap/blast 时）；再用 **Read** 验证行号与正文。"
         )
     if role == "ast" or route_id in ("ast-codegraph",):
         return (
@@ -294,7 +299,8 @@ def render_agent_instructions(
 
     lines.append("")
     lines.append(
-        "**codegraph 独用场景**：调用链、跨包 trap、extension 符号、影响面、定义/引用定位；"
+        "**Prefer / Adapt / Own**：定义跳转 Prefer **Grep → Read**；诊断 **ReadLints**；"
+        "codegraph 独用调用链、跨包 trap、extension 符号、影响面，以及 Grep+Read 歧义时的定义/引用；"
         "纯字面搜索用 Grep（勿用 GO_TO_DEFINITION，Agent 未暴露）。"
     )
 

package/dist/templates/trellis/scripts/common/session_context.py

@@ -20,7 +20,9 @@ import subprocess
 from pathlib import Path
 
 from .active_task import resolve_context_key
-from .config import get_git_packages
+from .artifact_locale import artifact_locale_summary, resolve_artifact_locale
+from .config import get_git_packages, get_journal_snippet_enabled
+from .session_memory import get_latest_journal_summary
 from .git import run_git
 from .packages_context import get_packages_section
 from .tasks import iter_active_tasks, load_task, get_all_statuses, children_progress
@@ -46,7 +48,7 @@ from .paths import (
 # =============================================================================
 
 _PACKAGE_NAME = "@blxzer/cursor-trellis"
-_PYTHON_CMD = "python3"
+_PYTHON_CMD = "python"
 _UPDATE_CHECK_TIMEOUT_SECONDS = 1.0
 _VERSION_RE = re.compile(
     r"^\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?\s*$"
@@ -797,6 +799,10 @@ def get_context_json(repo_root: Path | None = None) -> dict:
 
     result = {
         "developer": developer or "",
+        "artifactLocale": resolve_artifact_locale(
+            repo_root / selected_task if selected_task else None,
+            repo_root,
+        ),
         "git": {
             "isRepo": root_git_info["isRepo"],
             "branch": root_git_info["branch"],
@@ -819,9 +825,26 @@ def get_context_json(repo_root: Path | None = None) -> dict:
     if pkg_git_info:
         result["packageGit"] = pkg_git_info
 
+    if get_journal_snippet_enabled(repo_root):
+        result["journal"]["snippet"] = _resolve_journal_snippet(
+            repo_root,
+            journal_file,
+            developer,
+        )
+
     return result
 
 
+def _resolve_journal_snippet(
+    repo_root: Path,
+    journal_file: Path | None,
+    developer: str | None,
+) -> str:
+    if not journal_file or not developer:
+        return ""
+    return get_latest_journal_summary(journal_file, repo_root, developer)
+
+
 def output_json(repo_root: Path | None = None) -> None:
     """Output context in JSON format.
 
@@ -860,11 +883,12 @@ def get_context_text(repo_root: Path | None = None) -> str:
     lines.append("## DEVELOPER")
     if not developer:
         lines.append(
-            f"ERROR: Not initialized. Run: python3 ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/init_developer.py <name>"
+            f"ERROR: Not initialized. Run: python ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/init_developer.py <name>"
         )
         return "\n".join(lines)
 
     lines.append(f"Name: {developer}")
+    lines.append(artifact_locale_summary(repo_root))
     lines.append("")
 
     root_git_info = _collect_root_git_info(repo_root)
@@ -966,6 +990,10 @@ def get_context_text(repo_root: Path | None = None) -> str:
         lines.append(f"Line count: {journal_lines} / 2000")
         if journal_lines > 1800:
             lines.append("[!] WARNING: Approaching 2000 line limit!")
+        if get_journal_snippet_enabled(repo_root):
+            snippet = _resolve_journal_snippet(repo_root, journal_file, developer)
+            if snippet:
+                lines.append(f"Recent snippet: {snippet}")
     else:
         lines.append("No journal file found")
     lines.append("")
@@ -1085,7 +1113,7 @@ def get_context_text_record(repo_root: Path | None = None) -> str:
     developer = get_developer(repo_root)
     if not developer:
         lines.append(
-            f"ERROR: Not initialized. Run: python3 ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/init_developer.py <name>"
+            f"ERROR: Not initialized. Run: python ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/init_developer.py <name>"
         )
         return "\n".join(lines)