@research-copilot/plugin 1.1.15 → 1.1.16

package/dist/hooks/scripts/session_start_memory_injector.py

@@ -0,0 +1,188 @@
+"""SessionStart hook: inject .copilot/ __HANDOFF__ summaries into context."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+
+HANDOFF_HEADER = "## __HANDOFF__"
+COPILOT_FILES = ["state.md", "literature.md", "ideas.md",
+                 "experiments.md", "decisions.md", "handoff.md"]
+MAX_TOTAL_LINES = 400
+PIPELINES_TAIL_LINES = 20
+RECENT_PIPELINES = 3
+
+
+def conductor_protocol_path() -> Path:
+    """Locate CONDUCTOR-PROTOCOL.md in both dev (self/) and installed
+    (${CLAUDE_PLUGIN_ROOT}/) layouts. The script lives at
+    <root>/hooks/scripts/session_start_memory_injector.py, so the protocol is
+    two levels up.
+    """
+    return Path(__file__).resolve().parent.parent.parent / "CONDUCTOR-PROTOCOL.md"
+
+
+def extract_handoff_block(text: str) -> str | None:
+    """Return the body of the trailing ## __HANDOFF__ section, or None."""
+    idx = text.rfind(HANDOFF_HEADER)
+    if idx < 0:
+        return None
+    body = text[idx + len(HANDOFF_HEADER):].strip()
+    end = body.find("\n## ")
+    if end >= 0:
+        body = body[:end].rstrip()
+    return body or None
+
+
+def extract_last_n_lines(text: str, n: int) -> str:
+    lines = text.rstrip("\n").split("\n")
+    return "\n".join(lines[-n:])
+
+
+def main() -> int:
+    workspace = Path.cwd()
+    copilot = workspace / ".copilot"
+    if not copilot.exists():
+        sys.stdout.write("[memory-injector] .copilot/ not initialized — skipping.\n")
+        sys.stdout.flush()
+        return 0
+
+    blocks: list[str] = []
+    total_lines = 0
+
+    for fname in COPILOT_FILES:
+        f = copilot / fname
+        if not f.is_file():
+            continue
+        text = f.read_text(encoding="utf-8", errors="replace")
+        block = extract_handoff_block(text)
+        if block is None:
+            block = extract_last_n_lines(text, n=PIPELINES_TAIL_LINES)
+            if not block.strip():
+                continue
+            header = f"### {fname} (no __HANDOFF__; last {PIPELINES_TAIL_LINES} lines)"
+        else:
+            header = f"### {fname}"
+        blocks.append(f"{header}\n{block}")
+        total_lines += block.count("\n") + 2
+        if total_lines >= MAX_TOTAL_LINES:
+            blocks.append(f"[memory-injector] truncated at {MAX_TOTAL_LINES} lines budget")
+            break
+
+    # ---- Write last_updated snapshot for SubagentStop hook ----
+    snapshot: dict[str, str | None] = {}
+    for fname in COPILOT_FILES:
+        f = copilot / fname
+        if not f.is_file():
+            continue
+        try:
+            text = f.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        idx = text.rfind(HANDOFF_HEADER)
+        if idx < 0:
+            snapshot[fname] = None
+            continue
+        body = text[idx + len(HANDOFF_HEADER):]
+        last_updated: str | None = None
+        for line in body.splitlines():
+            s = line.strip()
+            if s.startswith("- last_updated:"):
+                last_updated = s.split(":", 1)[1].strip() or None
+                break
+        snapshot[fname] = last_updated
+    try:
+        (copilot / ".session_snapshot.json").write_text(
+            json.dumps(snapshot, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8",
+        )
+    except OSError:
+        pass
+
+    pipelines_dir = copilot / "pipelines"
+    if pipelines_dir.is_dir() and total_lines < MAX_TOTAL_LINES:
+        recent = sorted(pipelines_dir.glob("*.md"))[-RECENT_PIPELINES:]
+        for p in recent:
+            text = p.read_text(encoding="utf-8", errors="replace")
+            block = extract_handoff_block(text) or extract_last_n_lines(text, n=PIPELINES_TAIL_LINES)
+            if not block.strip():
+                continue
+            blocks.append(f"### pipelines/{p.stem}\n{block}")
+            total_lines += block.count("\n") + 2
+            if total_lines >= MAX_TOTAL_LINES:
+                break
+
+    if not blocks:
+        sys.stdout.write(
+            "[memory-injector] .copilot/ exists but no __HANDOFF__ blocks found — "
+            "sub-agents likely not following PIPELINE-OS §9.\n"
+        )
+        sys.stdout.flush()
+        return 0
+
+    sys.stdout.write("[memory-injector] Loaded research state from .copilot/:\n\n")
+    sys.stdout.write("\n\n".join(blocks))
+    sys.stdout.write(
+        "\n\n[memory-injector] Constraints: do NOT propose ideas already in ideas.md; "
+        "do NOT re-run experiments already in experiments.md unless explicitly asked.\n"
+    )
+    sys.stdout.flush()
+
+    # ---- Summarize last 24h of violations log ----
+    vlog = copilot / "__violations.log"
+    if vlog.is_file():
+        try:
+            import datetime as _dt
+            now = _dt.datetime.now(_dt.timezone.utc)
+            cutoff = now - _dt.timedelta(hours=24)
+            hard_blocks = 0
+            releases = 0
+            soft_warns = 0
+            for line in vlog.read_text(encoding="utf-8", errors="replace").splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    rec = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                try:
+                    t = _dt.datetime.fromisoformat(rec.get("ts", "").replace("Z", "+00:00"))
+                except ValueError:
+                    continue
+                if t.tzinfo is None:
+                    t = t.replace(tzinfo=_dt.timezone.utc)
+                if t < cutoff:
+                    continue
+                sev, kind = rec.get("sev"), rec.get("kind")
+                if sev == "HARD" and kind == "BLOCK":
+                    hard_blocks += 1
+                elif sev == "HARD" and kind == "RELEASE":
+                    releases += 1
+                elif sev == "SOFT" and kind == "WARN":
+                    soft_warns += 1
+            if hard_blocks or releases or soft_warns:
+                sys.stdout.write(
+                    f"\n[memory-injector] Last 24h: {hard_blocks} HARD blocks "
+                    f"({releases} 3-strike releases), {soft_warns} SOFT warns. "
+                    f"See .copilot/__violations.log.\n"
+                )
+                sys.stdout.flush()
+        except OSError:
+            pass
+
+    proto = conductor_protocol_path()
+    if proto.is_file():
+        try:
+            sys.stdout.write(
+                "\n\n[conductor] Active protocol (you ARE the conductor; "
+                "delegate execution to copilot-*, own the task list):\n\n"
+                + proto.read_text(encoding="utf-8", errors="replace") + "\n"
+            )
+            sys.stdout.flush()
+        except OSError:
+            pass
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/hooks/scripts/user_prompt_dispatch_reminder.py

@@ -0,0 +1,40 @@
+"""UserPromptSubmit hook: re-assert the main-session conductor's standing orders
+on EVERY turn. No suppression — the constraint must apply from every interaction
+onward, including 'next step' / slash / @ prompts. Honors a .disabled flag."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+STANDING_ORDERS = (
+    "[conductor] You are the research-pipeline conductor (main session). Standing orders:\n"
+    "  1. Do NOT execute domain work inline. For any execution-class request, FIRST\n"
+    "     publish a TaskCreate plan list (one task per planned dispatch), THEN dispatch:\n"
+    "       - literature / paper search -> Agent(subagent_type='copilot-literature')\n"
+    "       - innovation / brainstorm    -> Agent(subagent_type='copilot-ideation')\n"
+    "       - experiment / training      -> Agent(subagent_type='copilot-experiment')\n"
+    "       - drafting / writing         -> Agent(subagent_type='copilot-writer')\n"
+    "       - polish / de-AI             -> Agent(subagent_type='copilot-polisher')\n"
+    "       - review / sanity            -> Agent(subagent_type='copilot-reviewer')\n"
+    "       - rebuttal                   -> Agent(subagent_type='copilot-rebuttal')\n"
+    "  2. You OWN the plan and the task list — never let the first sub-agent's closing\n"
+    "     recommendation decide the next step. Audit each return, then advance the plan.\n"
+    "  3. You may write .copilot/state.md and .copilot/decisions.md; refresh their\n"
+    "     __HANDOFF__ blocks on every stage transition (PIPELINE-OS §9).\n"
+    "  4. Read .copilot/state.md before diagnosing where the pipeline stands.\n"
+)
+
+
+def main() -> int:
+    if (Path.cwd() / ".copilot" / "dispatch-reminder.disabled").exists():
+        return 0
+    # Drain stdin (the prompt) so the hook doesn't block; content is not inspected —
+    # standing orders fire unconditionally.
+    _ = sys.stdin.read()
+    sys.stdout.write(STANDING_ORDERS)
+    sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/hooks/session-memory-injector.json

@@ -0,0 +1,17 @@
+{
+  "description": "SessionStart hook: inject .copilot/ __HANDOFF__ summaries so the new session knows where the pipeline stands.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python self/hooks/scripts/session_start_memory_injector.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/hooks/tests/conftest.py

@@ -0,0 +1,61 @@
+"""Shared pytest fixtures for copilot hook tests."""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent / "scripts"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+FIXTURES = Path(__file__).resolve().parent / "fixtures"
+
+
+@pytest.fixture
+def workspace(tmp_path: Path) -> Path:
+    (tmp_path / ".copilot").mkdir()
+    return tmp_path
+
+
+@pytest.fixture
+def fixtures_dir() -> Path:
+    return FIXTURES
+
+
+def make_payload(tool_name: str, tool_input: dict, transcript_path: str,
+                 stop_hook_active: bool = False) -> dict:
+    return {"tool_name": tool_name, "tool_input": tool_input,
+            "transcript_path": transcript_path,
+            "stop_hook_active": stop_hook_active}
+
+
+@pytest.fixture
+def payload_builder():
+    return make_payload
+
+
+def write_handoff_block(file: Path, last_updated: str,
+                        written_by: str = "copilot-test",
+                        key_facts: list[str] | None = None) -> None:
+    facts = key_facts or ["(placeholder)"]
+    body = "\n".join([
+        "",
+        "## __HANDOFF__",
+        f"- last_updated: {last_updated}",
+        f"- written_by: {written_by}",
+        "- key_facts:",
+        *(f"  - {f}" for f in facts),
+        "- next_owner: (none)",
+        "",
+    ])
+    if file.exists():
+        file.write_text(file.read_text() + body, encoding="utf-8")
+    else:
+        file.write_text(body, encoding="utf-8")
+
+
+@pytest.fixture
+def handoff_writer():
+    return write_handoff_block

package/dist/hooks/tests/fixtures/transcript_copilot_experiment_complete.jsonl

@@ -0,0 +1,2 @@
+{"role":"user","content":"run experiment"}
+{"role":"assistant","metadata":{"subagent_type":"copilot-experiment"},"content":[{"type":"text","text":"[STATE_OUTPUT]\nPrevious: JUDGED\nCurrent: END\nAction completed: Wrote handoff\nCapability gate: passed\nEvidence: experiments.md:42\nNext allowed: []\nTransition reason: goal met\n[/STATE_OUTPUT]"}]}

package/dist/hooks/tests/fixtures/transcript_copilot_experiment_state_jump.jsonl

@@ -0,0 +1,2 @@
+{"role":"user","content":"run experiment"}
+{"role":"assistant","metadata":{"subagent_type":"copilot-experiment"},"content":[{"type":"text","text":"[STATE_OUTPUT]\nPrevious: UNINITIALIZED\nCurrent: END\nAction completed: skipped\nCapability gate: passed\nEvidence: none\nNext allowed: []\nTransition reason: shortcut\n[/STATE_OUTPUT]"}]}

package/dist/hooks/tests/fixtures/transcript_copilot_literature.jsonl

@@ -0,0 +1,2 @@
+{"role":"user","content":"scan papers"}
+{"role":"assistant","metadata":{"subagent_type":"copilot-literature"},"content":[{"type":"text","text":"[STATE_OUTPUT]\nPrevious: UNINITIALIZED\nCurrent: SCANNING\nAction completed: Loaded literature.md\nCapability gate: passed\nEvidence: literature.md:1\nNext allowed: [BASELINE_LOCKED, RELATED_WORK_AUGMENTED]\nTransition reason: memory-gate passed\n[/STATE_OUTPUT]"}]}

package/dist/hooks/tests/fixtures/transcript_main_only.jsonl

@@ -0,0 +1,2 @@
+{"role":"user","content":"hello"}
+{"role":"assistant","content":[{"type":"text","text":"hi"}]}

package/dist/hooks/tests/fixtures/transcript_malformed_state_output.jsonl

@@ -0,0 +1,2 @@
+{"role":"user","content":"go"}
+{"role":"assistant","metadata":{"subagent_type":"copilot-literature"},"content":[{"type":"text","text":"[STATE_OUTPUT]\nPrevious: SCANNING\nCurrent: END\nTransition reason: done\n[/STATE_OUTPUT]"}]}

package/dist/hooks/tests/integration_run.ps1

@@ -0,0 +1,65 @@
+# Manual integration smoke test for copilot guard hooks.
+# Usage: pwsh -File self/hooks/tests/integration_run.ps1
+#
+# Exercises each hook with fake stdin payloads and asserts the decision JSON.
+# Does NOT register the hooks in .claude/settings.json (Task 20 does that).
+
+$ErrorActionPreference = "Stop"
+$python = "D:/article/.venv/Scripts/python.exe"
+$repo = "D:/article"
+
+$tmpRoot = Join-Path ([System.IO.Path]::GetTempPath()) ("copilot-smoke-" + [Guid]::NewGuid().ToString("N"))
+New-Item -ItemType Directory -Path $tmpRoot | Out-Null
+$workspace = $tmpRoot
+New-Item -ItemType Directory -Path "$workspace/.copilot" | Out-Null
+
+function Run-Hook ($script, $payload) {
+    $json = $payload | ConvertTo-Json -Compress -Depth 10
+    $stdinFile = Join-Path $tmpRoot "stdin.txt"
+    Set-Content -Path $stdinFile -Value $json -NoNewline -Encoding UTF8
+    $stdoutFile = Join-Path $tmpRoot "stdout.txt"
+    $stderrFile = Join-Path $tmpRoot "stderr.txt"
+    $proc = Start-Process -FilePath $python `
+        -ArgumentList "$repo/self/hooks/scripts/$script" `
+        -WorkingDirectory $workspace `
+        -RedirectStandardInput $stdinFile `
+        -RedirectStandardOutput $stdoutFile `
+        -RedirectStandardError $stderrFile `
+        -NoNewWindow -PassThru -Wait
+    return (Get-Content $stdoutFile -Raw)
+}
+
+function Assert ($cond, $msg) {
+    if (-not $cond) {
+        Write-Host "FAIL: $msg" -ForegroundColor Red
+        exit 1
+    }
+    Write-Host "PASS: $msg" -ForegroundColor Green
+}
+
+# Sanity: scripts import cleanly
+& $python -c "import sys; sys.path.insert(0, '$repo/self/hooks/scripts'); import _copilot_hook_lib, copilot_write_guard, copilot_subagent_stop"
+Assert ($LASTEXITCODE -eq 0) "scripts import cleanly"
+
+# Test 1: PreToolUse — literature writing ideas.md → deny
+$lit = Join-Path $tmpRoot "lit.jsonl"
+'{"role":"assistant","metadata":{"subagent_type":"copilot-literature"}}' | Set-Content -Path $lit -Encoding UTF8
+$payload = @{
+    tool_name = "Write"
+    tool_input = @{ file_path = (Join-Path $workspace ".copilot/ideas.md") }
+    transcript_path = $lit
+}
+$out = Run-Hook -script "copilot_write_guard.py" -payload $payload
+Assert ($out -match '"deny"') "PreToolUse denies non-owned write (copilot-literature -> ideas.md)"
+
+# Test 2: SubagentStop — first boot, no snapshot, no handoff → allow + NO-SNAPSHOT log
+$payload = @{ transcript_path = $lit; stop_hook_active = $false }
+$out = Run-Hook -script "copilot_subagent_stop.py" -payload $payload
+Assert ($out -match '"allow"') "SubagentStop allows on first boot (SOFT degrade)"
+
+$log = Get-Content "$workspace/.copilot/__violations.log" -Raw -ErrorAction SilentlyContinue
+Assert ($log -and $log -match "NO-SNAPSHOT") "violations.log records NO-SNAPSHOT entry"
+
+Write-Host "ALL INTEGRATION CHECKS PASSED" -ForegroundColor Green
+Remove-Item -Recurse -Force $tmpRoot
+exit 0