get-claudia 1.62.0 → 1.64.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.64.0 (2026-06-13)
+
+### Added
+
+- **Status-only wrap for daemon scheduled jobs** (Proposal 11, E5). The seven background jobs (importance decay, pattern detection, consolidation, daily and weekly backups, vault sync, observation ingest) now each write `~/.claudia/loops/<job>_status.md` and check deterministic invariants (the backup jobs assert the backup file exists and is non-empty). It is status-only: a failed invariant is flagged but never halts the job, and a job that raises is recorded and then re-raised, so daemon behavior is unchanged. `memory.system_health` and the `/status` endpoint now surface each job's last verdict plus a flagged count. New module `claudia_memory/loops/job_wrapper.py` (6 tests); health surfacing has 2 tests; full daemon suite stays green (803 passed). This completes Proposal 11.
+
+## 1.63.0 (2026-06-13)
+
+### Added
+
+- **`/build-team` skill** (Proposal 11, E6). A user-invoked counterpart to `hire-agent`: it reads the user's profile, judgment rules, and real task history, then proposes a minimal, tailored agent team in one pass. The proposal runs through the independent `loop-checker` (scored against goal alignment, right-sizing, and a "progressive, not overwhelming" hard constraint, bounded to 2 revisions), is written to a `team_status.md` control file, and is gated on explicit user approval. On approval it scaffolds agent definitions and writes `.bak` siblings for any modified file so the change is reversible. Reuses the existing roster first and never auto-spawns agents or takes external actions. New files: `template-v2/.claude/skills/build-team/SKILL.md` (+ `skill-index.json` entry).
+- **Proactive team review** (Proposal 11, E7). `hire-agent` now distinguishes "add one agent" from "the whole team has drifted." When it detects an archetype shift, a new recurring task class the roster does not cover, or two-plus unused agents, it gently suggests reviewing the team as a unit and routes to `/build-team` for the validated, approval-gated, reversible change. One suggestion at a time; never auto-applied; a review can shrink a team as readily as grow it.
+
 ## 1.62.0 (2026-06-13)
 
 ### Loop engineering foundation (Proposal 11, Phases 1-2)

package/memory-daemon/claudia_memory/daemon/health.py

@@ -152,6 +152,34 @@ def build_status_report(*, db=None) -> dict:
     except Exception:
         report["components"]["scheduler"] = "error"
 
+    # Loop status files (Proposal 11, E5): last verdict per wrapped daemon job.
+    # Purely observational; the overall status is not changed by a flagged job.
+    try:
+        from ..loops.job_wrapper import default_loops_dir
+        from ..loops.status import read_status
+
+        loops = []
+        loops_dir = default_loops_dir()
+        if loops_dir.exists():
+            for status_file in sorted(loops_dir.glob("*_status.md")):
+                try:
+                    fields, _ = read_status(status_file)
+                except Exception:
+                    continue
+                loops.append(
+                    {
+                        "job": fields.get("loop_id", status_file.stem.replace("_status", "")),
+                        "verified": fields.get("verified"),
+                        "verdict": fields.get("checker_verdict"),
+                        "updated_at": fields.get("updated_at"),
+                    }
+                )
+        report["loops"] = loops
+        report["loops_flagged"] = sum(1 for entry in loops if entry.get("verified") is False)
+    except Exception:
+        report["loops"] = []
+        report["loops_flagged"] = 0
+
     return report
 
 

package/memory-daemon/claudia_memory/daemon/scheduler.py

@@ -23,10 +23,24 @@ from ..services.consolidate import (
     run_full_consolidation,
 )
 from ..services.vault_sync import run_vault_sync
+from ..loops.job_wrapper import run_with_status
 
 logger = logging.getLogger(__name__)
 
 
