planr 1.4.0 → 1.5.0

package/website/catalog-model.mjs

@@ -1,185 +0,0 @@
-const IDENTIFIER = /^[A-Za-z0-9._-]+$/;
-
-export function safeIdentifier(value, label = "identifier") {
-  if (typeof value !== "string" || !IDENTIFIER.test(value)) {
-    throw new Error(`${label} is not a safe registry identifier`);
-  }
-  return value;
-}
-
-export function previewCommand(policyId, bindingId) {
-  return `planr agents preset apply ${safeIdentifier(policyId, "policy id")} --binding ${safeIdentifier(bindingId, "binding id")}`;
-}
-
-export function statusLabel(status) {
-  const labels = {
-    experimental: "Experimental",
-    verified: "Verified",
-    recommended: "Recommended",
-    stale: "Stale",
-    deprecated: "Deprecated",
-  };
-  return labels[status] ?? "Unverified";
-}
-
-export function formatBasisPoints(value) {
-  const basisPoints = Number(value);
-  return Number.isFinite(basisPoints) ? `${(basisPoints / 100).toFixed(2)}%` : "—";
-}
-
-function findArtifact(entry, kind) {
-  const artifacts = entry.artifacts.filter((artifact) => artifact.kind === kind);
-  if (artifacts.length !== 1) {
-    throw new Error(`registry entry must contain exactly one ${kind} artifact`);
-  }
-  return artifacts[0];
-}
-
-function proposedConfig(preview, kind) {
-  const artifact = preview.artifacts.find((candidate) => candidate.kind === kind);
-  const value = artifact?.config_diff?.proposed?.value;
-  if (!value || typeof value !== "object") {
-    throw new Error(`preset preview is missing proposed ${kind} configuration`);
-  }
-  return value;
-}
-
-function matchingCandidate(report, policyId, bindingId) {
-  const candidate = report.candidates?.find(
-    (value) => value.policy?.id === policyId && value.binding?.id === bindingId,
-  );
-  if (!candidate) {
-    throw new Error(`evaluation report has no candidate for ${policyId} + ${bindingId}`);
-  }
-  return candidate;
-}
-
-function recommendationMatches(report, policyId, bindingId) {
-  return Boolean(
-    report.recommended?.some(
-      (value) => value.policy === policyId && value.binding === bindingId && value.status === "recommended",
-    ),
-  );
-}
-
-export function projectComposition({ verified, preview, verificationEnvelope }) {
-  if (!verified?.integrity_verified || !verified?.signature_verified || !verified?.trusted_maintainer) {
-    throw new Error("website projection requires an integrity-verified entry signed by a trusted maintainer");
-  }
-  if (!verified.compatible) {
-    throw new Error("website projection requires a compatible registry entry");
-  }
-  if (!preview?.pack?.safe) {
-    throw new Error("website projection requires a canonical safe-pack preview");
-  }
-
-  const entry = verified.entry;
-  const evaluation = entry.evaluation;
-  if (!evaluation) {
-    throw new Error("website projection requires evaluation binding metadata");
-  }
-  const policyId = safeIdentifier(evaluation.policy_id, "policy id");
-  const bindingId = safeIdentifier(evaluation.binding_id, "binding id");
-  const report = verificationEnvelope.report ?? verificationEnvelope;
-  const candidate = matchingCandidate(report, policyId, bindingId);
-  const reportRecommended = recommendationMatches(report, policyId, bindingId);
-  if (verified.recommended && (!reportRecommended || candidate.status !== "recommended")) {
-    throw new Error("registry recommendation does not match canonical evaluation evidence");
-  }
-
-  const policy = proposedConfig(preview, "active_policy");
-  const agents = proposedConfig(preview, "agent_registry");
-  if (policy.id !== policyId || preview.composition?.binding?.id !== bindingId) {
-    throw new Error("preset preview provenance does not match registry evaluation binding");
-  }
-  const runs = Number(candidate.metrics?.runs ?? 0);
-  const verifiedRoutes = Number(candidate.metrics?.verified_route_runs ?? 0);
-  const policyArtifact = findArtifact(entry, "policy");
-  const bindingArtifact = findArtifact(entry, "host-binding");
-  const verificationArtifact = findArtifact(entry, "verification");
-
-  return {
-    id: `${safeIdentifier(entry.id, "entry id")}@${entry.version}`,
-    entryId: entry.id,
-    entryVersion: entry.version,
-    status: verified.effective_status,
-    statusLabel: statusLabel(verified.effective_status),
-    recommended: verified.recommended,
-    freshness: verified.freshness,
-    lifecycle: entry.lifecycle,
-    replacement: entry.replacement ?? null,
-    policy: {
-      id: policyId,
-      version: evaluation.policy_version,
-      usage: policy.usage,
-      transitions: policy.transitions,
-      materiality: policy.materiality,
-      execution: policy.execution,
-    },
-    binding: {
-      id: bindingId,
-      version: evaluation.binding_version,
-      host: preview.composition.host,
-      profiles: agents.profiles,
-      dispatch: preview.composition.dispatch,
-    },
-    compatibility: {
-      hosts: entry.compatible_hosts,
-      minPlanrVersion: entry.min_planr_version,
-      maxPlanrVersion: entry.max_planr_version,
-    },
-    enforcement: [
-      {
-        dimension: "Policy limits",
-        state: "verified",
-        detail: "Planr validates count, time, concurrency, transition, and safety-stop limits before dispatch.",
-      },
-      {
-        dimension: "Execution permissions",
-        state: "verified",
-        detail: "Registry-safe policy: no commands, hooks, network/MCP grants, secrets, or overwrite permission.",
-      },
-      {
-        dimension: "Model and effort",
-        state: "host_enforced",
-        detail: "The host binding requests concrete routes; the host retains final execution authority.",
-      },
-      {
-        dimension: "Effective route evidence",
-        state: runs > 0 && verifiedRoutes === runs ? "verified" : "unavailable",
-        detail: `${verifiedRoutes} of ${runs} evaluation runs carried verified effective-route evidence.`,
-      },
-    ],
-    evaluation: {
-      suiteId: report.suite?.id,
-      suiteVersion: report.suite?.version,
-      evaluatedAtUnix: report.suite?.evaluated_at_unix,
-      reviewAtUnix: entry.review_at_unix,
-      status: candidate.status,
-      metrics: candidate.metrics,
-      thresholds: candidate.threshold_results,
-      resultHashes: candidate.results?.map((result) => result.result_sha256) ?? [],
-      fixtureSha256: report.suite?.fixture_sha256,
-    },
-    registry: {
-      id: verified.registry_id,
-      version: verified.registry_version,
-      manifestSha256: verified.manifest_sha256,
-      signer: entry.signature?.signer,
-      signatureVerified: true,
-      trustedMaintainer: true,
-      artifacts: [policyArtifact, bindingArtifact, verificationArtifact].map((artifact) => ({
-        path: artifact.path,
-        kind: artifact.kind,
-        sha256: artifact.sha256,
-        sizeBytes: artifact.size_bytes,
-      })),
-    },
-    command: previewCommand(policyId, bindingId),
-  };
-}
-
-export function visibleCompositions(catalog, recommendedOnly = false) {
-  const compositions = Array.isArray(catalog?.compositions) ? catalog.compositions : [];
-  return recommendedOnly ? compositions.filter((entry) => entry.recommended) : compositions;
-}

