memstack-skill-loader 4.9.0__tar.gz → 4.10.0__tar.gz

{memstack_skill_loader-4.9.0/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.9.0
+Version: 4.10.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0

{memstack_skill_loader-4.9.0 → memstack_skill_loader-4.10.0}/README.md

@@ -1,6 +1,6 @@
 # MemStack™ Skill Loader
 
-**129 skills for Claude Code:** 85 free + 44 Pro exclusive. Vector-indexed so CC loads only the skill it needs, saving your context window.
+**130 skills for Claude Code:** 86 free + 44 Pro exclusive. Vector-indexed so CC loads only the skill it needs, saving your context window.
 
 ## Quick Start (5 minutes)
 
@@ -11,7 +11,7 @@ MemStack installs in two parts: the **skills** (via the Claude Code plugin marke
 /plugin marketplace add cwinvestments/memstack
 /plugin install memstack@cwinvestments-memstack
 ```
-Run both commands. This unlocks the 85 free skills right away.
+Run both commands. This unlocks the 86 free skills right away.
 
 > **SSH error?** ("Host key verification failed" on a fresh server that's never used GitHub over SSH.)
 > **Default fix · (in terminal)** — rewrite GitHub to HTTPS, then retry Step 1:
@@ -53,7 +53,7 @@ If this doesn't match Step 2's interpreter, the server won't launch (you'll see
 ```
 activate_license(key="your-key", email="you@example.com")
 ```
-Use `key="free"` for the free tier, or your Pro key from [memstack.pro](https://memstack.pro) to unlock all 44 Pro skills (85 free + 44 Pro = 129 total). Then type `list skills` to verify.
+Use `key="free"` for the free tier, or your Pro key from [memstack.pro](https://memstack.pro) to unlock all 44 Pro skills (86 free + 44 Pro = 130 total). Then type `list skills` to verify.
 
 > To override the skills path, set `MEMSTACK_SKILLS_DIR=/path/to/your/memstack/skills`.
 
@@ -86,7 +86,7 @@ sudo apt install python3-pip
 
 ## How It Works
 
-MCP server that vector-indexes all 129 MemStack™ skills so Claude Code can call `find_skill("deploy to Railway")` and load **only** the relevant skill on demand, instead of all skills consuming context window.
+MCP server that vector-indexes all 130 MemStack™ skills so Claude Code can call `find_skill("deploy to Railway")` and load **only** the relevant skill on demand, instead of all skills consuming context window.
 
 - **No Anthropic API key required:** skill search and indexing run locally — the only outbound network call is license validation, which contacts the MemStack license server on session start ([Data and privacy](#data-and-privacy))
 - **Pro skills auto-detected:** set your license key and they appear automatically

{memstack_skill_loader-4.9.0 → memstack_skill_loader-4.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memstack-skill-loader"
-version = "4.9.0"
+version = "4.10.0"
 description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
 requires-python = ">=3.10"
 dependencies = [

{memstack_skill_loader-4.9.0 → memstack_skill_loader-4.10.0}/src/memstack_skill_loader/__init__.py

@@ -1,3 +1,3 @@
 """MemStack Skill Loader — MCP server for semantic skill search."""
 
-__version__ = "4.9.0"
+__version__ = "4.10.0"

{memstack_skill_loader-4.9.0 → memstack_skill_loader-4.10.0}/src/memstack_skill_loader/agent_runner.py

@@ -1026,7 +1026,8 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
                    model: str = "", disallowed_tools: Optional[list[str]] = None,
                    session: Optional["Session"] = None,
                    display_name: str = "",
-                   execution_mode: str = "subscription") -> tuple[str, int, int, int]:
+                   execution_mode: str = "subscription",
+                   extra_settings: Optional[str] = None) -> tuple[str, int, int, int]:
     """Run a single claude interactive streaming invocation and return the output."""
     claude_bin = shutil.which("claude")
     if not claude_bin:
@@ -1040,6 +1041,10 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
     if disallowed_tools:
         patterns = ",".join(f"mcp__{srv}__*" for srv in disallowed_tools)
         cmd.extend(["--disallowedTools", patterns])
+    if extra_settings:
+        # Inline --settings JSON (e.g. Builder git-deny PreToolUse hook). Only
+        # passed by Builder call sites; Manager/Reviewer never provide this.
+        cmd.extend(["--settings", extra_settings])
 
     if log_path:
         log_path.parent.mkdir(parents=True, exist_ok=True)
@@ -1385,10 +1390,53 @@ def _parse_subtasks(text: str) -> list[tuple[str, str]]:
     return []
 
 
+def _build_builder_hook_settings() -> str:
+    """Inline --settings JSON that registers the Builder git-deny PreToolUse hook.
+
+    The hook script ships inside this package (hooks/deny_git.py). Its absolute
+    path MUST use forward slashes: backslashes get stripped when the settings
+    command string is executed on Windows, which mangles the path and breaks
+    the hook (see smoke test)."""
+    hook_script = os.path.join(os.path.dirname(__file__), "hooks", "deny_git.py").replace("\\", "/")
+    return json.dumps({
+        "hooks": {"PreToolUse": [{"matcher": "Bash",
+            "hooks": [{"type": "command", "command": f"python {hook_script}"}]}]}
+    })
+
+
+def _git_head(working_dir: str) -> Optional[str]:
+    """Return the current HEAD commit SHA, or None if it can't be read."""
+    try:
+        r = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=working_dir, capture_output=True, text=True, timeout=30,
+        )
+        return r.stdout.strip() if r.returncode == 0 else None
+    except Exception:
+        return None
+
+
+def _git_reset_soft(working_dir: str, ref: str) -> bool:
+    """Best-effort `git reset --soft <ref>` to move HEAD back without touching
+    the working tree. Used to undo a Builder commit so the orchestrator remains
+    the single committer. Returns True on success."""
+    try:
+        r = subprocess.run(
+            ["git", "reset", "--soft", ref],
+            cwd=working_dir, capture_output=True, text=True, timeout=30,
+        )
+        return r.returncode == 0
+    except Exception:
+        return False
+
+
 def _orchestrate(session: Session) -> None:
     """Run the Manager → Builder → Reviewer loop."""
     session._start_monotonic = time.monotonic()
     session_log_dir = STATE_DIR / "sessions" / session.session_id
+    # Builder-only git-deny hook (Layer 1). Built once, passed to Builder
+    # _invoke_agent calls via extra_settings; never to Manager/Reviewer.
+    builder_hook_settings = _build_builder_hook_settings()
 
     try:
         # Load execution modes and custom display names for this run
@@ -1512,6 +1560,9 @@ def _orchestrate(session: Session) -> None:
                     )
                     if session.user_name:
                         builder_prompt = f"The user's name is {session.user_name}.\n\n" + builder_prompt
+                    # Layer 2 backstop: snapshot HEAD before the Builder runs so
+                    # we can detect any git activity that slips past the hook.
+                    pre_head = _git_head(session.working_dir)
                     try:
                         if agent_modes["builder"] == "subscription":
                             builder_output, b_in, b_out, b_ctx = _invoke_agent(
@@ -1524,6 +1575,7 @@ def _orchestrate(session: Session) -> None:
                                 session=session,
                                 display_name=display_names["builder"],
                                 execution_mode=agent_modes["builder"],
+                                extra_settings=builder_hook_settings,
                             )
                         else:
                             builder_output, b_in, b_out = _invoke_api_agent(
@@ -1565,6 +1617,24 @@ def _orchestrate(session: Session) -> None:
                     if session.status == "stopped":
                         break
 
+                    # Layer 2 backstop: if the Builder moved HEAD (commit, reset,
+                    # checkout, etc.) it violated the no-git policy. Soft-undo and
+                    # fail the subtask rather than trusting its work.
+                    post_head = _git_head(session.working_dir)
+                    if pre_head and post_head and post_head != pre_head:
+                        undone = _git_reset_soft(session.working_dir, pre_head)
+                        reason = (
+                            f"Builder ran git and moved HEAD (pre={pre_head[:8]} "
+                            f"post={post_head[:8]}) - blocked by policy"
+                            + ("; HEAD soft-reset to pre-state" if undone else "")
+                        )
+                        print(f"[agent-runner] POLICY VIOLATION: {reason}", file=sys.stderr)
+                        session.add_message("system", "all", f"Subtask {idx} of {len(subtasks)} failed: {title} - {reason}")
+                        subtasks_failed += 1
+                        subtask_results.append(f"Subtask {idx}: FAILED - {title} ({reason})")
+                        session._save_state()
+                        break
+
                     if not builder_output or len(builder_output.strip()) < 20:
                         try:
                             diff_result = subprocess.run(
@@ -1784,6 +1854,9 @@ def _orchestrate(session: Session) -> None:
             )
             if session.user_name:
                 builder_prompt = f"The user's name is {session.user_name}.\n\n" + builder_prompt
+            # Layer 2 backstop: snapshot HEAD before the Builder runs so we can
+            # detect any git activity that slips past the hook.
+            pre_head = _git_head(session.working_dir)
             try:
                 if agent_modes["builder"] == "subscription":
                     builder_output, b_in, b_out, b_ctx = _invoke_agent(
@@ -1796,6 +1869,7 @@ def _orchestrate(session: Session) -> None:
                         session=session,
                         display_name=display_names["builder"],
                         execution_mode=agent_modes["builder"],
+                        extra_settings=builder_hook_settings,
                     )
                 else:
                     builder_output, b_in, b_out = _invoke_api_agent(
@@ -1836,6 +1910,25 @@ def _orchestrate(session: Session) -> None:
                 session._save_state()
                 return
 
+            # Layer 2 backstop: if the Builder moved HEAD (commit, reset,
+            # checkout, etc.) it violated the no-git policy. Soft-undo and fail
+            # the task rather than trusting its work.
+            post_head = _git_head(session.working_dir)
+            if pre_head and post_head and post_head != pre_head:
+                undone = _git_reset_soft(session.working_dir, pre_head)
+                reason = (
+                    f"Builder ran git and moved HEAD (pre={pre_head[:8]} "
+                    f"post={post_head[:8]}) - blocked by policy"
+                    + ("; HEAD soft-reset to pre-state" if undone else "")
+                )
+                print(f"[agent-runner] POLICY VIOLATION: {reason}", file=sys.stderr)
+                session.agents["builder"]["status"] = "crashed"
+                session.status = "error"
+                session.result = reason
+                session.add_message("system", "all", f"Task failed: {reason}")
+                session._save_state()
+                return
+
             if not builder_output or len(builder_output.strip()) < 20:
                 try:
                     diff_result = subprocess.run(

{memstack_skill_loader-4.9.0 → memstack_skill_loader-4.10.0}/src/memstack_skill_loader/categories.py

@@ -31,6 +31,7 @@ CATEGORY_MAP = {
     "performance-audit": "Development", "refactor-planner": "Development", "test-writer": "Development",
     "changelog-generator": "Development", "mentor": "Development", "webapp-testing": "Development",
     # Core
+    "goal": "Core",
     "compress": "Core", "diary": "Core", "echo": "Core", "grimoire": "Core",
     "sight": "Core", "token-optimization": "Core",
     # Marketing

memstack_skill_loader-4.10.0/src/memstack_skill_loader/goal.py

@@ -0,0 +1,118 @@
+# MemStack Goal CLI - thin `python -m memstack_skill_loader.goal` wrapper over goal_engine
+"""Command-line front door to the goal engine (see goal_engine.py).
+
+This module reimplements NOTHING: every subcommand delegates to the engine's
+existing functions. It exists so the /goal skill and the Architect stage can
+shell out to a stable interface and, critically, gate on an EXIT CODE:
+
+    template  -> print the blank five-field scaffold                 (exit 0)
+    validate  -> parse + validate a drafted goal; print problems.
+                 exit 0 when the goal is valid (warnings allowed),
+                 exit 2 when it has errors (missing TASK/OUTCOME/
+                 VERIFICATION). This exit code is the enforcement point.
+    format    -> parse + re-emit the clean labeled template          (exit 0)
+
+Input for validate/format resolves in this order: --text, else --file, else
+STDIN — so a caller can pipe a goal in or pass it as an argument.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .goal_engine import (
+    format_goal,
+    goal_is_valid,
+    goal_template,
+    parse_goal,
+    validate_goal,
+)
+
+# Exit code returned by `validate` when the goal has hard errors. Callers
+# (skill, Architect) branch on this to refuse an unverifiable goal.
+EXIT_INVALID = 2
+
+
+def read_input(args: argparse.Namespace) -> str:
+    """Resolve the goal text from --text, else --file, else STDIN.
+
+    Returns the raw text unparsed. An empty result is left to the engine's
+    validator to report (it will surface the missing required fields).
+    """
+    if args.text is not None:
+        return args.text
+    if args.file is not None:
+        with open(args.file, "r", encoding="utf-8") as fh:
+            return fh.read()
+    return sys.stdin.read()
+
+
+def _add_input_args(parser: argparse.ArgumentParser) -> None:
+    """Attach the shared --text / --file options to a subparser."""
+    parser.add_argument(
+        "--text", default=None,
+        help="Goal text passed directly on the command line.",
+    )
+    parser.add_argument(
+        "--file", default=None,
+        help="Path to a file containing the drafted goal.",
+    )
+
+
+def cmd_template(_args: argparse.Namespace) -> int:
+    """Print the blank five-field template."""
+    print(goal_template())
+    return 0
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    """Validate a drafted goal; print problems, return 0 (valid) or EXIT_INVALID.
+
+    Problems are printed one per line in the engine's order (errors first, then
+    ``WARNING:`` lines). Warnings do not affect the exit code.
+    """
+    goal = parse_goal(read_input(args))
+    for problem in validate_goal(goal):
+        print(problem)
+    return 0 if goal_is_valid(goal) else EXIT_INVALID
+
+
+def cmd_format(args: argparse.Namespace) -> int:
+    """Parse a goal and re-emit it via the engine's clean template."""
+    goal = parse_goal(read_input(args))
+    print(format_goal(goal))
+    return 0
+
+
+def main() -> None:
+    """CLI entry point. Dispatches to a subcommand and exits with its code."""
+    parser = argparse.ArgumentParser(
+        prog="python -m memstack_skill_loader.goal",
+        description="Structure and validate a task as a goal with a required, "
+                    "checkable VERIFICATION criterion.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_template = sub.add_parser("template", help="Print the blank five-field template.")
+    p_template.set_defaults(func=cmd_template)
+
+    p_validate = sub.add_parser(
+        "validate",
+        help="Validate a drafted goal (stdin/--file/--text). Exit 2 on errors.",
+    )
+    _add_input_args(p_validate)
+    p_validate.set_defaults(func=cmd_validate)
+
+    p_format = sub.add_parser(
+        "format", help="Re-emit a drafted goal (stdin/--file/--text) as the clean template.",
+    )
+    _add_input_args(p_format)
+    p_format.set_defaults(func=cmd_format)
+
+    args = parser.parse_args()
+    sys.exit(args.func(args))
+
+
+if __name__ == "__main__":
+    main()

memstack_skill_loader-4.10.0/src/memstack_skill_loader/goal_engine.py

@@ -0,0 +1,326 @@
+# MemStack Goal Engine - structures a task into five fields with a required, checkable VERIFICATION criterion
+"""Goal-structuring engine shared by the /goal skill and the Architect stage.
+
+A "goal" is a task decomposed into five fields:
+
+    TASK          what to do
+    WHY           why it matters / who it's for          (optional)
+    OUTCOME       the exact finished result / definition of done
+    CONSTRAINTS   what must or must not be done           (optional, list)
+    VERIFICATION  how to prove the OUTCOME is complete    (REQUIRED)
+
+VERIFICATION is the load-bearing field and the whole reason this module exists.
+The dominant failure mode this engine is built to prevent is a goal that reads
+as "done" without a concrete, checkable way to prove it: an agent (or a person)
+declares success against a vague target and ships something unverified. A goal
+without a specific verification criterion is treated as invalid here — not a
+style nit, but a hard rule enforced by ``validate_goal``. A verification that
+exists but only says "it works" / "tests pass" is flagged as a warning so the
+author is nudged toward a concrete, observable check.
+
+Pure standard library. No project imports, no external dependencies.
+
+Validation contract (see ``validate_goal``): the returned list mixes two
+severities distinguished by prefix —
+  * ERRORS  — plain messages (e.g. "TASK is required"). A goal with any error
+              is invalid and must not proceed.
+  * WARNINGS — messages prefixed with the literal ``"WARNING: "``. Advisory
+              only; a goal with warnings but no errors is still valid.
+Use ``goal_has_errors`` / ``goal_is_valid`` to branch without string-matching.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+# The five recognized field labels, in canonical display order. Parsing is
+# case-insensitive and whitespace-tolerant; this ordering drives format output.
+_LABELS = ("TASK", "WHY", "OUTCOME", "CONSTRAINTS", "VERIFICATION")
+
+# Matches a label line like "OUTCOME: ...", tolerating leading whitespace and
+# any casing. Group 1 = the (upper-cased) label, group 2 = the inline value.
+_LABEL_RE = re.compile(
+    r"^\s*(" + "|".join(_LABELS) + r")\s*:\s*(.*)$",
+    re.IGNORECASE,
+)
+
+# Marker prepended to advisory messages so callers can separate them from
+# hard errors without re-deriving the rules.
+_WARNING_PREFIX = "WARNING: "
+
+# A verification shorter than this (after normalization) is assumed too terse
+# to name a concrete, checkable criterion.
+_VAGUE_MIN_LEN = 15
+
+# Vacuous verification phrasings that may exceed the length floor yet still
+# assert nothing observable. Compared against the normalized (lower-cased,
+# punctuation-stripped, whitespace-collapsed) verification text.
+_VAGUE_PHRASES = frozenset({
+    "it works",
+    "works",
+    "it is done",
+    "its done",
+    "done",
+    "finished",
+    "complete",
+    "completed",
+    "tests pass",
+    "all tests pass",
+    "the tests pass",
+    "passes",
+    "it passes",
+    "ok",
+    "looks good",
+    "lgtm",
+    "works as expected",
+    "it works as expected",
+})
+
+
+@dataclass
+class Goal:
+    """A task structured into five fields.
+
+    ``task``, ``outcome`` and ``verification`` carry the meaning; ``why`` and
+    ``constraints`` are optional context. Only ``task`` is a positional
+    requirement of the dataclass — the required-ness of ``outcome`` and
+    ``verification`` is a *validation* rule (see ``validate_goal``), not a
+    construction rule, so partial goals can be built and then reported on.
+    """
+
+    task: str
+    why: str = ""
+    outcome: str = ""
+    constraints: list[str] = field(default_factory=list)
+    verification: str = ""
+
+
+def _normalize(text: str) -> str:
+    """Lower-case, strip surrounding punctuation, and collapse inner whitespace.
+
+    Used to compare a verification string against ``_VAGUE_PHRASES`` so that
+    "It works." and "  it   works  " both reduce to "it works".
+    """
+    lowered = text.strip().lower()
+    lowered = re.sub(r"\s+", " ", lowered)
+    return lowered.strip(" \t\r\n.!?,;:-*")
+
+
+def _split_constraints(raw_lines: list[str]) -> list[str]:
+    """Turn accumulated CONSTRAINTS text into a clean list.
+
+    Splits on both newlines and commas, strips common bullet markers
+    ("-", "*", "•") and surrounding whitespace, and drops empties.
+    """
+    items: list[str] = []
+    for line in raw_lines:
+        for part in re.split(r"[,\n]", line):
+            cleaned = part.strip().lstrip("-*• \t").strip()
+            if cleaned:
+                items.append(cleaned)
+    return items
+
+
+def parse_goal(text: str) -> Goal:
+    """Parse labeled ``LABEL: value`` text into a :class:`Goal`.
+
+    Recognizes the five labels (TASK, WHY, OUTCOME, CONSTRAINTS, VERIFICATION)
+    case-insensitively and with tolerant whitespace. A field's value may span
+    multiple lines: everything after a label line, up to the next label line,
+    belongs to that field. Scalar fields are whitespace-joined; CONSTRAINTS is
+    split into a list (see :func:`_split_constraints`).
+
+    Missing fields become empty (``""`` or ``[]``). Parsing never raises for
+    missing required fields — that is reported by :func:`validate_goal`.
+    """
+    # Accumulate raw text lines per field as we walk the input.
+    buckets: dict[str, list[str]] = {label: [] for label in _LABELS}
+    current: str | None = None
+
+    for line in text.splitlines():
+        match = _LABEL_RE.match(line)
+        if match:
+            current = match.group(1).upper()
+            inline = match.group(2).strip()
+            if inline:
+                buckets[current].append(inline)
+        elif current is not None:
+            # Continuation line for the field currently being read.
+            stripped = line.strip()
+            if stripped:
+                buckets[current].append(stripped)
+
+    def scalar(label: str) -> str:
+        return " ".join(buckets[label]).strip()
+
+    return Goal(
+        task=scalar("TASK"),
+        why=scalar("WHY"),
+        outcome=scalar("OUTCOME"),
+        constraints=_split_constraints(buckets["CONSTRAINTS"]),
+        verification=scalar("VERIFICATION"),
+    )
+
+
+def _verification_is_vague(verification: str) -> bool:
+    """True when a non-empty verification names no concrete, checkable criterion.
+
+    Two triggers: it is shorter than ``_VAGUE_MIN_LEN`` after normalization, or
+    it matches one of the known vacuous phrasings in ``_VAGUE_PHRASES``.
+    """
+    normalized = _normalize(verification)
+    if not normalized:
+        return False  # empty is an ERROR case, handled by validate_goal
+    if len(normalized) < _VAGUE_MIN_LEN:
+        return True
+    return normalized in _VAGUE_PHRASES
+
+
+def validate_goal(goal: Goal) -> list[str]:
+    """Return a list of problems with *goal*; an empty list means fully valid.
+
+    Errors (plain messages — presence of any makes the goal invalid):
+      * "TASK is required"
+      * "OUTCOME is required (define what done looks like)"
+      * "VERIFICATION is required (state how you'll prove it's complete)"
+
+    Warnings (prefixed with ``"WARNING: "`` — advisory, do not invalidate):
+      * a present-but-vacuous VERIFICATION.
+
+    Errors are listed before warnings. Use :func:`goal_has_errors` to test
+    validity without inspecting the prefix yourself.
+    """
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    if not goal.task.strip():
+        errors.append("TASK is required")
+    if not goal.outcome.strip():
+        errors.append("OUTCOME is required (define what done looks like)")
+    if not goal.verification.strip():
+        errors.append(
+            "VERIFICATION is required (state how you'll prove it's complete)"
+        )
+    elif _verification_is_vague(goal.verification):
+        warnings.append(
+            _WARNING_PREFIX
+            + "VERIFICATION is vague - state a concrete, checkable criterion"
+        )
+
+    return errors + warnings
+
+
+def goal_has_errors(problems: list[str]) -> bool:
+    """True if *problems* (from :func:`validate_goal`) contains any hard error.
+
+    A hard error is any message NOT prefixed with ``"WARNING: "``.
+    """
+    return any(not p.startswith(_WARNING_PREFIX) for p in problems)
+
+
+def goal_is_valid(goal: Goal) -> bool:
+    """Convenience: True when *goal* has no hard errors (warnings are allowed)."""
+    return not goal_has_errors(validate_goal(goal))
+
+
+def format_goal(goal: Goal) -> str:
+    """Render *goal* back into the clean labeled template for display/output.
+
+    Optional empty fields (WHY, CONSTRAINTS) are still emitted as labels so the
+    output shape is stable and copy-editable. Constraints render as a bulleted
+    list; a single constraint renders inline.
+    """
+    lines = [f"TASK: {goal.task}".rstrip()]
+    lines.append(f"WHY: {goal.why}".rstrip())
+    lines.append(f"OUTCOME: {goal.outcome}".rstrip())
+
+    if not goal.constraints:
+        lines.append("CONSTRAINTS:")
+    elif len(goal.constraints) == 1:
+        lines.append(f"CONSTRAINTS: {goal.constraints[0]}")
+    else:
+        lines.append("CONSTRAINTS:")
+        lines.extend(f"  - {item}" for item in goal.constraints)
+
+    lines.append(f"VERIFICATION: {goal.verification}".rstrip())
+    return "\n".join(lines)
+
+
+def goal_template() -> str:
+    """Return the empty five-field template with a one-line hint per label.
+
+    Handed to a user (or the Architect) starting from scratch, so every field —
+    especially VERIFICATION — comes with a prompt for what belongs there.
+    """
+    return (
+        "TASK: (what to do)\n"
+        "WHY: (why it matters / who it's for - optional)\n"
+        "OUTCOME: (the exact finished result - what 'done' looks like)\n"
+        "CONSTRAINTS: (what must or must not be done - optional, one per line)\n"
+        "VERIFICATION: (how you'll prove the outcome is complete - "
+        "a concrete, checkable criterion)"
+    )
+
+
+if __name__ == "__main__":
+    # Small self-test exercising the four cases: valid, missing-verification
+    # (error), vague-verification (warning), and template output.
+    print("=" * 64)
+    print("CASE 1 — complete valid goal")
+    print("=" * 64)
+    valid = parse_goal(
+        """
+        TASK: Add a --json flag to the report command
+        WHY: CI needs machine-readable output for the dashboard
+        OUTCOME: `report --json` prints a valid JSON object to stdout and exits 0
+        CONSTRAINTS: no new dependencies
+        must not change the default human output
+        VERIFICATION: run `report --json | python -m json.tool` and confirm it
+        parses and contains the "total" key
+        """
+    )
+    print(format_goal(valid))
+    problems = validate_goal(valid)
+    print("\nproblems:", problems)
+    print("has_errors:", goal_has_errors(problems), "| is_valid:", goal_is_valid(valid))
+    print("constraints parsed:", valid.constraints)
+    assert problems == [], "expected no problems for a complete goal"
+    assert goal_is_valid(valid)
+    assert valid.constraints == ["no new dependencies", "must not change the default human output"]
+
+    print("\n" + "=" * 64)
+    print("CASE 2 — missing VERIFICATION (error)")
+    print("=" * 64)
+    missing = parse_goal(
+        "TASK: Refactor the parser\n"
+        "OUTCOME: parser split into tokenizer and builder modules"
+    )
+    problems = validate_goal(missing)
+    print("problems:", problems)
+    print("has_errors:", goal_has_errors(problems), "| is_valid:", goal_is_valid(missing))
+    assert goal_has_errors(problems), "missing verification must be an error"
+    assert any("VERIFICATION is required" in p for p in problems)
+    assert not goal_is_valid(missing)
+
+    print("\n" + "=" * 64)
+    print("CASE 3 — vague VERIFICATION (warning, still valid)")
+    print("=" * 64)
+    vague = parse_goal(
+        "TASK: Fix the login bug\n"
+        "OUTCOME: users can log in again\n"
+        "VERIFICATION: it works"
+    )
+    problems = validate_goal(vague)
+    print("problems:", problems)
+    print("has_errors:", goal_has_errors(problems), "| is_valid:", goal_is_valid(vague))
+    assert not goal_has_errors(problems), "vague verification is a warning, not an error"
+    assert any(p.startswith("WARNING: ") for p in problems)
+    assert goal_is_valid(vague), "a goal with only warnings is still valid"
+
+    print("\n" + "=" * 64)
+    print("CASE 4 — empty template")
+    print("=" * 64)
+    print(goal_template())
+
+    print("\nAll self-test assertions passed.")

memstack_skill_loader-4.10.0/src/memstack_skill_loader/hooks/__init__.py

@@ -0,0 +1,5 @@
+"""Hook scripts injected into agent subprocesses (e.g. Builder git-guard).
+
+Kept as a subpackage so the scripts ship inside the installed wheel and can be
+resolved at runtime via os.path.dirname(__file__).
+"""

memstack_skill_loader-4.10.0/src/memstack_skill_loader/hooks/deny_git.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+"""PreToolUse hook: denies any Bash git invocation. Injected only into the
+Builder agent subprocess via --settings, so the Builder cannot run git
+(commit, push, reset, checkout, etc.). Fail-closed: on any error, deny."""
+import sys, json, re
+
+try:
+    data = json.load(sys.stdin)
+    cmd = data.get("tool_input", {}).get("command", "")
+except Exception:
+    # Fail closed: if we can't parse, deny to be safe.
+    print("BLOCKED: Builder git-guard could not parse tool input; denying.", file=sys.stderr)
+    sys.exit(2)
+
+# Match git as a command token in any form: git, /usr/bin/git, sh -c "git",
+# env VAR=x git, chained "&& git", "; git", "| git", GIT_DIR=... git, etc.
+if re.search(r"(^|[\s;&|/])git(\s|$)", cmd) or re.search(r"\bgit\b", cmd):
+    print("BLOCKED: Builder may not run git. Git operations are performed by the orchestrator, not the Builder.", file=sys.stderr)
+    sys.exit(2)
+
+sys.exit(0)

{memstack_skill_loader-4.9.0 → memstack_skill_loader-4.10.0/src/memstack_skill_loader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.9.0
+Version: 4.10.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0

{memstack_skill_loader-4.9.0 → memstack_skill_loader-4.10.0}/src/memstack_skill_loader.egg-info/SOURCES.txt

@@ -9,6 +9,8 @@ src/memstack_skill_loader/compression.py
 src/memstack_skill_loader/config.py
 src/memstack_skill_loader/dashboard.html
 src/memstack_skill_loader/dashboard.py
+src/memstack_skill_loader/goal.py
+src/memstack_skill_loader/goal_engine.py
 src/memstack_skill_loader/indexer.py
 src/memstack_skill_loader/license.py
 src/memstack_skill_loader/memory_db.py
@@ -24,6 +26,8 @@ src/memstack_skill_loader.egg-info/dependency_links.txt
 src/memstack_skill_loader.egg-info/entry_points.txt
 src/memstack_skill_loader.egg-info/requires.txt
 src/memstack_skill_loader.egg-info/top_level.txt
+src/memstack_skill_loader/hooks/__init__.py
+src/memstack_skill_loader/hooks/deny_git.py
 src/memstack_skill_loader/proxy/__init__.py
 src/memstack_skill_loader/proxy/_diag.py
 src/memstack_skill_loader/proxy/body_parser.py