+def _file_nonempty(path) -> "tuple[bool, str]":
+    """Invariant: a backup path must exist and be a non-empty file."""
+    try:
+        p = Path(path)
+        if not p.exists():
+            return False, f"backup file missing: {p}"
+        if p.stat().st_size == 0:
+            return False, f"backup file is empty: {p}"
+        return True, ""
+    except Exception as e:  # noqa: BLE001
+        return False, f"could not stat backup: {e!r}"
+
+
 # Tools whose invocations are always relevant for Claudia's memory
 RELEVANT_TOOL_PREFIXES = {
     "gmail", "google_workspace", "slack", "telegram",
@@ -282,72 +296,99 @@ class MemoryScheduler:
         """Run importance decay daily"""
         try:
             logger.debug("Running daily decay")
-            result = run_decay()
+            result = run_with_status(
+                "daily_decay",
+                run_decay,
+                invariants=[("completed", lambda r: (r is not None, "decay returned no result"))],
+            )
             logger.debug(f"Daily decay complete: {result}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in daily decay")
 
     def _run_pattern_detection(self) -> None:
         """Run pattern detection"""
         try:
             logger.debug("Running pattern detection")
-            patterns = detect_patterns()
+            patterns = run_with_status(
+                "pattern_detection",
+                detect_patterns,
+                invariants=[("is_list", lambda r: (isinstance(r, (list, tuple)), "patterns not a list"))],
+            )
             logger.info(f"Pattern detection complete: {len(patterns)} patterns detected")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in pattern detection")
 
     def _run_full_consolidation(self) -> None:
         """Run full overnight consolidation"""
         try:
             logger.info("Running full consolidation")
-            result = run_full_consolidation()
+            result = run_with_status(
+                "full_consolidation",
+                run_full_consolidation,
+                invariants=[("completed", lambda r: (r is not None, "consolidation returned no result"))],
+            )
             logger.info(f"Full consolidation complete: {result}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in full consolidation")
 
     def _run_daily_backup(self) -> None:
         """Create a labeled daily backup with 7-day retention."""
         try:
             from ..database import get_db
-            backup_path = get_db().backup(label="daily")
+            backup_path = run_with_status(
+                "daily_backup",
+                lambda: get_db().backup(label="daily"),
+                invariants=[("backup_nonempty", lambda p: _file_nonempty(p))],
+            )
             logger.info(f"Daily backup created: {backup_path}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in daily backup")
 
     def _run_weekly_backup(self) -> None:
         """Create a labeled weekly backup with 4-week retention."""
         try:
             from ..database import get_db
-            backup_path = get_db().backup(label="weekly")
+            backup_path = run_with_status(
+                "weekly_backup",
+                lambda: get_db().backup(label="weekly"),
+                invariants=[("backup_nonempty", lambda p: _file_nonempty(p))],
+            )
             logger.info(f"Weekly backup created: {backup_path}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in weekly backup")
 
     def _run_vault_sync(self) -> None:
         """Run Obsidian vault sync + canvas regeneration"""
         try:
-            logger.info("[Safety-net full sync] Running after 4R Reweave inline in consolidation")
             logger.info("Running vault sync")
             from ..config import _project_id
             from ..services.vault_sync import get_vault_path
             from ..services.canvas_generator import CanvasGenerator
 
-            result = run_vault_sync(project_id=_project_id)
-            logger.info(f"Vault sync complete: {result}")
-
-            # Regenerate canvases after sync
-            vault_path = get_vault_path(_project_id)
-            gen = CanvasGenerator(vault_path)
-            canvas_result = gen.generate_all()
-            logger.info(f"Canvas regeneration complete: {canvas_result}")
-        except Exception as e:
+            def _sync_and_canvas():
+                result = run_vault_sync(project_id=_project_id)
+                logger.info(f"Vault sync complete: {result}")
+                vault_path = get_vault_path(_project_id)
+                canvas_result = CanvasGenerator(vault_path).generate_all()
+                logger.info(f"Canvas regeneration complete: {canvas_result}")
+                return result
+
+            run_with_status(
+                "vault_sync",
+                _sync_and_canvas,
+                invariants=[("completed", lambda r: (r is not None, "vault sync returned no result"))],
+            )
+        except Exception:
             logger.exception("Error in vault sync")
 
     def _run_observation_ingest(self) -> None:
         """Ingest observations from PostToolUse hook captures."""
         try:
             from ..database import get_db
-            _ingest_observations(get_db(), self.config)
+            run_with_status(
+                "observation_ingest",
+                lambda: _ingest_observations(get_db(), self.config),
+            )
         except Exception as e:
             logger.debug(f"Error in observation ingestion: {e}")
 

package/memory-daemon/claudia_memory/loops/job_wrapper.py

@@ -0,0 +1,106 @@
+"""Status-only job wrapper for daemon scheduled jobs (Proposal 11, E5).
+
+Wraps a scheduled job so it writes a status file and flags invariant failures,
+without ever changing the job's behavior. This is the "status-only" form of the
+daemon wrap: a failed invariant is recorded but does NOT halt the job, and a job
+that raises is recorded and then re-raised so the daemon's existing error
+handling is preserved.
+
+Each invariant is a ``(name, check)`` pair where ``check(result)`` returns
+``(ok: bool, detail: str)``. A check may inspect the job's return value or
+external state (a backup file on disk, an entity count); it is deterministic, not
+an LLM (see Proposal 11 Decision D2: the daemon has no agent context).
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Iterable
+
+from claudia_memory.loops.status import write_status
+
+Invariant = tuple[str, Callable[[Any], "tuple[bool, str]"]]
+
+
+def default_loops_dir() -> Path:
+    """Where daemon job status files live."""
+    return Path.home() / ".claudia" / "loops"
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def run_with_status(
+    job_id: str,
+    fn: Callable[[], Any],
+    invariants: Iterable[Invariant] = (),
+    status_dir: "str | Path | None" = None,
+    now: "str | None" = None,
+) -> Any:
+    """Run ``fn``, check ``invariants``, write ``<job_id>_status.md``, return result.
+
+    Status-only contract:
+    - A failed invariant flags the run (``verified: false``) but does not halt it;
+      the job's result is still returned.
+    - A job that raises is recorded as unverified and then re-raised, so the
+      daemon's existing error handling is unchanged.
+    """
+    base = Path(status_dir) if status_dir is not None else default_loops_dir()
+
+    error: BaseException | None = None
+    result: Any = None
+    try:
+        result = fn()
+    except Exception as e:  # noqa: BLE001 - recorded below, then re-raised
+        error = e
+
+    checks: list[tuple[str, bool, str]] = []
+    if error is None:
+        for name, check in invariants:
+            try:
+                ok, detail = check(result)
+            except Exception as e:  # noqa: BLE001 - a raising check is a failed check
+                ok, detail = False, f"invariant raised: {e!r}"
+            checks.append((name, bool(ok), str(detail)))
+
+    verified = error is None and all(ok for _, ok, _ in checks)
+    summary, body = _format_verdict(job_id, error, checks)
+
+    write_status(
+        base / f"{job_id}_status.md",
+        {
+            "loop_id": job_id,
+            "verified": verified,
+            "checker_verdict": summary,
+            "next_action": "none" if verified else "review flagged job run",
+            "updated_at": now or _now_iso(),
+        },
+        body=body,
+    )
+
+    if error is not None:
+        raise error
+    return result
+
+
+def _format_verdict(job_id: str, error: "BaseException | None", checks) -> "tuple[str, str]":
+    if error is not None:
+        summary = f"job raised {type(error).__name__}: {error}"
+        return summary, f"# Loop status: {job_id}\n\n{summary}"
+
+    failed = [(name, detail) for name, ok, detail in checks if not ok]
+    if not checks:
+        summary = "ran; no invariants defined"
+    elif not failed:
+        summary = f"all {len(checks)} invariant(s) held"
+    else:
+        names = ", ".join(name for name, _ in failed)
+        summary = f"{len(failed)} of {len(checks)} invariant(s) failed: {names}"
+
+    lines = [f"# Loop status: {job_id}", "", summary]
+    if failed:
+        lines.append("")
+        lines.extend(f"- {name}: {detail}" for name, detail in failed)
+    return summary, "\n".join(lines)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.62.0",
+  "version": "1.64.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/manifest.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.62.0",
-  "generated": "2026-06-14T02:37:03.060Z",
+  "version": "1.64.0",
+  "generated": "2026-06-14T03:04:35.117Z",
   "algorithm": "sha256",
   "files": {
     ".claude/rules/claudia-principles.md": "939e9720421628e7f2e4c8dfbaa4aeb9c1e18e8c6a5379cd6b772a6835b812e5",
@@ -26,6 +26,7 @@
     ".claude/skills/auto-research/references/safety-rules.md": "ae036270e86949ed0f9bface582f6038276adafd3f40a29aa733698111a26683",
     ".claude/skills/brain/SKILL.md": "b87dd93c85923c676292bea67f7a0580ee71eea2bea05426ea6eda951a140d5c",
     ".claude/skills/brain-monitor/SKILL.md": "6e9ce1e6e40bc612a5126d84d743c1fd7ebc596f60575873533479fdcae5b608",
+    ".claude/skills/build-team/SKILL.md": "38a33c8f3e84d0b27f4a4a6ac10cc8318e684b0611a9052a1dd47acbd26874d9",
     ".claude/skills/capability-suggester.md": "06235c8ab062d356cf9b6c18c7aa44ea667e7694983a46e8ae0a9fe32e734944",
     ".claude/skills/capture-meeting/SKILL.md": "815e7587fcd925323c379a6c57e458b3484d034338c1237378641d142c126175",
     ".claude/skills/capture-meeting/evals/basic.yaml": "47c4eb1479aeda8067bc877cebfe8688c9b2bb3ce09297e42375cdf558f412e3",
@@ -44,7 +45,7 @@
     ".claude/skills/fix-duplicates/SKILL.md": "bd3d6aae0bce09bc844ba93f76abb4a97ff0286c6a4da29cd369763864fd4a86",
     ".claude/skills/follow-up-draft/SKILL.md": "49212946cb7b2db39cecd435ab6fcb7cb26cc49666306084d27676543be67281",
     ".claude/skills/growth-check/SKILL.md": "a3ed3f2427f3639f81d16b1a2adfa268bafed795d2b0d02621bc6be318784c24",
-    ".claude/skills/hire-agent.md": "2d60d241592db7d5f30a635d11164802f907b02616fb25170f3f867d5235f067",
+    ".claude/skills/hire-agent.md": "8f46632d6c9b02563a41c00c811e1bcd365614bb5e64d770482f3536fa30e6fe",
     ".claude/skills/inbox-check/SKILL.md": "e2cddc91f72ffc0443d105385d2e8b464f86404a4825d308bd03a68e4ee43726",
     ".claude/skills/ingest-sources/SKILL.md": "938b93d299649db156ad19e9a7bd5d09e950f53bc2eaf8a85386f9fdbca350d0",
     ".claude/skills/ingest-sources/references/extraction-patterns.md": "28d6dc604c4a11eacfe4523e705ad430ba8fe26632bafcccaef656e9618e5aea",
@@ -69,7 +70,7 @@
     ".claude/skills/research/SKILL.md": "0d317e6350b043ee774916b923957f61dbc174e3caafc0187198fa236a2fd28d",
     ".claude/skills/research/references/source-evaluation.md": "64614b7eff83468d7ff76dd640252579f23e69e760969672e9aebe5ceb00f695",
     ".claude/skills/risk-surfacer.md": "b01e6bc7a22df414a7ee7a5e4a108088b5d049646723cc7513fac27a3ba4856c",
-    ".claude/skills/skill-index.json": "043c86f1b07f28bb54db80117437f60fb3d79ad0d18549fdc2c74921b996a56f",
+    ".claude/skills/skill-index.json": "576ebd98fe5f597a45871366d286cd6765d6bdabefe49633c2d00514518c54bc",
     ".claude/skills/skill-router/SKILL.md": "12fc45aebc94d3ead65843cd336a88797a40856e82908cda47256c9cbb4cb60f",
     ".claude/skills/skill-router/references/overlap-clusters.md": "bc819b4892cbdf9919db392825230f4cd4eec546cd7f0c9de6c29a2468ab489a",
     ".claude/skills/structure-generator.md": "dbe70841ab60599a632687aaa3c3652361483df2fe854640c56982b60622eb19",

package/template-v2/.claude/skills/build-team/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: build-team
+description: Propose a personalized team of specialized agents based on the user's profile, goals, and how they actually work. Runs the proposal through an independent Checker, gates on the user's approval, and applies with rollback. Use when the user says "build my team", "set up my agents", "what agents should I have", "design my team", "/build-team", or asks Claudia to tailor her team to their work. See also: `hire-agent` for proactive single-agent suggestions; `structure-generator` for folder scaffolding; `capability-suggester` for command-level additions.
+argument-hint: "[optional: focus area, e.g. 'around client work']"
+invocation: explicit
+effort-level: high
+---
+
+# Build Team
+
+The user-invoked counterpart to `hire-agent`. Where `hire-agent` suggests one
+agent reactively when it spots a repeated pattern, `build-team` looks at the
+whole picture (the user's profile, judgment rules, and real task history) and
+proposes a tailored team in one pass. It is a Maker-Checker flow (Proposal 11,
+E6): Claudia proposes, an independent Checker validates, the user approves, and
+only then is anything written.
+
+## What this is, and is not
+
+- It **proposes and, on approval, scaffolds** agent definitions. It never
+  auto-spawns agents or takes external actions.
+- It **reuses the existing roster first** (the agents in `.claude/agents/`) and
+  adds a new role only when the user's work clearly justifies one.
+- It **starts minimal.** A small team that covers the real work beats a sprawling
+  org chart the user will never use. Growth comes later, from `hire-agent` and
+  the proactive team-update suggestions (Proposal 11, E7).
+- It does **not** duplicate `agent-dispatcher` routing logic, and it does not
+  change how Claudia delegates. It only proposes which agents exist.
+
+## When to fire
+
+Trigger phrases: "build my team", "set up my agents", "what agents should I
+have", "design my team", "/build-team", "tailor your team to my work".
+
+Also the landing spot when a proactive suggestion (from `capability-suggester`
+or `hire-agent`) escalates from "add one agent" to "let's set up your whole
+team".
+
+Do NOT fire for: adding a single agent for one observed pattern (use
+`hire-agent`), folder/structure changes (use `structure-generator`), or
+command/workflow additions (use `capability-suggester`).
+
+## The flow
+
+### Step 1: Read the profile
+
+Gather, silently:
+
+- `context/me.md`: role, archetype, priorities, the shape of a typical week.
+- `context/judgment.yaml` (if it exists): priorities, delegation preferences,
+  surfacing rules. A user who said "just auto-process transcripts" wants a
+  processing agent; a user who said "always run things by me" wants a smaller,
+  more ask-first team.
+- Recent task patterns: what the user has actually asked Claudia to do
+  repeatedly (lean on the same signals `hire-agent` uses, plus `memory_recall`
+  for recurring work). The team should map to real work, not a generic template.
+
+If `context/me.md` does not exist, the user has not onboarded. Route to
+onboarding first; do not propose a team into a vacuum.
+
+### Step 2: Maker proposes the team
+
+Claudia (the Maker) drafts a team:
+
+1. Start from the **minimal seed for the user's archetype** (see the seed table
+   below).
+2. Adjust to the user's actual work: drop a seed role they will not use, add a
+   role a recurring task clearly needs.
+3. For each role, write a one-line **rationale tied to the user's real work**
+   ("You process client transcripts most weeks, so a Document Processor handles
+   the extraction while I keep the judgment"). A role with no concrete rationale
+   does not belong in the proposal.
+4. Every new (non-roster) role must pass the `hire-agent` candidate test:
+   compute-heavy, judgment-light, structured in and out, repeatable. If it needs
+   relationship context or would take external actions, it is not an agent.
+
+### Step 3: The Checker validates (bounded)
+
+Dispatch the `loop-checker` agent with the team proposal as the `artifact` and
+the team rubric below. The Checker scores independently and returns the standard
+verdict JSON (`verified`, `score`, `issues`, `hard_constraint_violated`).
+
+If the Checker returns `verified: false` (most often: too large, or a role that
+needs judgment), the Maker **revises once** based on the issues (usually by
+trimming) and re-checks. Cap at **2 revisions**. This is the same bounded
+Maker-Checker discipline every loop follows; the team proposal is not exempt.
+
+**The team rubric:**
+
+| Dimension | 10 | 0 |
+|-----------|----|----|
+| Goal alignment | Every role maps to a stated priority or a recurring task in the profile | Roles are generic, not tied to this user |
+| Right-sized | The minimum team that covers the work (progressive, not overwhelming) | Sprawling; roles the user will not use |
+| Judgment-safe | Every role is compute-heavy and judgment-light | A role would take external actions or need relationship judgment |
+| Reuse-first | Uses existing roster agents where they fit; new roles only when justified | Invents roles that duplicate existing agents |
+| Tier-correct | Haiku for structured extraction, Sonnet for multi-turn research | Mismatched model tiers |
+
+**Hard constraints** (any one forces `verified: false`): more than 5 roles in a
+first team, or any role that would require relationship judgment or take external
+actions.
+
+### Step 4: Status file + approval gate
+
+Write `team_status.md` in the standard schema (`docs/loop-status-schema.md`):
+`last_input` (one-line profile summary), `maker_proposal` (the team), `score`,
+`checker_verdict`, `verified`, `next_action: await user approval`. Write it to
+the workspace, atomically (temp sibling then rename).
+
+Then present the validated proposal to the user: each role, its model tier, and
+its one-line rationale, plus what is reused vs new. **Write nothing to
+`.claude/agents/` or `.claude/skills/` yet.** This is a Human-Approved action
+(see `claudia-principles.md`). Ask plainly: "Want me to set this team up?"
+
+### Step 5: Apply and rollback (only after explicit approval)
+
+On a clear yes:
+
+1. For each **new** role, scaffold `.claude/agents/<name>.md` using the agent
+   definition format from `hire-agent` (frontmatter: `name`, `description`,
+   `model`, `dispatch-category`, `dispatch-tier`, `auto-dispatch`; body: role,
+   job, output format, constraints).
+2. For any **existing** file you modify (for example, adding the team to
+   `.claude/agents/README.md`), write a `.bak` sibling first, the same
+   mechanism the installer upgrade flow uses. New files need no `.bak`.
+3. Report exactly what was created or changed, and how to undo it: "Rollback by
+   restoring the `.bak` files and deleting the new agent files, or just say
+   'undo the team setup' and I will."
+4. Do not edit `agent-dispatcher.md` routing here. The new agents exist; routing
+   them is the dispatcher's job and can be tuned separately.
+
+Rollback on request: restore each `.bak`, delete each newly created agent file,
+and report what was reverted.
+
+## Minimal seed teams (Proposal 11, D5)
+
+Starting points, not prescriptions. Every seed gets pruned and adjusted to the
+user's actual work in Step 2. All roles are drawn from the existing roster.
+
+| Archetype | Minimal seed |
+|-----------|-------------|
+| Consultant / Advisor | Document Archivist (intake), Document Processor (extract from client docs and transcripts), Research Scout (client and market research) |
+| Executive / Manager | Document Processor (reports and decks), Schedule Analyst (calendar patterns), Research Scout |
+| Founder / Entrepreneur | Research Scout (market and competitor), Document Processor (investor and product docs), Document Archivist |
+| Solo Professional | Document Archivist, Document Processor |
+| Content Creator | Research Scout (topic research), Document Processor (transcript and draft extraction), Canvas Generator (visual) |
+
+Two or three roles is a healthy first team. Five is the ceiling, not the target.
+
+## Safety
+
+- **Approval gate is non-negotiable.** Nothing is written to `agents/` or
+  `skills/` without an explicit yes (Step 4).
+- **Reversible.** `.bak` siblings for any modified file; new files are
+  deletable; "undo the team setup" restores the prior state.
+- **Judgment stays human.** Agents handle processing. Relationship judgment,
+  strategy, and external actions never get delegated to a generated agent.
+- **Minimal by default.** When the Checker and the Maker disagree on size, the
+  smaller team wins. The user can always add more later.
+
+## See also
+
+- `hire-agent` for proactive, single-agent suggestions from one observed pattern.
+- `structure-generator` for the archetype folder structures this composes with.
+- `capability-suggester` for command and workflow additions (not agents).
+- `.claude/agents/README.md` for the current roster and the two-tier model.
+- `.claude/skills/_loop/checker.md` for the Checker brief the validation uses.
+- `docs/loop-status-schema.md` for the `team_status.md` format.

package/template-v2/.claude/skills/hire-agent.md

@@ -147,3 +147,49 @@ After creating a new agent, I monitor:
 If an agent isn't being used or consistently needs my intervention, I might suggest retiring it:
 
 "The LinkedIn Processor hasn't been used in 3 weeks. Want me to remove it to keep things simple?"
+
+## Proactive team review (Proposal 11, E7)
+
+Single-agent suggestions (above) cover incremental growth. Sometimes the whole
+team has drifted from how the user now works, and the right move is to review the
+team as a unit, not bolt on one more agent.
+
+### Drift triggers
+
+I raise a team review (not just a single hire) when I notice:
+
+- **Archetype shift.** The user's `context/me.md` archetype has changed, or their
+  described work no longer matches it (a consultant who is now mostly building a
+  product).
+- **A new recurring task class.** A whole category of repeated work has appeared
+  that the current roster does not cover, not just one task type.
+- **Roster drift.** Two or more agents have gone unused for weeks while the user
+  keeps doing a kind of work by hand.
+
+These are about the shape of the team, not a single gap. One missing agent is a
+`hire-agent` suggestion; a team that no longer fits is a team review.
+
+### Suggest a diff, then route to /build-team
+
+When a drift trigger fires, I suggest the change as a **team diff**, gently and
+as one suggestion:
+
+```
+"The way you work has shifted toward [X] over the last while. Your current team
+was set up for [Y]. Want me to review the whole team? Roughly, I'd add [role],
+retire [unused role], and keep the rest."
+```
+
+If the user says yes, I route to `/build-team`, which does the real work: it reads
+the current profile, proposes the adjusted team, validates it through the Checker,
+shows it for approval, and applies it with `.bak` rollback. I do not re-implement
+the proposal, validation, or apply logic here. This skill only notices the drift
+and offers the review; `build-team` owns the change.
+
+### Discipline
+
+- One suggestion, not a flood. If the user declines, I drop it and do not re-raise
+  until a new, distinct drift signal appears.
+- Never auto-apply. A team review is always proposed, never performed silently.
+- Minimal still wins. A review can shrink a team as readily as grow it; an unused
+  agent is friction, not value.

package/template-v2/.claude/skills/skill-index.json

@@ -17,6 +17,21 @@
         "I have an idea for Claudia"
       ]
     },
+    {
+      "name": "build-team",
+      "path": "build-team/SKILL.md",
+      "description": "Propose a personalized team of specialized agents based on the user profile and real work, validated by an independent Checker, applied on approval with rollback.",
+      "invocation": "explicit",
+      "effort_level": "high",
+      "triggers": ["build my team", "set up my agents", "what agents should I have", "design my team", "/build-team"],
+      "examples": [
+        "build my team",
+        "what agents should I have for my work?",
+        "set up my agents",
+        "design a team around my client work",
+        "tailor your team to how I work"
+      ]
+    },
     {
       "name": "onboarding",
       "path": "onboarding.md",