@sushanglewis/lincoln 1.6.3 → 1.8.0

package/framework/scripts/security_analyzer.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""Risk analyzer for Lincoln pre-tool-use security gate.
+
+Loads `.claude/policies/security.yaml` and evaluates a tool call against the
+configured policies. Designed to be invoked from `.claude/hooks/pre-tool-use.sh`
+and from generated harness-specific hook scripts.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+DEFAULT_POLICY_PATH = ".claude/policies/security.yaml"
+
+
+def load_policy(root: Path) -> dict[str, Any]:
+    """Load the risk policy YAML, returning an empty policy if missing."""
+    path = root / DEFAULT_POLICY_PATH
+    if not path.exists():
+        return {"policies": []}
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {"policies": []}
+
+
+def _normalize_command(command: str) -> str:
+    """Strip leading whitespace and collapse internal spaces for matching."""
+    return re.sub(r"\s+", " ", command.strip())
+
+
+def _split_command_segments(command: str) -> list[str]:
+    """Split a shell command on chain operators so each segment is matched.
+
+    Handles `&&`, `||`, `;`, and `|`.
+    """
+    segments = re.split(r"\s*(&&|\|\||;|\|)\s*", command)
+    return [_normalize_command(seg) for seg in segments if seg and not re.match(r"^(&&|\|\||;|\|)$", seg.strip())]
+
+
+def _strip_command_prefix(segment: str) -> str:
+    """Remove common leading prefixes that should not hide the real command.
+
+    Examples: `sudo rm foo`, `env VAR=1 rm foo`, `cd /tmp && rm foo`.
+    """
+    segment = _normalize_command(segment)
+    while re.match(r"^[A-Za-z_][A-Za-z0-9_]*=\S+\s+", segment):
+        segment = _normalize_command(re.sub(r"^[A-Za-z_][A-Za-z0-9_]*=\S+\s+", "", segment))
+    if re.match(r"^(sudo|doas)\s+", segment):
+        segment = _normalize_command(re.sub(r"^(sudo|doas)\s+", "", segment))
+    if re.match(r"^cd\s+\S+\s*(&&|;|\|)", segment):
+        segment = _normalize_command(re.sub(r"^cd\s+\S+\s*(&&|;|\|)", "", segment))
+    return segment
+
+
+def _command_matches(condition: str, command: str) -> bool:
+    """Evaluate a human-readable condition against a bash command."""
+    lowered = condition.lower()
+    segments = _split_command_segments(command)
+
+    def _any_segment(pattern: str) -> bool:
+        return any(re.search(pattern, _strip_command_prefix(seg)) for seg in segments)
+
+    if "rm -rf" in lowered or 'command matches "rm -rf"' in lowered:
+        if _any_segment(r"\brm\s+-rf\b"):
+            return True
+
+    if 'command matches "rm -r" or "rm -rf"' in lowered:
+        if _any_segment(r"\brm\s+-r(?:f)?\b"):
+            return True
+
+    if 'command matches any of ["rm", "rmdir"]' in lowered:
+        if _any_segment(r"(?:^|\s)(?:rm\b|rmdir\b)"):
+            return True
+
+    if 'command matches "git push"' in lowered:
+        if _any_segment(r"\bgit\s+push\b"):
+            return True
+
+    if "external http client" in lowered or "curl, wget" in lowered:
+        if _any_segment(r"\b(?:curl|wget|httpie)\b"):
+            return True
+
+    if 'command matches "rm"' in lowered and "rmdir" not in lowered:
+        if _any_segment(r"\brm\b"):
+            return True
+
+    return False
+
+
+def _resolve_target_path(target: str, root: Path) -> Path:
+    """Resolve a Write/Edit target to an absolute, canonical path."""
+    path = Path(target)
+    if not path.is_absolute():
+        path = root / path
+    try:
+        return path.resolve()
+    except (OSError, ValueError):
+        return path.absolute()
+
+
+def _target_matches(condition: str, target: str, process_slug: str, root: Path) -> bool:
+    """Evaluate a file-target condition using canonical absolute paths."""
+    lowered = condition.lower()
+    resolved = _resolve_target_path(target, root)
+    try:
+        package_root = (root / process_slug).resolve()
+    except (OSError, ValueError):
+        package_root = (root / process_slug).absolute()
+
+    if "outside current process_slug" in lowered:
+        try:
+            resolved.relative_to(package_root)
+            return False
+        except ValueError:
+            return True
+
+    if "inside current process_slug" in lowered:
+        try:
+            resolved.relative_to(package_root)
+            return True
+        except ValueError:
+            return False
+
+    return False
+
+
+def _evaluate_policy(policy: dict[str, Any], tool_name: str, tool_args: dict[str, Any], process_slug: str, root: Path) -> bool:
+    """Return True if the policy applies to this tool call."""
+    tools = [t.strip() for t in policy.get("tool", "").split("|")]
+    if tool_name not in tools:
+        return False
+
+    condition = policy.get("condition", "")
+    if tool_name == "Bash":
+        command = tool_args.get("command", "")
+        return _command_matches(condition, command)
+
+    if tool_name in ("Write", "Edit"):
+        target = tool_args.get("file_path") or tool_args.get("path") or ""
+        return _target_matches(condition, target, process_slug, root)
+
+    return False
+
+
+def _log_security_event(
+    log_dir: Path,
+    tool_name: str,
+    tool_args: dict[str, Any],
+    result: dict[str, Any],
+) -> None:
+    """Append a JSON line to issue-<N>/logs/security.log."""
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "security.log"
+    entry = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "tool": tool_name,
+        "level": result["level"],
+        "policy": result.get("policy", ""),
+        "action": "blocked" if result["confirm_required"] else "allowed",
+        "args": {k: v for k, v in tool_args.items() if k in ("command", "file_path", "path")},
+    }
+    with log_file.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+
+def analyze(
+    root: Path,
+    tool_name: str,
+    tool_args: dict[str, Any],
+    process_slug: str = "",
+    log_dir: str | None = None,
+) -> dict[str, Any]:
+    """Analyze a tool call and return risk assessment."""
+    if os.environ.get("LINCOLN_SECURITY_MODE") == "permissive":
+        return {
+            "level": "low",
+            "policy": "",
+            "message": "Security analyzer is in permissive mode.",
+            "confirm_required": False,
+            "log": False,
+        }
+
+    policy_data = load_policy(root)
+    policies = policy_data.get("policies", [])
+
+    for policy in policies:
+        if not _evaluate_policy(policy, tool_name, tool_args, process_slug, root):
+            continue
+
+        result = {
+            "level": policy.get("level", "unknown"),
+            "policy": policy.get("name", ""),
+            "message": policy.get("message", ""),
+            "confirm_required": bool(policy.get("confirm", False)),
+            "log": bool(policy.get("log", False)),
+        }
+        if log_dir:
+            _log_security_event(Path(log_dir), tool_name, tool_args, result)
+        return result
+
+    return {
+        "level": "low",
+        "policy": "",
+        "message": "",
+        "confirm_required": False,
+        "log": False,
+    }
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Analyze tool call risk")
+    parser.add_argument("--root", type=Path, default=Path.cwd())
+    parser.add_argument("--tool", required=True)
+    parser.add_argument("--args", default="{}")
+    parser.add_argument("--process-slug", default="")
+    parser.add_argument("--log-dir", default=None)
+    args = parser.parse_args()
+
+    tool_args = json.loads(args.args)
+    result = analyze(
+        args.root,
+        args.tool,
+        tool_args,
+        process_slug=args.process_slug,
+        log_dir=args.log_dir,
+    )
+    print(json.dumps(result, ensure_ascii=False))

