@reconcrap/people-network-memory 0.1.0

package/scripts/people_memory_bootstrap.py

@@ -0,0 +1,247 @@
+"""Stdlib-only bootstrap launcher for AI harnesses.
+
+The harness can call this script instead of calling the package directly. It
+creates or repairs a local venv, installs the package, and then launches the MCP
+server through that venv. Keep this file dependency-free.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import platform
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+STATE_SCHEMA_VERSION = 1
+LOCAL_ENV_FILENAME = "local.env.json"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    repo = Path(args.repo).expanduser().resolve() if args.repo else _repo_root()
+    venv = Path(args.venv).expanduser().resolve() if args.venv else repo / ".venv"
+    if args.command == "run":
+        result = ensure_runtime(
+            repo=repo,
+            venv=venv,
+            extra=args.extra,
+            force=args.force,
+            git_pull=args.git_pull,
+        )
+        env = os.environ.copy()
+        env.update({key: value for key, value in _load_local_env(repo).items() if key not in env})
+        env.setdefault("PEOPLE_MEMORY_BACKEND", args.backend)
+        env.setdefault("PEOPLE_MEMORY_SENSITIVITY_POLICY", "personal")
+        env.setdefault("GRAPHITI_TELEMETRY_ENABLED", "false")
+        passthrough_args = list(args.server_args)
+        if passthrough_args and passthrough_args[0] == "--":
+            passthrough_args = passthrough_args[1:]
+        server_args = ["-m", "people_network_memory.cli", "start", *passthrough_args]
+        return subprocess.call([result["python"], *server_args], cwd=str(repo), env=env)
+    if args.command in {"ensure", "update"}:
+        result = ensure_runtime(
+            repo=repo,
+            venv=venv,
+            extra=args.extra,
+            force=args.force or args.command == "update",
+            git_pull=args.git_pull,
+        )
+        print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True))
+        return 0
+    parser.error(f"unsupported command: {args.command}")
+    return 2
+
+
+def ensure_runtime(
+    *,
+    repo: Path,
+    venv: Path,
+    extra: str,
+    force: bool = False,
+    git_pull: bool = False,
+) -> dict[str, Any]:
+    if not (repo / "pyproject.toml").exists():
+        raise SystemExit(f"Repo root does not contain pyproject.toml: {repo}")
+    git_pull_status = "disabled"
+    if git_pull:
+        git_pull_status = _git_pull_best_effort(repo)
+    venv_python = _venv_python(venv)
+    created_venv = False
+    if not venv_python.exists():
+        _log(f"Creating venv at {venv}")
+        _run([sys.executable, "-m", "venv", str(venv)], label="create venv")
+        created_venv = True
+    state_path = _state_path(repo)
+    desired_hash = _desired_state_hash(repo, extra=extra, bootstrap_python=sys.executable)
+    current_hash = _read_state_hash(state_path)
+    installed = False
+    if force or created_venv or current_hash != desired_hash:
+        _log("Installing/updating people-network-memory runtime")
+        _run([str(venv_python), "-m", "pip", "install", "--upgrade", "pip"], label="upgrade pip")
+        target = str(repo) if extra == "base" else f"{repo}[{extra}]"
+        _run([str(venv_python), "-m", "pip", "install", "-e", target], label="install package")
+        _write_state(
+            state_path,
+            {
+                "schema_version": STATE_SCHEMA_VERSION,
+                "state_hash": desired_hash,
+                "repo": str(repo),
+                "venv": str(venv),
+                "extra": extra,
+                "bootstrap_python": sys.executable,
+                "installed_at": datetime.now(timezone.utc).isoformat(),
+            },
+        )
+        installed = True
+    return {
+        "ok": True,
+        "repo": str(repo),
+        "venv": str(venv),
+        "python": str(venv_python),
+        "extra": extra,
+        "created_venv": created_venv,
+        "installed_or_updated": installed,
+        "git_pull": git_pull,
+        "git_pull_status": git_pull_status,
+    }
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Bootstrap People Network Memory runtime.")
+    sub = parser.add_subparsers(dest="command", required=True)
+    for command in ["run", "ensure", "update"]:
+        item = sub.add_parser(command)
+        item.add_argument("--repo")
+        item.add_argument("--venv")
+        item.add_argument("--extra", choices=["base", "graphiti"], default="base")
+        item.add_argument("--backend", choices=["local_json", "graphiti", "inmemory"], default="local_json")
+        item.add_argument("--force", action="store_true")
+        item.add_argument("--git-pull", action="store_true")
+        if command == "run":
+            item.add_argument("server_args", nargs=argparse.REMAINDER)
+        else:
+            item.set_defaults(server_args=[])
+    return parser
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _venv_python(venv: Path) -> Path:
+    if platform.system().lower().startswith("win"):
+        return venv / "Scripts" / "python.exe"
+    return venv / "bin" / "python"
+
+
+def _state_path(repo: Path) -> Path:
+    return repo / ".people-network-memory" / "bootstrap-state.json"
+
+
+def _desired_state_hash(repo: Path, *, extra: str, bootstrap_python: str) -> str:
+    digest = hashlib.sha256()
+    for path in [repo / "pyproject.toml", Path(__file__).resolve()]:
+        digest.update(path.name.encode("utf-8"))
+        digest.update(path.read_bytes())
+    digest.update(extra.encode("utf-8"))
+    digest.update(bootstrap_python.encode("utf-8"))
+    digest.update(f"{sys.version_info.major}.{sys.version_info.minor}".encode("ascii"))
+    return digest.hexdigest()
+
+
+def _read_state_hash(path: Path) -> str | None:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError):
+        return None
+    value = payload.get("state_hash")
+    return value if isinstance(value, str) else None
+
+
+def _write_state(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def _load_local_env(repo: Path) -> dict[str, str]:
+    path = repo / ".people-network-memory" / LOCAL_ENV_FILENAME
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return {}
+    except json.JSONDecodeError as exc:
+        raise SystemExit(f"Invalid local env JSON at {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise SystemExit(f"Local env JSON must be an object: {path}")
+    loaded: dict[str, str] = {}
+    for key, value in payload.items():
+        if not _allowed_local_env_name(key):
+            continue
+        if isinstance(value, str) and value:
+            loaded[key] = value
+    return loaded
+
+
+def _allowed_local_env_name(name: str) -> bool:
+    return (
+        name.startswith("PEOPLE_MEMORY_")
+        or name == "GRAPHITI_TELEMETRY_ENABLED"
+        or name == "VOLCENGINE_" + "API" + "_KEY"
+    )
+
+
+def _git_pull_best_effort(repo: Path) -> str:
+    inside_repo = subprocess.run(
+        ["git", "-C", str(repo), "rev-parse", "--is-inside-work-tree"],
+        capture_output=True,
+        text=True,
+    )
+    if inside_repo.returncode != 0:
+        _log("Skipping git pull: repo is not a git work tree")
+        return "skipped:not_git_repo"
+    upstream = subprocess.run(
+        ["git", "-C", str(repo), "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        capture_output=True,
+        text=True,
+    )
+    if upstream.returncode != 0:
+        _log("Skipping git pull: current branch has no upstream")
+        return "skipped:no_upstream"
+    command = ["git", "-C", str(repo), "pull", "--ff-only"]
+    _log(f"git pull: {' '.join(command)}")
+    result = subprocess.run(command, capture_output=True, text=True)
+    output = _trim_process_output(result.stdout, result.stderr)
+    if output:
+        _log(output)
+    if result.returncode != 0:
+        _log("Git pull failed; continuing with the existing checkout")
+        return f"failed:{result.returncode}"
+    return "ok"
+
+
+def _trim_process_output(stdout: str, stderr: str, *, limit: int = 800) -> str:
+    output = "\n".join(part.strip() for part in [stdout, stderr] if part.strip())
+    if len(output) <= limit:
+        return output
+    return output[:limit] + "... [truncated]"
+
+
+def _run(command: list[str], *, label: str) -> None:
+    _log(f"{label}: {' '.join(command)}")
+    subprocess.run(command, check=True)
+
+
+def _log(message: str) -> None:
+    print(f"[people-memory-bootstrap] {message}", file=sys.stderr, flush=True)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/run_graphiti_live_from_liepin.ps1

@@ -0,0 +1,87 @@
+param(
+  [string]$ArtifactsDir = ".people-network-memory/test-artifacts/graphiti-live",
+  [string]$LiepinConfigPath = "$HOME/.liepin-recommend-mcp/screening-config.json",
+  [string]$PythonCommand = "python"
+)
+
+$ErrorActionPreference = "Stop"
+
+$repoRoot = Split-Path -Parent $PSScriptRoot
+Set-Location $repoRoot
+
+$localEnvPath = Join-Path $repoRoot ".people-network-memory/local.env.json"
+if (Test-Path -LiteralPath $localEnvPath) {
+  $localEnv = Get-Content -LiteralPath $localEnvPath -Raw | ConvertFrom-Json
+  foreach ($property in $localEnv.PSObject.Properties) {
+    $name = $property.Name
+    $isAllowed = (
+      $name.StartsWith("PEOPLE_MEMORY_") -or
+      $name -eq "GRAPHITI_TELEMETRY_ENABLED" -or
+      $name -eq "VOLCENGINE_API_KEY"
+    )
+    if ($isAllowed -and -not [System.Environment]::GetEnvironmentVariable($name, "Process")) {
+      [System.Environment]::SetEnvironmentVariable($name, [string]$property.Value, "Process")
+    }
+  }
+}
+
+$resolvedLiepinConfigPath = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath(
+  $LiepinConfigPath
+)
+if (-not (Test-Path -LiteralPath $resolvedLiepinConfigPath)) {
+  throw "Liepin LLM config not found: $resolvedLiepinConfigPath"
+}
+
+$liepinConfig = Get-Content -LiteralPath $resolvedLiepinConfigPath -Raw | ConvertFrom-Json
+foreach ($field in @("baseUrl", "apiKey", "model")) {
+  if (-not $liepinConfig.PSObject.Properties.Name.Contains($field) -or -not $liepinConfig.$field) {
+    throw "Liepin LLM config is missing required field: $field"
+  }
+}
+
+if (-not $env:PEOPLE_MEMORY_EMBEDDING_API_KEY -and $env:VOLCENGINE_API_KEY) {
+  $env:PEOPLE_MEMORY_EMBEDDING_API_KEY = $env:VOLCENGINE_API_KEY
+}
+if (-not $env:PEOPLE_MEMORY_EMBEDDING_API_KEY) {
+  throw "Set PEOPLE_MEMORY_EMBEDDING_API_KEY or VOLCENGINE_API_KEY before running live Graphiti artifacts."
+}
+
+$env:PEOPLE_MEMORY_BACKEND = "graphiti"
+$env:PEOPLE_MEMORY_GRAPH_BACKEND = "kuzu"
+$env:PEOPLE_MEMORY_EMBEDDING_PROVIDER = "volcengine"
+$env:PEOPLE_MEMORY_EMBEDDING_BASE_URL = "https://ark.cn-beijing.volces.com/api/coding/v3"
+$env:PEOPLE_MEMORY_EMBEDDING_MODEL = "doubao-embedding-vision-251215"
+$env:PEOPLE_MEMORY_LLM_PROVIDER = "openai_compatible"
+$env:PEOPLE_MEMORY_LLM_BASE_URL = $liepinConfig.baseUrl
+$env:PEOPLE_MEMORY_LLM_MODEL = $liepinConfig.model
+$env:PEOPLE_MEMORY_LLM_API_KEY = $liepinConfig.apiKey
+$env:PEOPLE_MEMORY_LLM_RESPONSE_FORMAT = "none"
+$env:GRAPHITI_TELEMETRY_ENABLED = "false"
+
+& powershell -ExecutionPolicy Bypass -File .\scripts\run_tests_with_artifacts.ps1 `
+  -ArtifactsDir $ArtifactsDir `
+  -PythonCommand $PythonCommand `
+  -Graphiti
+$runnerExitCode = $LASTEXITCODE
+if ($runnerExitCode -ne 0) {
+  exit $runnerExitCode
+}
+
+$resolvedArtifactsDir = if ([System.IO.Path]::IsPathRooted($ArtifactsDir)) {
+  [System.IO.Path]::GetFullPath($ArtifactsDir)
+}
+else {
+  [System.IO.Path]::GetFullPath((Join-Path $repoRoot $ArtifactsDir))
+}
+$manifestPath = Join-Path $resolvedArtifactsDir "manifest.json"
+$manifest = Get-Content -LiteralPath $manifestPath -Raw | ConvertFrom-Json
+$failedGraphiti = @(
+  $manifest.steps | Where-Object { $_.name -like "graphiti_*" -and $_.exit_code -ne 0 }
+)
+if ($failedGraphiti.Count -gt 0) {
+  Write-Host "Failed live Graphiti steps:"
+  $failedGraphiti | ForEach-Object { Write-Host "  - $($_.name): exit $($_.exit_code)" }
+  exit 1
+}
+
+exit 0

package/scripts/run_tests_with_artifacts.ps1

@@ -0,0 +1,307 @@
+param(
+  [string]$ArtifactsDir = ".people-network-memory/test-artifacts/latest",
+  [string]$PythonCommand = "python",
+  [switch]$Graphiti,
+  [switch]$LiveLlm
+)
+
+$ErrorActionPreference = "Stop"
+
+$repoRoot = Split-Path -Parent $PSScriptRoot
+Set-Location $repoRoot
+
+$repoRootFull = [System.IO.Path]::GetFullPath($repoRoot)
+$resolvedArtifactsDir = [System.IO.Path]::GetFullPath((Join-Path $repoRoot $ArtifactsDir))
+if (-not $resolvedArtifactsDir.StartsWith($repoRootFull, [System.StringComparison]::OrdinalIgnoreCase)) {
+  throw "ArtifactsDir must resolve inside the repository root."
+}
+
+if ($PythonCommand -eq "python") {
+  $venvPython = Join-Path $repoRoot ".venv/Scripts/python.exe"
+  if (Test-Path -LiteralPath $venvPython) {
+    $PythonCommand = $venvPython
+  }
+}
+
+if (Test-Path -LiteralPath $resolvedArtifactsDir) {
+  Get-ChildItem -LiteralPath $resolvedArtifactsDir -Force | Remove-Item -Recurse -Force
+}
+New-Item -ItemType Directory -Force -Path $resolvedArtifactsDir | Out-Null
+
+$manifest = [ordered]@{
+  schema_version = 1
+  created_at = (Get-Date).ToUniversalTime().ToString("o")
+  repo_root = $repoRoot
+  artifacts_dir = $resolvedArtifactsDir
+  steps = @()
+}
+$manifestPath = Join-Path $resolvedArtifactsDir "manifest.json"
+$script:LastArtifactStepExitCode = $null
+
+function Save-Manifest {
+  $manifest | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath $manifestPath -Encoding UTF8
+}
+
+function Invoke-ArtifactStep {
+  param(
+    [string]$Name,
+    [string]$Command,
+    [string[]]$Arguments,
+    [string]$OutputFile,
+    [switch]$AllowFailure,
+    [switch]$CleanPeopleMemoryEnv
+  )
+
+  $outputPath = Join-Path $resolvedArtifactsDir $OutputFile
+  $startedAt = (Get-Date).ToUniversalTime().ToString("o")
+  Write-Host ""
+  Write-Host "==> $Name"
+  Write-Host "    $Command $($Arguments -join ' ')"
+  $step = [ordered]@{
+    name = $Name
+    command = $Command
+    arguments = $Arguments
+    output = $outputPath
+    exit_code = $null
+    allow_failure = [bool]$AllowFailure
+    clean_people_memory_env = [bool]$CleanPeopleMemoryEnv
+    started_at = $startedAt
+    finished_at = $null
+    status = "running"
+  }
+  $manifest.steps += $step
+  Save-Manifest
+
+  $previousErrorActionPreference = $ErrorActionPreference
+  $envSnapshot = @{}
+  if ($CleanPeopleMemoryEnv) {
+    $namesToClean = @(
+      Get-ChildItem Env: |
+        Where-Object { $_.Name -like "PEOPLE_MEMORY_*" } |
+        ForEach-Object { $_.Name }
+    )
+    $namesToClean += "GRAPHITI_TELEMETRY_ENABLED"
+    $namesToClean = @($namesToClean | Select-Object -Unique)
+    foreach ($envVarName in $namesToClean) {
+      $envSnapshot[$envVarName] = [System.Environment]::GetEnvironmentVariable($envVarName, "Process")
+      [System.Environment]::SetEnvironmentVariable($envVarName, $null, "Process")
+    }
+    $envSnapshot["PEOPLE_MEMORY_DISABLE_LOCAL_ENV"] = [System.Environment]::GetEnvironmentVariable("PEOPLE_MEMORY_DISABLE_LOCAL_ENV", "Process")
+    [System.Environment]::SetEnvironmentVariable("PEOPLE_MEMORY_DISABLE_LOCAL_ENV", "true", "Process")
+    $env:GRAPHITI_TELEMETRY_ENABLED = "false"
+  }
+  $ErrorActionPreference = "Continue"
+  try {
+    & $Command @Arguments *> $outputPath
+    $exitCode = $LASTEXITCODE
+    if ($null -eq $exitCode) {
+      $exitCode = 0
+    }
+  }
+  finally {
+    $ErrorActionPreference = $previousErrorActionPreference
+    if ($CleanPeopleMemoryEnv) {
+      foreach ($envVarName in $envSnapshot.Keys) {
+        [System.Environment]::SetEnvironmentVariable($envVarName, $envSnapshot[$envVarName], "Process")
+      }
+    }
+  }
+  $finishedAt = (Get-Date).ToUniversalTime().ToString("o")
+
+  $step["exit_code"] = $exitCode
+  $step["finished_at"] = $finishedAt
+  $step["status"] = "completed"
+  $script:LastArtifactStepExitCode = $exitCode
+  Save-Manifest
+
+  if ($exitCode -ne 0 -and -not $AllowFailure) {
+    Write-Host "    failed with exit code $exitCode"
+  }
+}
+
+function Add-SkippedArtifactStep {
+  param(
+    [string]$Name,
+    [string]$Reason
+  )
+  $now = (Get-Date).ToUniversalTime().ToString("o")
+  $manifest.steps += [ordered]@{
+    name = $Name
+    command = ""
+    arguments = @()
+    output = ""
+    exit_code = 0
+    allow_failure = $true
+    clean_people_memory_env = $false
+    started_at = $now
+    finished_at = $now
+    status = "skipped"
+    reason = $Reason
+  }
+  Save-Manifest
+}
+
+Invoke-ArtifactStep `
+  -Name "unit_tests" `
+  -Command $PythonCommand `
+  -Arguments @("-m", "unittest", "discover", "-s", "tests", "-v") `
+  -OutputFile "unittest.txt" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "mcp_test_mode_start" `
+  -Command $PythonCommand `
+  -Arguments @("-m", "people_network_memory.cli", "start", "--test-mode", "--once") `
+  -OutputFile "mcp-start.json" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "doctor_test_mode" `
+  -Command $PythonCommand `
+  -Arguments @("-m", "people_network_memory.cli", "doctor", "--test-mode") `
+  -OutputFile "doctor-test-mode.json" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "tool_schemas" `
+  -Command $PythonCommand `
+  -Arguments @("-m", "people_network_memory.cli", "tool-schemas") `
+  -OutputFile "tool-schemas.json" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "fixture_eval" `
+  -Command $PythonCommand `
+  -Arguments @(
+    "-m", "people_network_memory.cli", "eval-fixtures",
+    "--include-cases",
+    "--output", (Join-Path $resolvedArtifactsDir "eval-fixtures.json")
+  ) `
+  -OutputFile "eval-fixtures.stdout.json" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "fixture_eval_report" `
+  -Command $PythonCommand `
+  -Arguments @(
+    "-m", "people_network_memory.cli", "report-eval",
+    "--input", (Join-Path $resolvedArtifactsDir "eval-fixtures.json"),
+    "--output", (Join-Path $resolvedArtifactsDir "eval-fixtures-report.md"),
+    "--title", "Fixture Retrieval Test Report"
+  ) `
+  -OutputFile "eval-fixtures-report.stdout.json" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "openclaw_smoke" `
+  -Command $PythonCommand `
+  -Arguments @("-m", "people_network_memory.cli", "smoke-openclaw") `
+  -OutputFile "smoke-openclaw.json" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "harness_integration_eval" `
+  -Command $PythonCommand `
+  -Arguments @(
+    "-m", "people_network_memory.cli", "eval-harness-integration",
+    "--output", (Join-Path $resolvedArtifactsDir "harness-integration-eval.json")
+  ) `
+  -OutputFile "harness-integration-eval.stdout.json" `
+  -CleanPeopleMemoryEnv
+
+Invoke-ArtifactStep `
+  -Name "release_check" `
+  -Command $PythonCommand `
+  -Arguments @(
+    "-m", "people_network_memory.cli", "release-check",
+    "--output", (Join-Path $resolvedArtifactsDir "release-check.json")
+  ) `
+  -OutputFile "release-check.stdout.json" `
+  -CleanPeopleMemoryEnv
+
+if ($LiveLlm) {
+  Invoke-ArtifactStep `
+    -Name "llm_extractor_eval" `
+    -Command $PythonCommand `
+    -Arguments @(
+      "-m", "people_network_memory.cli", "eval-extractor",
+      "--output", (Join-Path $resolvedArtifactsDir "llm-extractor-eval.json")
+    ) `
+    -OutputFile "llm-extractor-eval.stdout.json"
+}
+
+Invoke-ArtifactStep `
+  -Name "git_diff_check" `
+  -Command "git" `
+  -Arguments @("diff", "--check") `
+  -OutputFile "git-diff-check.txt"
+
+Invoke-ArtifactStep `
+  -Name "git_status" `
+  -Command "git" `
+  -Arguments @("status", "--short") `
+  -OutputFile "git-status.txt"
+
+if ($Graphiti) {
+  Invoke-ArtifactStep `
+    -Name "graphiti_embedding_check" `
+    -Command $PythonCommand `
+    -Arguments @("-m", "people_network_memory.cli", "check-embedding") `
+    -OutputFile "embedding-check.json" `
+    -AllowFailure
+
+  Invoke-ArtifactStep `
+    -Name "graphiti_spike" `
+    -Command $PythonCommand `
+    -Arguments @("-m", "people_network_memory.cli", "spike-graphiti") `
+    -OutputFile "graphiti-spike.json" `
+    -AllowFailure
+
+  Invoke-ArtifactStep `
+    -Name "graphiti_promotion_gate" `
+    -Command $PythonCommand `
+    -Arguments @(
+      "-m", "people_network_memory.cli", "graphiti-gate",
+      "--isolated",
+      "--include-cases",
+      "--all-cases",
+      "--output", (Join-Path $resolvedArtifactsDir "graphiti-gate.json")
+    ) `
+    -OutputFile "graphiti-gate.stdout.json" `
+    -AllowFailure
+
+  if ($script:LastArtifactStepExitCode -eq 0) {
+    Invoke-ArtifactStep `
+      -Name "graphiti_eval_smoke" `
+      -Command $PythonCommand `
+      -Arguments @(
+        "-m", "people_network_memory.cli", "eval-graphiti",
+        "--isolated",
+        "--max-interactions", "2",
+        "--max-queries", "2",
+        "--output", (Join-Path $resolvedArtifactsDir "graphiti-eval.json")
+      ) `
+      -OutputFile "graphiti-eval.stdout.json" `
+      -AllowFailure
+  }
+  else {
+    Add-SkippedArtifactStep `
+      -Name "graphiti_eval_smoke" `
+      -Reason "Skipped because graphiti_promotion_gate did not pass."
+  }
+}
+
+Save-Manifest
+
+$failed = @($manifest.steps | Where-Object { $null -ne $_.exit_code -and $_.exit_code -ne 0 -and -not $_.allow_failure })
+Write-Host ""
+Write-Host "Artifacts saved to $resolvedArtifactsDir"
+Write-Host "Manifest: $manifestPath"
+
+if ($failed.Count -gt 0) {
+  Write-Host "Failed required steps:"
+  $failed | ForEach-Object { Write-Host "  - $($_.name): exit $($_.exit_code)" }
+  exit 1
+}
+
+Write-Host "All required artifact steps passed."

package/src/people_network_memory/__init__.py

@@ -0,0 +1,6 @@
+"""People Network Memory package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"
+

package/src/people_network_memory/application/__init__.py

@@ -0,0 +1,16 @@
+"""Application use cases."""
+
+from people_network_memory.application.services import (
+    BuildPersonCardService,
+    RecordInteractionService,
+    ResolveIdentityService,
+    RetrieveContextService,
+)
+
+__all__ = [
+    "BuildPersonCardService",
+    "RecordInteractionService",
+    "ResolveIdentityService",
+    "RetrieveContextService",
+]
+