@rosetears/aili-pi 0.1.0

package/scripts/bootstrap.sh

@@ -0,0 +1,180 @@
+#!/bin/sh
+set -eu
+
+PACKAGE_SOURCE='npm:@rosetears/aili-pi@latest'
+PACKAGE_ID='npm:@rosetears/aili-pi'
+MINIMUM_PI_VERSION='0.81.1'
+OFFICIAL_INSTALLER_URL='https://pi.dev/install.sh'
+UPDATE_PI=0
+PI_STATE='existing'
+AILI_PREEXISTING='unknown'
+
+say() {
+  printf '%s\n' "$1"
+}
+
+fail() {
+  say "AILI bootstrap: ERROR stage=$1"
+  say "pi_state=$PI_STATE"
+  say "aili_state=$AILI_PREEXISTING"
+  say 'repair=resolve-the-reported-stage-and-rerun-install.sh'
+  exit 1
+}
+
+usage() {
+  say 'Usage: install.sh [--update-pi]'
+  say '  --update-pi  update official Pi before compatibility checks'
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --update-pi) UPDATE_PI=1 ;;
+    -h|--help) usage; exit 0 ;;
+    *) say "AILI bootstrap: unsupported argument: $1"; usage; exit 2 ;;
+  esac
+  shift
+done
+
+case "$(uname -s 2>/dev/null || true)" in
+  Linux) PLATFORM='linux' ;;
+  Darwin)
+    say 'AILI bootstrap: ERROR stage=platform unsupported=macos'
+    say 'aili_state=unknown'
+    exit 1
+    ;;
+  *)
+    say 'AILI bootstrap: ERROR stage=platform unsupported=native-windows-or-other'
+    say 'aili_state=unknown'
+    exit 1
+    ;;
+esac
+ARCHITECTURE=$(uname -m 2>/dev/null || true)
+case "$ARCHITECTURE" in
+  ''|*[!A-Za-z0-9_.-]*) fail 'platform-architecture' ;;
+esac
+
+TEMP_DIR=''
+cleanup() {
+  if [ -n "$TEMP_DIR" ] && [ -d "$TEMP_DIR" ]; then
+    rm -rf "$TEMP_DIR"
+  fi
+}
+trap cleanup EXIT HUP INT TERM
+
+has_pi() {
+  command -v pi >/dev/null 2>&1
+}
+
+ensure_temp_dir() {
+  if [ -z "$TEMP_DIR" ]; then
+    TEMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/aili-pi-bootstrap.XXXXXX") || fail 'temporary-directory'
+    chmod 700 "$TEMP_DIR" || fail 'temporary-directory-permissions'
+  fi
+}
+
+install_official_pi() {
+  PI_STATE='install-attempted'
+  ensure_temp_dir
+  installer="$TEMP_DIR/pi-install.sh"
+
+  command -v curl >/dev/null 2>&1 || fail 'official-installer-download-tool'
+  curl --fail --silent --show-error --location \
+    --proto '=https' --proto-redir '=https' \
+    --connect-timeout 15 --max-time 120 --max-filesize 1048576 \
+    "$OFFICIAL_INSTALLER_URL" -o "$installer" || fail 'official-installer-download'
+  chmod 600 "$installer" || fail 'official-installer-permissions'
+  sh "$installer" || fail 'official-pi-install'
+  hash -r 2>/dev/null || true
+  has_pi || fail 'official-pi-executable'
+  PI_STATE='installed'
+}
+
+version_compatible() {
+  version=$1
+  minimum=$2
+  old_ifs=$IFS
+  IFS=.
+  set -- $version
+  IFS=$old_ifs
+  [ "$#" -eq 3 ] || return 1
+  major=$1 minor=$2 patch=$3
+  case "$major$minor$patch" in *[!0-9]*) return 1 ;; esac
+  old_ifs=$IFS
+  IFS=.
+  set -- $minimum
+  IFS=$old_ifs
+  min_major=$1 min_minor=$2 min_patch=$3
+  [ "$major" -gt "$min_major" ] && return 0
+  [ "$major" -lt "$min_major" ] && return 1
+  [ "$minor" -gt "$min_minor" ] && return 0
+  [ "$minor" -lt "$min_minor" ] && return 1
+  [ "$patch" -ge "$min_patch" ]
+}
+
+preflight() {
+  raw_version=$(pi --version 2>/dev/null) || fail 'pi-version-probe'
+  case "$raw_version" in
+    *[!0-9.]*|*.*.*.*|'') fail 'pi-version-format' ;;
+  esac
+  version=$raw_version
+  version_compatible "$version" "$MINIMUM_PI_VERSION" || fail 'pi-version-incompatible'
+
+  help=$(pi --help 2>/dev/null) || fail 'pi-api-probe'
+  for required in '--extension' '--no-extensions' '--no-skills' '--no-prompt-templates' '--mode' '--no-session' '--print' '--offline' '--list-models'; do
+    printf '%s\n' "$help" | grep -E -- "^[[:space:]]*$required([,[:space:]]|$)" >/dev/null \
+      || fail 'pi-api-incompatible'
+  done
+
+  list_output=$(pi list 2>/dev/null) || fail 'pi-package-resource-probe'
+  case "$list_output" in
+    *"$PACKAGE_ID"*|*'@rosetears/aili-pi'*) AILI_PREEXISTING='present-before-run' ;;
+    *) AILI_PREEXISTING='absent-before-run' ;;
+  esac
+  ensure_temp_dir
+  smoke_extension="$TEMP_DIR/extension-smoke.mjs"
+  cat > "$smoke_extension" <<'EOF'
+export default function ailiBootstrapPreflight(pi) {
+  if (!pi || typeof pi.registerCommand !== "function") throw new Error("extension-api-unavailable");
+  pi.registerCommand("aili-bootstrap-preflight", {
+    description: "AILI bootstrap compatibility probe",
+    handler: async () => undefined,
+  });
+}
+EOF
+  chmod 600 "$smoke_extension" || fail 'pi-headless-load-probe'
+  PI_OFFLINE=1 pi --offline --no-session --no-extensions --no-skills --no-prompt-templates \
+    --extension "$smoke_extension" --list-models '__aili_preflight_no_match__' >/dev/null 2>&1 \
+    || fail 'pi-headless-load-probe'
+  OBSERVED_PI_VERSION=$version
+}
+
+say "AILI bootstrap: platform=$PLATFORM architecture=$ARCHITECTURE"
+if ! has_pi; then
+  install_official_pi
+elif [ "$UPDATE_PI" -eq 1 ]; then
+  PI_STATE='update-attempted-possibly-changed'
+  pi update --self >/dev/null 2>&1 || fail 'official-pi-update'
+  PI_STATE='updated'
+fi
+
+preflight
+say "AILI bootstrap: preflight=pass pi_version=$OBSERVED_PI_VERSION"
+
+if ! pi install "$PACKAGE_SOURCE" >/dev/null 2>&1; then
+  say 'AILI bootstrap: ERROR stage=aili-package-install'
+  say "pi_state=$PI_STATE"
+  if [ "$AILI_PREEXISTING" = 'present-before-run' ]; then
+    say 'aili_state=previous-installation-may-remain'
+  else
+    say 'aili_state=possibly-partial'
+  fi
+  say "repair=pi install $PACKAGE_SOURCE"
+  say "optional_destructive_remove=pi remove $PACKAGE_ID"
+  exit 1
+fi
+
+say "AILI bootstrap: success pi_state=$PI_STATE aili_state=installed"
+say 'start=pi'
+say "update=pi update $PACKAGE_ID"
+say "list=pi list"
+say "remove=pi remove $PACKAGE_ID"