package/website/catalog-model.test.mjs

@@ -1,124 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  formatBasisPoints,
-  previewCommand,
-  projectComposition,
-  safeIdentifier,
-  visibleCompositions,
-} from "./catalog-model.mjs";
-
-function fixture() {
-  const verified = {
-    registry_id: "official",
-    registry_version: "2026.07",
-    manifest_sha256: "a".repeat(64),
-    integrity_verified: true,
-    signature_verified: true,
-    trusted_maintainer: true,
-    compatible: true,
-    freshness: "current",
-    effective_status: "recommended",
-    recommended: true,
-    entry: {
-      id: "balanced-codex",
-      version: "1.0.0",
-      lifecycle: "published",
-      compatible_hosts: ["codex"],
-      min_planr_version: "1.3.0",
-      max_planr_version: "1.9.0",
-      review_at_unix: 1815523200,
-      evaluation: {
-        policy_id: "balanced",
-        policy_version: "1.0.0",
-        binding_id: "codex-openai",
-        binding_version: "1.0.0",
-      },
-      signature: { signer: "planr-maintainers" },
-      artifacts: [
-        { path: "pack/policy.toml", kind: "policy", sha256: "1".repeat(64), size_bytes: 1 },
-        { path: "pack/binding.toml", kind: "host-binding", sha256: "2".repeat(64), size_bytes: 2 },
-        { path: "pack/verification.json", kind: "verification", sha256: "3".repeat(64), size_bytes: 3 },
-      ],
-    },
-  };
-  const policy = {
-    id: "balanced",
-    usage: { max_active_agents: 3, max_parallel_writers: 1, max_depth: 1, metering: "trusted" },
-    transitions: { retry: { max_same_route_retries: 1 }, safety_stop: { enabled: true } },
-    materiality: { changed_files_threshold: 10 },
-    execution: { roles: { worker: { commands: [], hooks: [], network_hosts: [], mcp_servers: [] } } },
-  };
-  const preview = {
-    pack: { safe: true },
-    composition: { host: "codex", binding: { id: "codex-openai" }, dispatch: {} },
-    artifacts: [
-      { kind: "active_policy", config_diff: { proposed: { value: policy } } },
-      { kind: "agent_registry", config_diff: { proposed: { value: { profiles: {} } } } },
-    ],
-  };
-  const candidate = {
-    policy: { id: "balanced" },
-    binding: { id: "codex-openai" },
-    status: "recommended",
-    metrics: { runs: 7, verified_route_runs: 7, average_quality_score_bps: 9600 },
-    threshold_results: [{ name: "quality", pass: true }],
-    results: [{ result_sha256: "4".repeat(64) }],
-  };
-  const verificationEnvelope = {
-    report: {
-      suite: { id: "planr-preset-suite", version: "1.8.0", evaluated_at_unix: 1783987200, fixture_sha256: "5".repeat(64) },
-      candidates: [candidate],
-      recommended: [{ policy: "balanced", binding: "codex-openai", status: "recommended" }],
-    },
-  };
-  return { verified, preview, verificationEnvelope };
-}
-
-test("projects only trusted, safe, evidence-bound registry entries", () => {
-  const projected = projectComposition(fixture());
-  assert.equal(projected.status, "recommended");
-  assert.equal(projected.registry.signatureVerified, true);
-  assert.equal(projected.enforcement.at(-1).state, "verified");
-  assert.equal(projected.command, "planr agents preset apply balanced --binding codex-openai");
-});
-
-test("refuses unsigned metadata and recommendation drift", () => {
-  const unsigned = fixture();
-  unsigned.verified.signature_verified = false;
-  assert.throws(() => projectComposition(unsigned), /trusted maintainer/);
-
-  const drifted = fixture();
-  drifted.verificationEnvelope.report.recommended = [];
-  assert.throws(() => projectComposition(drifted), /does not match/);
-});
-
-test("publishes lifecycle-demoted recommendations with visible replacement metadata", () => {
-  const stale = fixture();
-  stale.verified.freshness = "stale";
-  stale.verified.effective_status = "stale";
-  stale.verified.recommended = false;
-  const staleProjected = projectComposition(stale);
-  assert.equal(staleProjected.status, "stale");
-  assert.equal(staleProjected.recommended, false);
-
-  const deprecated = fixture();
-  deprecated.verified.effective_status = "deprecated";
-  deprecated.verified.recommended = false;
-  deprecated.verified.entry.lifecycle = "deprecated";
-  deprecated.verified.entry.replacement = "balanced-codex-v2";
-  const deprecatedProjected = projectComposition(deprecated);
-  assert.equal(deprecatedProjected.status, "deprecated");
-  assert.equal(deprecatedProjected.replacement, "balanced-codex-v2");
-});
-
-test("copy commands accept identifiers only and filtering is deterministic", () => {
-  assert.equal(previewCommand("balanced", "codex-openai"), "planr agents preset apply balanced --binding codex-openai");
-  assert.throws(() => safeIdentifier("balanced; curl evil"), /safe registry identifier/);
-  assert.deepEqual(
-    visibleCompositions({ compositions: [{ recommended: true }, { recommended: false }] }, true),
-    [{ recommended: true }],
-  );
-  assert.equal(formatBasisPoints(9600), "96.00%");
-  assert.equal(formatBasisPoints(undefined), "—");
-});