package/framework/scripts/stage_loader.py

@@ -36,7 +36,7 @@ if str(PROJECT_ROOT) not in sys.path:
 
 import yaml
 
-from scripts import lincoln_trace
+from scripts import lincoln_condenser, lincoln_trace
 from scripts import lincoln_render
 from scripts.lincoln_documents import write_documents_index
 from scripts.lincoln_index import write_package_index
@@ -84,6 +84,29 @@ def now_iso() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
+def _record_stage_event(
+    state_file: Path | None,
+    category: str,
+    event_type: str,
+    payload: dict[str, Any] | None = None,
+) -> None:
+    """Write a lifecycle or gate event to the session trace.
+
+    Failures are logged but never block the stage action.
+    """
+    try:
+        merged_payload = {"event_type": event_type}
+        if payload:
+            merged_payload.update(payload)
+        lincoln_trace.append_event_entry(
+            state_path=state_file,
+            category=category,
+            payload=merged_payload,
+        )
+    except Exception as exc:
+        print(f"Warning: could not record {category}/{event_type} trace event: {exc}")
+
+
 def load_yaml(path: Path) -> Any:
     if not path.exists():
         raise FileNotFoundError(path)
@@ -483,6 +506,53 @@ def _check_previous_stage_completed(stage_id: str, prev_stage_id: str, state: di
     return False
 
 
+
+
+def _check_agent_delegation(stage_id: str) -> bool:
+    """Validate parallel specialist agent configuration in stage YAML."""
+    stage = load_stage_yaml(stage_id)
+    agent = stage.get("agent", {})
+    specialists = agent.get("parallel_specialists", [])
+    if not specialists:
+        return True
+
+    all_valid = True
+    for specialist in specialists:
+        agent_file = f"{specialist.lstrip('lc-')}.md"
+        agent_path = PROJECT_ROOT / ".claude" / "agents" / agent_file
+        if not agent_path.exists():
+            print(
+                f"FAIL: specialist agent '{specialist}' not found at .claude/agents/{agent_file}",
+                file=sys.stderr,
+            )
+            all_valid = False
+        else:
+            print(f"PASS: specialist agent '{specialist}' found")
+
+    output_schema = agent.get("output_schema")
+    if output_schema:
+        schema_path = PROJECT_ROOT / output_schema
+        if not schema_path.exists():
+            print(f"FAIL: output_schema not found: {output_schema}", file=sys.stderr)
+            all_valid = False
+        else:
+            try:
+                json.loads(schema_path.read_text(encoding="utf-8"))
+                print(f"PASS: output_schema is valid JSON: {output_schema}")
+            except json.JSONDecodeError as exc:
+                print(f"FAIL: output_schema is invalid JSON: {exc}", file=sys.stderr)
+                all_valid = False
+
+    merge_strategy = agent.get("merge_strategy", "priority")
+    if merge_strategy not in {"priority", "vote", "consensus"}:
+        print(f"FAIL: unsupported merge_strategy '{merge_strategy}'", file=sys.stderr)
+        all_valid = False
+    else:
+        print(f"PASS: merge_strategy '{merge_strategy}' supported")
+
+    return all_valid
+
+
 def _run_gate_check(
     phase: str,
     check: dict[str, Any],
@@ -564,6 +634,10 @@ def action_validate(
         if not passed:
             all_passed = False
 
+    if phase == "entry":
+        if not _check_agent_delegation(stage_id):
+            all_passed = False
+
     if not all_passed:
         if _is_legacy_state(state):
             stage_state["status"] = "validation_failed"
@@ -638,6 +712,13 @@ def action_record_artifacts(
     print(f"Recorded {len(recorded)} artifacts for stage '{stage_id}'")
     for art in recorded:
         print(f"  - {art}")
+
+    _record_stage_event(
+        state_file,
+        "stage_lifecycle",
+        "artifacts_recorded",
+        {"stage_id": stage_id, "artifact_count": len(recorded), "artifacts": recorded},
+    )
     return recorded
 
 
@@ -677,6 +758,13 @@ def action_approve_gate(
 
     save_state(state, state_file)
     print(f"PASS: gate approved for stage '{stage_id}' by '{approved_by}'")
+
+    _record_stage_event(
+        state_file,
+        "gate",
+        "gate_approved",
+        {"stage_id": stage_id, "approved_by": approved_by},
+    )
     return 0
 
 
@@ -799,6 +887,27 @@ def action_transition_next(stage_id: str, state: dict[str, Any], state_file: Pat
 
     save_state(state, state_file)
     print(f"Transitioned from '{stage_id}' to '{next_stage_id}'")
+
+    _record_stage_event(
+        state_file,
+        "stage_lifecycle",
+        "stage_completed",
+        {"stage_id": stage_id, "next_stage_id": next_stage_id},
+    )
+    if next_stage_id:
+        _record_stage_event(
+            state_file,
+            "stage_lifecycle",
+            "stage_started",
+            {"stage_id": next_stage_id, "previous_stage_id": stage_id},
+        )
+    else:
+        _record_stage_event(
+            state_file,
+            "session",
+            "workflow_completed",
+            {"final_stage_id": stage_id},
+        )
     return next_stage_id
 
 
@@ -900,6 +1009,20 @@ def action_handoff_report(stage_id: str, state: dict[str, Any], state_file: Path
     else:
         lines.append(f"- **Status:** {stage_state.get('status', state.get('current_run', {}).get('status', 'unknown'))}")
     lines.append("")
+
+    # Condense large traces as a handoff sub-step (OpenHands-style context pressure management).
+    try:
+        trace_file = lincoln_trace.get_trace_file(state, state_file)
+        condensation = lincoln_condenser.condense(trace_file)
+        if condensation:
+            lines.append("## Trace Condensation")
+            lines.append(f"- **Events summarized:** {condensation['event_count']}")
+            lines.append(f"- **Threshold:** {condensation.get('threshold', 200)}")
+            lines.append(f"- **Top categories:** {', '.join(condensation.get('categories', {}).keys())}")
+            lines.append("")
+    except Exception:
+        # Condensation is advisory; never break handoff report generation.
+        pass
     lines.append("## Waiting For")
     lines.append(f"- **Waiting for:** {'human' if stage_def.get('human_gate') and not stage_state.get('gate_passed') else 'agent'}")
     lines.append("")

package/framework/tools/lincoln/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@sushanglewis/lincoln",
-  "version": "1.6.3",
+  "version": "1.8.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@sushanglewis/lincoln",
-      "version": "1.6.3",
+      "version": "1.8.0",
       "license": "MIT",
       "dependencies": {
         "ink": "^5.2.0",

package/framework/tools/lincoln/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sushanglewis/lincoln-recorder",
-  "version": "1.6.3",
+  "version": "1.8.0",
   "description": "Cross-tool terminal UI for recording Lincoln interviews",
   "type": "module",
   "main": "./dist/index.js",

package/framework/tools/lincoln-installer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lincoln-install",
-  "version": "1.6.3",
+  "version": "1.8.0",
   "description": "Terminal TUI installer for the Lincoln AI-Native R&D workflow system",
   "type": "module",
   "main": "dist/main.js",
@@ -49,5 +49,10 @@
     "claude-code",
     "ai-workflow"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sushanglewis/Lincoln",
+    "directory": "tools/lincoln-installer"
+  },
   "license": "MIT"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sushanglewis/lincoln",
-  "version": "1.6.3",
+  "version": "1.8.0",
   "description": "Global Lincoln agent harness plugin CLI",
   "type": "module",
   "main": "./dist/index.js",
@@ -50,5 +50,10 @@
     "opencode",
     "plugin"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sushanglewis/Lincoln",
+    "directory": "packages/lincoln"
+  },
   "license": "MIT"
 }