package/scripts/generate-provenance.ts

@@ -0,0 +1,143 @@
+import { createHash } from "node:crypto";
+import { access, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+const ROOT = resolve(import.meta.dirname, "..");
+const readJson = async <T>(path: string): Promise<T> => JSON.parse(await readFile(resolve(ROOT, path), "utf8")) as T;
+const hash = (value: string): string => createHash("sha256").update(value).digest("hex");
+const spdxId = (value: string): string => `SPDXRef-${value.replace(/[^A-Za-z0-9.-]+/g, "-")}-${hash(value).slice(0, 10)}`;
+
+interface ProvenanceSource {
+  name: string;
+  repository: string;
+  revision: string;
+  version: string;
+  license: string;
+  status: "adapted" | "reference-only" | "dependency";
+  sourceFiles: string[];
+  symbols: string[];
+  localChanges: string[];
+  verification: string[];
+}
+
+interface LockedPackage {
+  version?: string;
+  resolved?: string;
+  integrity?: string;
+  license?: string;
+  dev?: boolean;
+  optional?: boolean;
+}
+
+function packageName(path: string): string {
+  const marker = "node_modules/";
+  const tail = path.slice(path.lastIndexOf(marker) + marker.length);
+  const parts = tail.split("/");
+  return parts[0]!.startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0]!;
+}
+
+async function generate(): Promise<{ notices: string; sbom: object }> {
+  const provenance = await readJson<{ schemaVersion: number; sources: ProvenanceSource[] }>("manifests/provenance.json");
+  const lockText = await readFile(resolve(ROOT, "package-lock.json"), "utf8");
+  const lock = JSON.parse(lockText) as { lockfileVersion: number; packages: Record<string, LockedPackage> };
+  if (provenance.schemaVersion !== 1) throw new Error("provenance schemaVersion must be 1");
+  if (lock.lockfileVersion !== 3) throw new Error("package-lock must use lockfileVersion 3");
+  const seenSources = new Set<string>();
+  for (const source of provenance.sources) {
+    if (!source.name || seenSources.has(source.name)) throw new Error(`duplicate or missing provenance source: ${source.name}`);
+    seenSources.add(source.name);
+    if (!/^[0-9a-f]{40}$/.test(source.revision) && !/^npm:[0-9]+\.[0-9]+\.[0-9]+$/.test(source.revision)) throw new Error(`${source.name}: exact commit or npm version required`);
+    if (!source.repository.startsWith("https://") || !source.license || source.verification.length === 0) throw new Error(`${source.name}: incomplete source identity`);
+    if (source.status === "adapted" && (source.sourceFiles.length === 0 || source.symbols.length === 0 || source.localChanges.length === 0)) throw new Error(`${source.name}: adapted source detail is incomplete`);
+    if (source.status === "reference-only" && (source.sourceFiles.length > 0 || source.symbols.length > 0 || source.localChanges.length > 0)) throw new Error(`${source.name}: reference-only source must not claim reused code`);
+    if (source.status === "dependency" && (source.sourceFiles.length === 0 || source.symbols.length === 0 || source.localChanges.length === 0)) throw new Error(`${source.name}: dependency source detail is incomplete`);
+  }
+
+  const packages = Object.entries(lock.packages)
+    .filter(([path, value]) => path !== "" && path.includes("node_modules/") && value.version)
+    .map(([path, value]) => ({
+      SPDXID: spdxId(path),
+      name: packageName(path),
+      versionInfo: value.version!,
+      downloadLocation: value.resolved ?? "NOASSERTION",
+      filesAnalyzed: false,
+      licenseConcluded: value.license ?? "NOASSERTION",
+      licenseDeclared: value.license ?? "NOASSERTION",
+      checksums: value.integrity ? [{ algorithm: "SHA512", checksumValue: value.integrity.replace(/^sha512-/, "") }] : [],
+      primaryPackagePurpose: "LIBRARY",
+      comment: `npm lock path=${path}; development=${Boolean(value.dev)}; optional=${Boolean(value.optional)}`,
+    }))
+    .sort((a, b) => a.SPDXID.localeCompare(b.SPDXID));
+
+  const sourcePackages = provenance.sources.filter((source) => source.status !== "reference-only").map((source) => ({
+    SPDXID: spdxId(`source:${source.name}`),
+    name: source.name,
+    versionInfo: source.version,
+    downloadLocation: /^[0-9a-f]{40}$/.test(source.revision) ? `${source.repository.replace(/\.git$/, "")}/commit/${source.revision}` : source.repository,
+    filesAnalyzed: false,
+    licenseConcluded: source.license,
+    licenseDeclared: source.license,
+    checksums: [],
+    primaryPackagePurpose: "SOURCE",
+    comment: `revision=${source.revision}; files=${source.sourceFiles.join(", ")}; symbols=${source.symbols.join(", ")}; local changes=${source.localChanges.join(" | ")}`,
+  }));
+  const rootId = "SPDXRef-Package-aili-pi";
+  const sbom = {
+    spdxVersion: "SPDX-2.3",
+    dataLicense: "CC0-1.0",
+    SPDXID: "SPDXRef-DOCUMENT",
+    name: "@rosetears/aili-pi-0.0.0-development",
+    documentNamespace: `https://github.com/Rosetears520/aili-pi/sbom/${hash(lockText).slice(0, 32)}`,
+    creationInfo: { creators: ["Tool: @rosetears/aili-pi scripts/generate-provenance.ts"] },
+    packages: [{ SPDXID: rootId, name: "@rosetears/aili-pi", versionInfo: "0.0.0-development", downloadLocation: "NOASSERTION", filesAnalyzed: false, licenseConcluded: "MIT", licenseDeclared: "MIT", checksums: [], primaryPackagePurpose: "APPLICATION" }, ...sourcePackages, ...packages],
+    relationships: [...sourcePackages, ...packages].map((item) => ({ spdxElementId: rootId, relationshipType: "DEPENDS_ON", relatedSpdxElement: item.SPDXID })),
+  };
+
+  const notices = [
+    "# Third-Party Notices",
+    "",
+    "This distribution is MIT-licensed. The following adapted sources and locked development/runtime dependencies retain their own license terms.",
+    "",
+    ...provenance.sources.map((source) => [
+      `## ${source.name}`,
+      "",
+      `- Status: ${source.status}`,
+      `- Source: ${source.repository}`,
+      `- Revision: ${source.revision}`,
+      `- Version: ${source.version}`,
+      `- License: ${source.license}`,
+      `- Source files: ${source.sourceFiles.length ? source.sourceFiles.join(", ") : "none copied"}`,
+      `- Reused symbols/patterns: ${source.symbols.length ? source.symbols.join(", ") : "none"}`,
+      `- Local changes: ${source.localChanges.length ? source.localChanges.join("; ") : "none"}`,
+      "",
+    ].join("\n")),
+    "## npm dependency inventory",
+    "",
+    `The exact ${packages.length}-entry package-lock inventory, versions, integrity values, dependency scope, and declared licenses is recorded in \`manifests/sbom.json\`.`,
+    "",
+    "Runtime dependencies are initialized through the single AILI Extension entry; no third-party source tree is copied into this package.",
+    "",
+  ].join("\n");
+  return { notices, sbom };
+}
+
+async function main(): Promise<void> {
+  const { notices, sbom } = await generate();
+  const expectedSbom = `${JSON.stringify(sbom, null, 2)}\n`;
+  if (process.argv.includes("--verify")) {
+    const [actualNotices, actualSbom] = await Promise.all([
+      readFile(resolve(ROOT, "THIRD_PARTY_NOTICES.md"), "utf8").catch(() => ""),
+      readFile(resolve(ROOT, "manifests/sbom.json"), "utf8").catch(() => ""),
+    ]);
+    if (actualNotices !== notices || actualSbom !== expectedSbom) throw new Error("provenance artifacts are missing or drifted; run npm run generate:provenance");
+  } else {
+    await Promise.all([
+      writeFile(resolve(ROOT, "THIRD_PARTY_NOTICES.md"), notices, "utf8"),
+      writeFile(resolve(ROOT, "manifests/sbom.json"), expectedSbom, "utf8"),
+    ]);
+  }
+  await Promise.all(["THIRD_PARTY_NOTICES.md", "manifests/sbom.json", "manifests/provenance.json"].map((path) => access(resolve(ROOT, path))));
+  console.log("Provenance verified: deterministic source records and SPDX SBOM");
+}
+
+await main();