package/website/cloudflare-launcher.test.mjs

@@ -1,38 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-import { cloudflareTestSteps } from "../scripts/cloudflare-test.mjs";
-
-test("launcher keeps deploy and destroy pinned to the test stage", () => {
-  assert.deepEqual(cloudflareTestSteps("deploy"), [
-    ["pnpm", ["site:check"]],
-    ["pnpm", ["exec", "alchemy", "deploy", "--stage", "test"]],
-  ]);
-  assert.deepEqual(cloudflareTestSteps("destroy"), [
-    ["pnpm", ["exec", "alchemy", "destroy", "--stage", "test"]],
-  ]);
-  assert.throws(() => cloudflareTestSteps("prod"), /usage:/);
-});
-
-const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const launcher = join(repositoryRoot, "scripts", "cloudflare-test.mjs");
-for (const version of ["v18.16.1", "v20.19.5"]) {
-  const node = join(homedir(), ".nvm", "versions", "node", version, "bin", "node");
-  test(
-    `direct launcher rejects ${version} before invoking pnpm`,
-    { skip: !existsSync(node) && `local ${version} runtime is unavailable` },
-    () => {
-      const result = spawnSync(node, [launcher, "deploy"], {
-        cwd: repositoryRoot,
-        encoding: "utf8",
-      });
-      assert.equal(result.status, 1);
-      assert.match(result.stderr, /Cloudflare deployment requires Node\.js 22 or newer/);
-      assert.doesNotMatch(result.stderr, /Corepack|ERR_VM|addAbortListener|experimental-strip-types/);
-    },
-  );
-}