package/scripts/local-package-e2e.ts

@@ -0,0 +1,51 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+
+const execFile = promisify(execFileCallback);
+const ROOT = resolve(import.meta.dirname, "..");
+const requested = process.argv[2];
+const expected = requested === "linux" ? "linux" : undefined;
+if (!expected) throw new Error("Usage: local-package-e2e.ts linux");
+if (process.platform !== expected) throw new Error(`native ${expected} evidence unavailable on ${process.platform}`);
+
+const scratchParent = join(ROOT, ".tmp", "p8-local-e2e");
+await mkdir(scratchParent, { recursive: true });
+const scratch = await mkdtemp(join(scratchParent, `run-${expected}-`));
+const home = join(scratch, "home");
+const pack = join(scratch, "pack");
+const extracted = join(scratch, "extracted");
+await Promise.all([mkdir(home), mkdir(pack), mkdir(extracted)]);
+const keep = join(home, "unrelated-state.txt");
+await writeFile(keep, "preserve-me\n", { mode: 0o600 });
+
+const run = async (command: string, args: string[], environment: NodeJS.ProcessEnv = process.env) => {
+  const result = await execFile(command, args, { cwd: ROOT, env: environment, encoding: "utf8", timeout: 60_000, maxBuffer: 1024 * 1024 });
+  return `${result.stdout}${result.stderr}`;
+};
+const packResult = JSON.parse(await run("npm", ["pack", "--pack-destination", pack, "--json"])) as Array<{ filename: string }>;
+const tarball = join(pack, packResult[0]!.filename);
+await run("tar", ["-xzf", tarball, "-C", extracted]);
+const packageRoot = join(extracted, "package");
+const nodeBin = dirname(process.execPath);
+const environment: NodeJS.ProcessEnv = {
+  HOME: home,
+  PATH: `${join(ROOT, "node_modules", ".bin")}:${nodeBin}:/usr/bin:/bin`,
+  npm_config_offline: "true",
+  npm_config_cache: join(scratch, "npm-cache"),
+};
+const pi = join(ROOT, "node_modules", ".bin", "pi");
+
+await run(pi, ["install", packageRoot], environment);
+const installed = await run(pi, ["list"], environment);
+if (!installed.includes(packageRoot)) throw new Error("Pi list did not report the installed local Package");
+const smoke = await run(pi, ["--list-models"], environment);
+if (smoke.includes("Failed to load extension")) throw new Error("installed Package failed Extension loading");
+const packageJson = JSON.parse(await readFile(join(packageRoot, "package.json"), "utf8")) as { pi?: { extensions?: string[]; prompts?: string[]; skills?: string[] } };
+if (packageJson.pi?.extensions?.length !== 1 || packageJson.pi?.prompts?.length !== 5 || packageJson.pi?.skills?.length !== 2 || !packageJson.pi.skills.includes("./node_modules/pi-web-access/skills")) throw new Error("packed resource declarations are incomplete");
+await run(pi, ["remove", packageRoot], environment);
+const removed = await run(pi, ["list"], environment);
+if (!removed.includes("No packages installed")) throw new Error("Pi Package removal did not reconcile settings");
+if (await readFile(keep, "utf8") !== "preserve-me\n") throw new Error("unrelated disposable-home state changed");
+console.log(`Native ${expected} local Package E2E passed; evidence retained at ${scratch}`);