package/website/data/catalog.json

@@ -1,307 +0,0 @@
-{
-  "schemaVersion": 1,
-  "generatedAtUnix": 1783987200,
-  "source": {
-    "state": "verified_registry_projection",
-    "manifest": "website/registry/manifest.toml",
-    "entryCount": 1,
-    "trust": "planr_registry_v1"
-  },
-  "compositions": [
-    {
-      "id": "balanced-codex@1.0.0",
-      "entryId": "balanced-codex",
-      "entryVersion": "1.0.0",
-      "status": "recommended",
-      "statusLabel": "Recommended",
-      "recommended": true,
-      "freshness": "current",
-      "lifecycle": "published",
-      "replacement": null,
-      "policy": {
-        "id": "balanced",
-        "version": "1.0.0",
-        "usage": {
-          "budget_exhaustion": "stop",
-          "max_active_agents": 3,
-          "max_attempts": 4,
-          "max_depth": 1,
-          "max_parallel_readers": 2,
-          "max_parallel_writers": 1,
-          "max_tool_calls": 120,
-          "max_wall_time_seconds": 3600,
-          "metering": "estimated",
-          "review_reserve_percent": 20
-        },
-        "transitions": {
-          "availability_fallback": {
-            "max_fallbacks": 1,
-            "require_same_capability_class": true
-          },
-          "quality_escalation": {
-            "max_escalations": 1,
-            "require_verification_evidence": true
-          },
-          "quota_downgrade": {
-            "enabled": false,
-            "max_downgrades": 0,
-            "noncritical_only": true
-          },
-          "retry": {
-            "max_same_route_retries": 1
-          },
-          "safety_stop": {
-            "enabled": true
-          }
-        },
-        "materiality": {
-          "changed_files_threshold": 10,
-          "changed_lines_threshold": 500
-        },
-        "execution": {
-          "max_read_scope_entries": 8,
-          "max_write_scope_entries": 4,
-          "roles": {
-            "worker": {
-              "approvals": [],
-              "commands": [],
-              "environment": [],
-              "filesystem": {
-                "allow_overwrite": false,
-                "read_roots": [
-                  "docs",
-                  "src",
-                  "tests"
-                ],
-                "write_roots": [
-                  "docs",
-                  "src",
-                  "tests"
-                ]
-              },
-              "hooks": [],
-              "mcp_servers": [],
-              "network_hosts": [],
-              "secret_references": "[REDACTED]",
-              "tools": [
-                "cargo",
-                "git",
-                "rg"
-              ]
-            }
-          }
-        }
-      },
-      "binding": {
-        "id": "codex-openai",
-        "version": "1.0.0",
-        "host": "codex",
-        "profiles": {
-          "codex-openai-driver": {
-            "capabilities": [],
-            "client": "codex",
-            "cost_tier": "premium",
-            "effort": "xhigh",
-            "model": "gpt-5.5"
-          },
-          "codex-openai-worker": {
-            "capabilities": [],
-            "client": "codex",
-            "cost_tier": "standard",
-            "effort": "high",
-            "model": "gpt-5.4-mini",
-            "skill": "planr-work"
-          }
-        },
-        "dispatch": {
-          "driver": {
-            "capability_evidence": [
-              "builtin-codex-none-fork-contract"
-            ],
-            "effort_override": false,
-            "fork_turns": {
-              "mode": "none"
-            },
-            "model_override": false
-          },
-          "worker": {
-            "capability_evidence": [
-              "builtin-codex-none-fork-contract"
-            ],
-            "effort_override": true,
-            "fork_turns": {
-              "mode": "none"
-            },
-            "model_override": true
-          }
-        }
-      },
-      "compatibility": {
-        "hosts": [
-          "codex"
-        ],
-        "minPlanrVersion": "1.3.0",
-        "maxPlanrVersion": "1.9.0"
-      },
-      "enforcement": [
-        {
-          "dimension": "Policy limits",
-          "state": "verified",
-          "detail": "Planr validates count, time, concurrency, transition, and safety-stop limits before dispatch."
-        },
-        {
-          "dimension": "Execution permissions",
-          "state": "verified",
-          "detail": "Registry-safe policy: no commands, hooks, network/MCP grants, secrets, or overwrite permission."
-        },
-        {
-          "dimension": "Model and effort",
-          "state": "host_enforced",
-          "detail": "The host binding requests concrete routes; the host retains final execution authority."
-        },
-        {
-          "dimension": "Effective route evidence",
-          "state": "verified",
-          "detail": "7 of 7 evaluation runs carried verified effective-route evidence."
-        }
-      ],
-      "evaluation": {
-        "suiteId": "planr-preset-suite",
-        "suiteVersion": "1.8.0",
-        "evaluatedAtUnix": 1783987200,
-        "reviewAtUnix": 1815523200,
-        "status": "recommended",
-        "metrics": {
-          "actual_task_runs": 7,
-          "availability_fallbacks": 7,
-          "average_credits_micros": 100,
-          "average_quality_score_bps": 10000,
-          "corrections": 7,
-          "metrics_source": "trusted_telemetry",
-          "oracle_passes": 7,
-          "p95_latency_ms": 228,
-          "quality_escalations": 7,
-          "reliability_bps": 10000,
-          "retries": 7,
-          "runs": 7,
-          "safety_stop_attempts": 1,
-          "safety_stop_failures": 0,
-          "total_credits_micros": 700,
-          "total_tokens": 70,
-          "total_tool_calls": 7,
-          "transition_contract_failures": 0,
-          "verified_result_hashes": 7,
-          "verified_route_runs": 7,
-          "violations": 0
-        },
-        "thresholds": [
-          {
-            "actual": "7",
-            "name": "minimum_runs",
-            "pass": true,
-            "rule": ">= 7"
-          },
-          {
-            "actual": "10000",
-            "name": "quality",
-            "pass": true,
-            "rule": ">= 8500 bps"
-          },
-          {
-            "actual": "10000",
-            "name": "reliability",
-            "pass": true,
-            "rule": ">= 9000 bps"
-          },
-          {
-            "actual": "100",
-            "name": "average_cost",
-            "pass": true,
-            "rule": "<= 1200000 credits_micros"
-          },
-          {
-            "actual": "228",
-            "name": "p95_latency",
-            "pass": true,
-            "rule": "<= 5000 ms"
-          },
-          {
-            "actual": "0",
-            "name": "transition_contract",
-            "pass": true,
-            "rule": "<= 0 failures"
-          },
-          {
-            "actual": "0",
-            "name": "safety_stop",
-            "pass": true,
-            "rule": "<= 0 failures"
-          },
-          {
-            "actual": "7/7",
-            "name": "actual_task_runs",
-            "pass": true,
-            "rule": "all fixtures executed"
-          },
-          {
-            "actual": "7/7",
-            "name": "output_oracles",
-            "pass": true,
-            "rule": "all task output oracles pass"
-          },
-          {
-            "actual": "7/7",
-            "name": "route_evidence",
-            "pass": true,
-            "rule": "all runs verified"
-          },
-          {
-            "actual": "7/7",
-            "name": "result_hashes",
-            "pass": true,
-            "rule": "all result hashes verified"
-          }
-        ],
-        "resultHashes": [
-          "c721c30da6e5f988de6741e8d4e611f7f45ad36425559a6b67ae4723869619be",
-          "e026c322f1f094f7241d352a8e9c70f10b89d456e7f42825b3c689dc5d785dc9",
-          "c74bf8de8296ff94ba45deeac158b619e3eb99c4e1b5251169bc2f1586518979",
-          "f76f06ae46bc2ce05bd631ee1f702e348a8dd3b8d4b2e53d59c409af4f330015",
-          "2165057d66dcc73722a57d01fb237a73f4da12bc70ab8757c817975925bfbbd8",
-          "052de2acf92d0ac000a15b92b26d5f173fe4ff606ee1dbe37df1e4a535cbdff8",
-          "41bf6ab560a23c450e9def8944c934091b598d270978fef8aaae0933f806619e"
-        ],
-        "fixtureSha256": "733c94e049d784eec2fa222f60c230e3f185ccefc84c23c313b1d7e85b60ab22"
-      },
-      "registry": {
-        "id": "planr-official",
-        "version": "2026.07",
-        "manifestSha256": "1512df7f667dd1c8f92b2eb39a06739336048dde58327195ada85b419a6cb4c7",
-        "signer": "planr-release-2026",
-        "signatureVerified": true,
-        "trustedMaintainer": true,
-        "artifacts": [
-          {
-            "path": "presets/policies/balanced.toml",
-            "kind": "policy",
-            "sha256": "827667b678224f6b09f7c3faab188ede4c7bad49cd2fc9fa8e46f01d61147080",
-            "sizeBytes": 993
-          },
-          {
-            "path": "presets/bindings/codex-openai.toml",
-            "kind": "host-binding",
-            "sha256": "2f1f1d91000aff8e6a7424f0380c16c46d24ee38c94de5a9beee2158c0bf6575",
-            "sizeBytes": 1449
-          },
-          {
-            "path": "website/registry/verification.json",
-            "kind": "verification",
-            "sha256": "7d1e36372b050ecab5080ea029fd3594f8f8f1df2f1d391c36aebd0fb56cf99a",
-            "sizeBytes": 276027
-          }
-        ]
-      },
-      "command": "planr agents preset apply balanced --binding codex-openai"
-    }
-  ]
-}