package/scripts/sync-roles.ts

@@ -0,0 +1,213 @@
+import { createHash } from "node:crypto";
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { lstat, readdir, readFile, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+
+const ROOT = resolve(import.meta.dirname, "..");
+const ROLES_DIR = join(ROOT, "roles");
+const MANIFEST_PATH = join(ROOT, "manifests", "roles.json");
+const SOURCE_COMMIT = "7eb35f357ad489f5841ee10dac1e44549c1bdb76";
+const SOURCE_REPOSITORY = "https://github.com/Rosetears520/aili-workflows.git";
+const execFile = promisify(execFileCallback);
+
+const ROLE_NAMES = [
+  "agent-evaluator", "ai-regression-scout", "browser-qa-runner", "code-reviewer",
+  "code-scout", "convergence-reviewer", "doc-researcher", "e2e-artifact-runner",
+  "implementer", "opensource-sanitizer", "plan-auditor", "pr-test-analyzer",
+  "security-auditor", "silent-failure-reviewer", "spec-miner", "test-coverage-reviewer",
+  "test-engineer", "web-performance-auditor", "web-researcher",
+] as const;
+
+const OPTIONAL: Record<string, string[]> = {
+  "browser-qa-runner": ["browser.qa"],
+  "e2e-artifact-runner": ["browser.qa", "artifact.store"],
+  "web-performance-auditor": ["browser.qa"],
+  "web-researcher": ["web.fetch"],
+};
+const KNOWN_SOURCE_PERMISSION_KEYS = new Set([
+  "apply_patch", "bash", "codegraph_codegraph_callees", "codegraph_codegraph_callers", "codegraph_codegraph_explore",
+  "codegraph_codegraph_files", "codegraph_codegraph_impact", "codegraph_codegraph_node", "codegraph_codegraph_search",
+  "codegraph_codegraph_status", "context7_query-docs", "context7_resolve-library-id", "doom_loop", "edit",
+  "external_directory", "glob", "grep", "list", "lsp", "multi_tool_use.parallel", "playwright_browser_click",
+  "playwright_browser_close", "playwright_browser_console_messages", "playwright_browser_drag", "playwright_browser_evaluate",
+  "playwright_browser_file_upload", "playwright_browser_fill_form", "playwright_browser_handle_dialog", "playwright_browser_hover",
+  "playwright_browser_navigate", "playwright_browser_navigate_back", "playwright_browser_network_requests",
+  "playwright_browser_press_key", "playwright_browser_resize", "playwright_browser_run_code", "playwright_browser_select_option",
+  "playwright_browser_snapshot", "playwright_browser_tabs", "playwright_browser_take_screenshot", "playwright_browser_type",
+  "playwright_browser_wait_for", "read", "skill", "task", "webfetch", "websearch",
+]);
+
+interface RoleRecord {
+  name: string;
+  description: string;
+  profilePath: string;
+  profileHash: string;
+  sourcePath: string;
+  sourceHash: string;
+  tools: string[];
+  capabilities: string[];
+  status: "adapted" | "optional" | "blocked";
+  compatibilityReason: string;
+  sourceFrontmatterDisposition: Record<string, string>;
+}
+
+function hash(content: string): string {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+function splitMarkdown(content: string): { description: string; body: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) throw new Error("source role lacks YAML frontmatter");
+  const description = match[1].match(/^description:\s*(.+)$/m)?.[1]?.trim();
+  if (!description) throw new Error("source role lacks description");
+  return { description, body: match[2].trim() };
+}
+
+function permissionDefault(frontmatter: string, tool: string): "allow" | "ask" | "deny" | "missing" {
+  const direct = frontmatter.match(new RegExp(`^  ${tool}:\\s*(allow|ask|deny)\\s*$`, "m"));
+  if (direct) return direct[1] as "allow" | "ask" | "deny";
+  const block = frontmatter.match(new RegExp(`^  ${tool}:\\s*\\n([\\s\\S]*?)(?=^  [a-zA-Z0-9_*.-]+:|^---$)`, "m"));
+  const wildcard = block?.[1].match(/^    ["']?\*["']?:\s*(allow|ask|deny)\s*$/m);
+  return wildcard ? wildcard[1] as "allow" | "ask" | "deny" : "missing";
+}
+
+function translatedPolicy(source: string): { tools: string[]; blocked: boolean; reason: string } {
+  const frontmatter = source.match(/^---\n([\s\S]*?)\n---/)?.[1];
+  if (!frontmatter) throw new Error("source role lacks frontmatter");
+  const permissionKeys = [...frontmatter.matchAll(/^  ([A-Za-z0-9_*.-]+):/gm)].map((match) => match[1]);
+  const unknown = permissionKeys.filter((key) => !KNOWN_SOURCE_PERMISSION_KEYS.has(key));
+  if (unknown.length > 0) throw new Error(`unknown source permission semantics: ${[...new Set(unknown)].join(",")}`);
+  const mappings = [["read", "read"], ["grep", "grep"], ["glob", "find"], ["list", "ls"]] as const;
+  const tools: string[] = mappings.filter(([sourceTool]) => permissionDefault(frontmatter, sourceTool) === "allow").map(([, piTool]) => piTool);
+  const edit = permissionDefault(frontmatter, "edit");
+  const bash = permissionDefault(frontmatter, "bash");
+  const editBlock = frontmatter.match(/^  edit:\s*\n([\s\S]*?)(?=^  [a-zA-Z0-9_*.-]+:|$)/m)?.[1] ?? "";
+  const bashBlock = frontmatter.match(/^  bash:\s*\n([\s\S]*?)(?=^  [a-zA-Z0-9_*.-]+:|$)/m)?.[1] ?? "";
+  const hasEditSemantics = edit === "allow" || edit === "ask" || /^(?:    .+:\s*(?:allow|ask))$/m.test(editBlock);
+  const hasBashSemantics = bash === "allow" || bash === "ask" || /^(?:    .+:\s*(?:allow|ask))$/m.test(bashBlock);
+  if (hasEditSemantics) tools.push("write", "edit");
+  return {
+    tools: [...new Set(tools)],
+    blocked: false,
+    reason: hasEditSemantics
+      ? `Source edit semantics are mapped to Pi write/edit under parent, role, mode, canonical-root, explicit task-boundary, credential, and headless fail-closed guards; source bash semantics are ${hasBashSemantics ? "intentionally omitted" : "not granted"}.`
+      : "Source role is safely narrowed to Pi read-only tools with application-level credential/path guards.",
+  };
+}
+
+function profileContent(name: string, description: string, tools: string[], body: string): string {
+  const adaptedBody = body
+    .replaceAll("OpenCode subagent", "Pi child role")
+    .replaceAll("OpenCode", "Pi")
+    .replaceAll("Task tool", "AILI task capability")
+    .replace(/## Output\n[\s\S]*?(?=\n## Stop)/, "## Output\n\nReturn exactly one JSON object with keys `status`, `summary`, `evidence`, `changedFiles`, `verification`, `blockers`, `risks`, and `confidence`.");
+  return [
+    "---",
+    `name: ${name}`,
+    `description: ${description}`,
+    `tools: ${tools.join(",") || "[]"}`,
+    `aili-source-revision: ${SOURCE_COMMIT}`,
+    "---",
+    "",
+    adaptedBody,
+    "",
+    "## Pi adapter contract",
+    "",
+    "You run once in a fresh `pi --mode json --no-session` child. Recursive AILI task dispatch is unavailable.",
+    "Use only the tools exposed by the Pi process. The task packet and parent policy may narrow this profile and never broaden it.",
+    "Return exactly one JSON object with keys `status`, `summary`, `evidence`, `changedFiles`, `verification`, `blockers`, `risks`, and `confidence`.",
+    "Do not include credentials, raw environment variables, authentication-store content, or unbounded command output.",
+    "",
+  ].join("\n");
+}
+
+async function generate(sourceRoot: string): Promise<void> {
+  const git = async (...args: string[]) => (await execFile("git", args, { cwd: sourceRoot, encoding: "utf8" })).stdout.trim();
+  const [commit, origin, status] = await Promise.all([
+    git("rev-parse", "HEAD"),
+    git("remote", "get-url", "origin"),
+    git("status", "--porcelain"),
+  ]);
+  if (commit !== SOURCE_COMMIT) throw new Error(`source revision mismatch: ${commit}`);
+  if (origin !== SOURCE_REPOSITORY) throw new Error(`source origin mismatch: ${origin}`);
+  if (status !== "") throw new Error("source worktree must be clean");
+  const records: RoleRecord[] = [];
+  for (const name of ROLE_NAMES) {
+    const sourcePath = join(sourceRoot, "agents", `${name}.md`);
+    if ((await lstat(sourcePath)).isSymbolicLink()) throw new Error(`${name}: source role must not be a symlink`);
+    const source = await readFile(sourcePath, "utf8");
+    const { description, body } = splitMarkdown(source);
+    const policy = translatedPolicy(source);
+    const tools = [...policy.tools];
+    if (name === "web-researcher") tools.length = 0;
+    const capabilities = ["repo.read", ...(tools.some((tool) => tool === "write" || tool === "edit") ? ["repo.write"] : []), ...(OPTIONAL[name] ?? [])];
+    if (name === "web-researcher") capabilities.splice(0, 1);
+    const profile = profileContent(name, description, tools, body);
+    await writeFile(join(ROLES_DIR, `${name}.md`), profile, "utf8");
+    records.push({
+      name,
+      description,
+      profilePath: `roles/${name}.md`,
+      profileHash: hash(profile),
+      sourcePath: `agents/${name}.md`,
+      sourceHash: hash(source),
+      tools,
+      capabilities,
+      status: OPTIONAL[name] ? "optional" : policy.blocked ? "blocked" : "adapted",
+      compatibilityReason: OPTIONAL[name] ? `Optional capabilities are required: ${OPTIONAL[name].join(", ")}.` : policy.reason,
+      sourceFrontmatterDisposition: {
+        mode: "replaced by fresh Pi child-process execution",
+        hidden: "not interpreted by Pi",
+        permission: "translated into the explicit Pi tool/capability ceiling; source YAML is never executed",
+      },
+    });
+  }
+  await writeFile(MANIFEST_PATH, `${JSON.stringify({
+    schemaVersion: 1,
+    source: { repository: SOURCE_REPOSITORY, commit: SOURCE_COMMIT },
+    outputContract: ["status", "summary", "evidence", "changedFiles", "verification", "blockers", "risks", "confidence"],
+    records,
+  }, null, 2)}\n`, "utf8");
+}
+
+async function verify(): Promise<void> {
+  const manifest = JSON.parse(await readFile(MANIFEST_PATH, "utf8")) as { schemaVersion: number; records: RoleRecord[] };
+  const errors: string[] = [];
+  if (manifest.schemaVersion !== 1) errors.push("roles manifest schemaVersion must be 1");
+  const expected = new Set(ROLE_NAMES);
+  const seen = new Set<string>();
+  for (const role of manifest.records ?? []) {
+    if (!expected.has(role.name as typeof ROLE_NAMES[number])) errors.push(`${role.name}: unexpected role`);
+    if (seen.has(role.name)) errors.push(`${role.name}: duplicate role`);
+    seen.add(role.name);
+    const content = await readFile(join(ROOT, role.profilePath), "utf8").catch(() => "");
+    if (!content) errors.push(`${role.name}: missing profile`);
+    else {
+      if (hash(content) !== role.profileHash) errors.push(`${role.name}: profile hash drift`);
+      if (content.includes("OpenCode subagent") || content.includes(".agents/skills/") || /^\s*permission:/m.test(content)) errors.push(`${role.name}: unsupported OpenCode semantics remain active`);
+      if (!content.includes("Return exactly one JSON object")) errors.push(`${role.name}: output contract missing`);
+    }
+    if (!Array.isArray(role.tools) || !Array.isArray(role.capabilities)) errors.push(`${role.name}: invalid policy arrays`);
+    if (!role.compatibilityReason) errors.push(`${role.name}: compatibility reason missing`);
+    if (role.status !== "adapted" && role.status !== "optional" && role.status !== "blocked") errors.push(`${role.name}: invalid compatibility status`);
+  }
+  for (const name of expected) if (!seen.has(name)) errors.push(`${name}: missing role`);
+  const files = (await readdir(ROLES_DIR)).filter((name) => name.endsWith(".md")).sort();
+  const expectedFiles = ROLE_NAMES.map((name) => `${name}.md`).sort();
+  if (JSON.stringify(files) !== JSON.stringify(expectedFiles)) errors.push(`role file inventory mismatch: ${files.length}/19`);
+  if (errors.length > 0) throw new Error(errors.join("\n"));
+  console.log(`Role profiles verified: ${manifest.records.length}`);
+}
+
+const args = process.argv.slice(2);
+if (args.includes("--verify")) {
+  await verify();
+} else {
+  const sourceFlag = args.indexOf("--source");
+  if (sourceFlag < 0 || !args[sourceFlag + 1]) throw new Error("Usage: sync-roles.ts --source <aili-workflows-root>");
+  const sourceRoot = resolve(args[sourceFlag + 1]);
+  if (basename(sourceRoot) === "") throw new Error("invalid source root");
+  await generate(sourceRoot);
+  await verify();
+}