Add repo deployment request family

This commit is contained in:
Meta Vens 2026-06-20 21:01:26 +01:00
commit 7b4be62c8e
6 changed files with 718 additions and 7 deletions

View file

@ -0,0 +1,438 @@
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use chrono::Utc;
use serde_json::Value;
use serde_json::json;
use std::env;
use std::fs;
use std::path::Path;
use std::path::PathBuf;
use std::process::Command;
fn main() -> Result<()> {
let args = Args::parse()?;
let result = run_smoke(args)?;
println!("{}", serde_json::to_string_pretty(&result)?);
Ok(())
}
#[derive(Clone, Debug)]
struct Args {
root: PathBuf,
smoke_root: PathBuf,
}
impl Args {
fn parse() -> Result<Self> {
let mut root = env::current_dir().context("failed to resolve current directory")?;
let mut smoke_root = root.join(".epiphany-smoke");
let mut args = env::args().skip(1).peekable();
while let Some(arg) = args.next() {
match arg.as_str() {
"--root" => root = take_path(&mut args, "--root")?,
"--smoke-root" => smoke_root = take_path(&mut args, "--smoke-root")?,
other => return Err(anyhow!("unexpected argument {other:?}")),
}
}
Ok(Self { root, smoke_root })
}
}
fn run_smoke(args: Args) -> Result<Value> {
let root = args
.root
.canonicalize()
.with_context(|| format!("failed to resolve {}", args.root.display()))?;
let manifest = root.join("epiphany-core").join("Cargo.toml");
if !manifest.exists() {
return Err(anyhow!(
"could not find epiphany-core manifest at {}",
manifest.display()
));
}
fs::create_dir_all(&args.smoke_root)
.with_context(|| format!("failed to create {}", args.smoke_root.display()))?;
let stamp = Utc::now().format("%Y%m%d-%H%M%S").to_string();
let smoke_dir = args
.smoke_root
.join(format!("repo-deployment-request-family-{stamp}"));
if smoke_dir.exists() {
fs::remove_dir_all(&smoke_dir)
.with_context(|| format!("failed to clear {}", smoke_dir.display()))?;
}
fs::create_dir_all(&smoke_dir)
.with_context(|| format!("failed to create {}", smoke_dir.display()))?;
let repo = smoke_dir.join("repo-body");
fs::create_dir_all(&repo).with_context(|| format!("failed to create {}", repo.display()))?;
git(["init"], &repo)?;
git(
["config", "user.email", "epiphany-smoke@example.invalid"],
&repo,
)?;
git(["config", "user.name", "Epiphany Smoke"], &repo)?;
fs::write(
repo.join("README.md"),
"# Repo Deployment Request Family Smoke\n\nThis repository proves branch-local deployment request cargo without deploy authority.\n",
)
.with_context(|| format!("failed to seed {}", repo.join("README.md").display()))?;
fs::create_dir_all(repo.join("deploy"))
.with_context(|| format!("failed to create {}", repo.join("deploy").display()))?;
fs::write(
repo.join("deploy").join("idunn-deploy.ps1"),
"# reviewed by Idunn before use\nWrite-Output 'deployment script placeholder'\n",
)
.with_context(|| {
format!(
"failed to seed {}",
repo.join("deploy").join("idunn-deploy.ps1").display()
)
})?;
git(["add", "README.md", "deploy/idunn-deploy.ps1"], &repo)?;
git(
["commit", "-m", "Seed repo deployment request smoke body"],
&repo,
)?;
git(
["switch", "-c", "epiphany/repo-deployment-request-family"],
&repo,
)?;
let item = "repo-deployment-request-family";
let target_path = ".epiphany/deployment-requests/repo-deployment-request-family.toml";
let local_verse = repo.join(".epiphany").join("local-verse.ccmp");
cargo_json(
&manifest,
"epiphany-repo",
&[
"init",
"--workspace",
path_str(&repo)?,
"--epiphany-root",
path_str(&root)?,
"--swarm-id",
"repo-deployment-request-family-smoke",
"--topic",
"repo-deployment-request-family",
],
&root,
)?;
cargo_json(
&manifest,
"epiphany-swarm",
&[
"online",
"--workspace",
path_str(&repo)?,
"--epiphany-root",
path_str(&root)?,
"--runtime-id",
"repo-deployment-request-family-smoke",
"--local-verse-store",
path_str(&local_verse)?,
],
&root,
)?;
cargo_json(
&manifest,
"epiphany-work",
&[
"accept",
"--workspace",
path_str(&repo)?,
"--from",
"persona",
"--item",
item,
"--summary",
"Ask for a reviewed Idunn-owned git-push deployment request without granting deployment authority.",
"--candidate-action-ref",
"candidate-action://repo-deployment-request-family/idunn-review",
"--public-discussion-ref",
"epiphany-global/persona-collaboration/repo-deployment-request-family",
],
&root,
)?;
let plan = cargo_json(
&manifest,
"epiphany-work",
&[
"derive-plan",
"--workspace",
path_str(&repo)?,
"--item",
item,
"--action-family",
"repo-deployment-request",
"--model-ref",
"repo-deployment-request-family-smoke-imagination-v1",
"--model-authored",
],
&root,
)?;
for _ in 0..4 {
cargo_json(
&manifest,
"epiphany-work",
&[
"tick",
"--workspace",
path_str(&repo)?,
"--epiphany-root",
path_str(&root)?,
"--item",
item,
"--cooldown-seconds",
"0",
],
&root,
)?;
}
let close = read_json(
&repo
.join(".epiphany")
.join("work")
.join(format!("work-close-{item}.json")),
)?;
let request_text = fs::read_to_string(repo.join(target_path))
.with_context(|| format!("failed to read {}", repo.join(target_path).display()))?;
let deploy_script_text = fs::read_to_string(repo.join("deploy").join("idunn-deploy.ps1"))
.with_context(|| {
format!(
"failed to read {}",
repo.join("deploy").join("idunn-deploy.ps1").display()
)
})?;
require_eq(
&plan,
&["derivation", "safeActionFamily"],
"repo.deployment_request",
)?;
require_eq(&close, &["status"], "closed")?;
require_eq(&close, &["soul", "verdict"], "passed")?;
require_eq(
&close,
&["closureReview", "familyAssertions", "status"],
"passed",
)?;
require_bool(
&close,
&["closureReview", "sourceGrounding", "pathScopeMatched"],
true,
)?;
require_bool(&close, &["privateStateExposed"], false)?;
require_text(
&request_text,
"schema_version = \"epiphany.repo_deployment_request.v0\"",
)?;
require_text(
&request_text,
"safe_action_family = \"repo.deployment_request\"",
)?;
require_text(&request_text, "status = \"awaiting-idunn-review\"")?;
require_text(&request_text, "requested_owner = \"Idunn/Maintainer\"")?;
require_text(
&request_text,
"deployment_trigger = \"git-push-observed-by-idunn\"",
)?;
require_text(&request_text, "deployment_owner = \"Idunn\"")?;
require_text(&request_text, "requires_idunn_receipt = true")?;
require_text(&request_text, "requires_aftercare_audit = true")?;
require_text(&request_text, "secret_policy_review_required = true")?;
require_text(
&request_text,
"idunn_deployment = \"gamecult.idunn.deployment_receipt.v0\"",
)?;
require_text(
&request_text,
"aftercare_audit = \"gamecult.idunn.deployment_aftercare_audit.v0\"",
)?;
require_text(&request_text, "requires_deployment_script_ref = true")?;
require_text(&request_text, "requires_script_hash_or_review_ref = true")?;
require_text(&request_text, "requires_host_access_policy_ref = true")?;
require_text(&request_text, "requires_secret_policy_ref = true")?;
require_text(&request_text, "requires_rollback_plan = true")?;
require_text(&request_text, "requires_aftercare_checks = true")?;
require_text(&request_text, "direct_deployment_authority = false")?;
require_text(&request_text, "direct_ssh_authority = false")?;
require_text(&request_text, "direct_git_push_authority = false")?;
require_text(&request_text, "direct_service_lifecycle_authority = false")?;
require_text(&request_text, "direct_hands_authority = false")?;
require_text(&request_text, "publication_authorized = false")?;
require_text(&request_text, "cross_body_mutation_authorized = false")?;
require_text(&request_text, "private_verse_rummaging = false")?;
require_text(&request_text, "private_state_exposed = false")?;
require_text(&deploy_script_text, "deployment script placeholder")?;
let summary = json!({
"schemaVersion": "epiphany.repo_deployment_request_family_smoke.v0",
"status": "ok",
"smokeDir": smoke_dir,
"repo": repo,
"branch": git_output(["branch", "--show-current"], &repo)?,
"item": item,
"safeActionFamily": plan["derivation"]["safeActionFamily"],
"targetPath": target_path,
"closeStatus": close["status"],
"soulVerdict": close["soul"]["verdict"],
"familyAssertionsStatus": close["closureReview"]["familyAssertions"]["status"],
"pathScopeMatched": close["closureReview"]["sourceGrounding"]["pathScopeMatched"],
"awaitingIdunnReview": true,
"deploymentTrigger": "git-push-observed-by-idunn",
"deploymentAuthority": false,
"sshAuthority": false,
"gitPushAuthority": false,
"serviceLifecycleAuthority": false,
"privateStateExposed": false,
});
write_json(&smoke_dir.join("summary.json"), &summary)?;
Ok(summary)
}
fn cargo_json(manifest: &Path, bin: &str, args: &[&str], cwd: &Path) -> Result<Value> {
let output = Command::new("cargo")
.arg("run")
.arg("--quiet")
.arg("--manifest-path")
.arg(manifest)
.arg("--bin")
.arg(bin)
.arg("--")
.args(args)
.current_dir(cwd)
.output()
.with_context(|| format!("failed to run cargo bin {bin}"))?;
if !output.status.success() {
return Err(anyhow!(
"{bin} failed with status {:?}\nstdout:\n{}\nstderr:\n{}",
output.status.code(),
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
));
}
serde_json::from_slice(&output.stdout).with_context(|| {
format!(
"{bin} did not emit JSON on stdout:\n{}",
String::from_utf8_lossy(&output.stdout)
)
})
}
fn git<const N: usize>(args: [&str; N], cwd: &Path) -> Result<()> {
let output = Command::new("git")
.args(args)
.current_dir(cwd)
.output()
.with_context(|| format!("failed to run git in {}", cwd.display()))?;
if output.status.success() {
Ok(())
} else {
Err(anyhow!(
"git failed in {} with status {:?}\nstdout:\n{}\nstderr:\n{}",
cwd.display(),
output.status.code(),
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
))
}
}
fn git_output<const N: usize>(args: [&str; N], cwd: &Path) -> Result<String> {
let output = Command::new("git")
.args(args)
.current_dir(cwd)
.output()
.with_context(|| format!("failed to run git in {}", cwd.display()))?;
if output.status.success() {
Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
} else {
Err(anyhow!(
"git failed in {} with status {:?}\nstdout:\n{}\nstderr:\n{}",
cwd.display(),
output.status.code(),
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
))
}
}
fn read_json(path: &Path) -> Result<Value> {
let bytes = fs::read(path).with_context(|| format!("failed to read {}", path.display()))?;
serde_json::from_slice(&bytes).with_context(|| format!("failed to parse {}", path.display()))
}
fn write_json(path: &Path, value: &Value) -> Result<()> {
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)
.with_context(|| format!("failed to create {}", parent.display()))?;
}
fs::write(path, serde_json::to_vec_pretty(value)?)
.with_context(|| format!("failed to write {}", path.display()))
}
fn require_eq(value: &Value, path: &[&str], expected: &str) -> Result<()> {
let actual = value_at_path(value, path)
.and_then(Value::as_str)
.ok_or_else(|| anyhow!("missing string at {}", path.join(".")))?;
if actual == expected {
Ok(())
} else {
Err(anyhow!(
"expected {} to be {:?}, got {:?}",
path.join("."),
expected,
actual
))
}
}
fn require_bool(value: &Value, path: &[&str], expected: bool) -> Result<()> {
let actual = value_at_path(value, path)
.and_then(Value::as_bool)
.ok_or_else(|| anyhow!("missing bool at {}", path.join(".")))?;
if actual == expected {
Ok(())
} else {
Err(anyhow!(
"expected {} to be {}, got {}",
path.join("."),
expected,
actual
))
}
}
fn require_text(haystack: &str, needle: &str) -> Result<()> {
if haystack.contains(needle) {
Ok(())
} else {
Err(anyhow!("expected text to contain {needle:?}"))
}
}
fn value_at_path<'a>(value: &'a Value, path: &[&str]) -> Option<&'a Value> {
let mut cursor = value;
for segment in path {
if let Ok(index) = segment.parse::<usize>() {
cursor = cursor.as_array()?.get(index)?;
} else {
cursor = cursor.get(*segment)?;
}
}
Some(cursor)
}
fn path_str(path: &Path) -> Result<&str> {
path.to_str()
.ok_or_else(|| anyhow!("path is not valid UTF-8: {}", path.display()))
}
fn take_path(args: &mut impl Iterator<Item = String>, name: &str) -> Result<PathBuf> {
Ok(PathBuf::from(
args.next()
.ok_or_else(|| anyhow!("missing value for {name}"))?,
))
}

View file

@ -1995,8 +1995,12 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result<DerivedSafe
| "secret-policy-request"
| "security-policy-request"
| "repo-security-request" => derive_repo_secret_policy_request_plan(input, &action_family),
"repo-deployment-request"
| "deployment-request"
| "idunn-deployment-request"
| "repo-deploy-request" => derive_repo_deployment_request_plan(input, &action_family),
other => Err(anyhow!(
"unsupported derive-plan action family {other:?}; supported families are append-worklog, planning-note, checklist-note, section-note, repo-status-section, task-card, repo-manifest, repo-tool-capabilities, repo-tool-request, repo-eve-surface, repo-collaboration-policy, repo-collaboration-topic, repo-consensus-brief, repo-objective-draft, repo-adoption-request, repo-scheduling-request, repo-work-order, repo-verification-request, repo-publication-request, repo-sync-request, repo-maintainer-review-request, repo-pr-request, repo-credit-request, repo-artifact-acceptance-request, repo-metrics-request, repo-doctrine-update-request, and repo-secret-policy-request"
"unsupported derive-plan action family {other:?}; supported families are append-worklog, planning-note, checklist-note, section-note, repo-status-section, task-card, repo-manifest, repo-tool-capabilities, repo-tool-request, repo-eve-surface, repo-collaboration-policy, repo-collaboration-topic, repo-consensus-brief, repo-objective-draft, repo-adoption-request, repo-scheduling-request, repo-work-order, repo-verification-request, repo-publication-request, repo-sync-request, repo-maintainer-review-request, repo-pr-request, repo-credit-request, repo-artifact-acceptance-request, repo-metrics-request, repo-doctrine-update-request, repo-secret-policy-request, and repo-deployment-request"
)),
}
}
@ -5065,6 +5069,141 @@ fn derive_repo_secret_policy_request_plan(
})
}
fn derive_repo_deployment_request_plan(
input: DeriveSafePlanInput<'_>,
action_family: &str,
) -> Result<DerivedSafePlan> {
let item_slug = sanitize(input.item);
let default_target = format!(".epiphany/deployment-requests/{item_slug}.toml");
let target_path = validate_toml_target_path(input.target_path.unwrap_or(&default_target))?;
let candidate_refs =
string_array_from_json(input.accept_receipt, &["feedback", "candidateActionRefs"]);
let public_refs =
string_array_from_json(input.accept_receipt, &["feedback", "publicDiscussionRefs"]);
let now = Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
let request_id = format!("repo-deployment-request:{item_slug}");
let lines = vec![
"# Epiphany repo deployment request.".to_string(),
"# Branch-local deployment request cargo; Idunn owns deployment execution.".to_string(),
format!(
"schema_version = {}",
toml_basic_string("epiphany.repo_deployment_request.v0")
),
format!("item = {}", toml_basic_string(input.item)),
format!("created_at = {}", toml_basic_string(&now)),
format!("source = {}", toml_basic_string(input.source)),
format!("summary = {}", toml_basic_string(&compact_line(input.summary))),
format!(
"safe_action_family = {}",
toml_basic_string("repo.deployment_request")
),
format!("model_authored = {}", input.model_authored),
format!(
"model_ref = {}",
toml_basic_string(input.model_ref.unwrap_or("deterministic-fallback"))
),
"operator_authored_shell_details = false".to_string(),
"hands_authority_granted = false".to_string(),
"deployment_authority = false".to_string(),
"ssh_authority = false".to_string(),
"git_push_authority = false".to_string(),
"service_lifecycle_authority = false".to_string(),
"durable_state_admitted = false".to_string(),
"publication_authorized = false".to_string(),
"merge_authorized = false".to_string(),
"cross_repo_mutation = false".to_string(),
"private_state_exposed = false".to_string(),
format!("candidate_action_refs = {}", toml_array(&candidate_refs)),
format!("public_discussion_refs = {}", toml_array(&public_refs)),
String::new(),
"[request]".to_string(),
format!("id = {}", toml_basic_string(&request_id)),
"status = \"awaiting-idunn-review\"".to_string(),
"requested_owner = \"Idunn/Maintainer\"".to_string(),
"requested_effect = \"review-repo-deployment-trigger-and-script\"".to_string(),
"deployment_trigger = \"git-push-observed-by-idunn\"".to_string(),
"deployment_owner = \"Idunn\"".to_string(),
"deployment_surface = \"reviewed repo deployment script or runbook\"".to_string(),
"requires_explicit_deployment_policy = true".to_string(),
"requires_idunn_receipt = true".to_string(),
"requires_aftercare_audit = true".to_string(),
String::new(),
"[antecedents]".to_string(),
"source_grounding_required = true".to_string(),
"mind_adoption_required = true".to_string(),
"soul_review_required = true".to_string(),
"maintainer_review_required = true".to_string(),
"secret_policy_review_required = true".to_string(),
"bifrost_publication_review_required = true".to_string(),
String::new(),
"[required_receipts]".to_string(),
"source_grounding = \"epiphany.eyes.evidence_packet\"".to_string(),
"mind_adoption = \"epiphany.repo_work_mind_adoption_decision.v0\"".to_string(),
"soul_review = \"epiphany.repo_work_closure_review.v0\"".to_string(),
"maintainer_review = \"gamecult.maintainer.review_receipt.v0\"".to_string(),
"secret_policy = \"epiphany.repo_secret_policy_request.v0\"".to_string(),
"bifrost_publication_review = \"gamecult.bifrost.publication_review_receipt.v0\""
.to_string(),
"idunn_deployment = \"gamecult.idunn.deployment_receipt.v0\"".to_string(),
"aftercare_audit = \"gamecult.idunn.deployment_aftercare_audit.v0\"".to_string(),
String::new(),
"[deployment_packet]".to_string(),
"requires_target_environment = true".to_string(),
"requires_git_ref_or_branch = true".to_string(),
"requires_deployment_script_ref = true".to_string(),
"requires_script_hash_or_review_ref = true".to_string(),
"requires_host_access_policy_ref = true".to_string(),
"requires_secret_policy_ref = true".to_string(),
"requires_rollback_plan = true".to_string(),
"requires_aftercare_checks = true".to_string(),
String::new(),
"[authority]".to_string(),
"branch_local_only = true".to_string(),
"direct_deployment_authority = false".to_string(),
"direct_ssh_authority = false".to_string(),
"direct_git_push_authority = false".to_string(),
"direct_service_lifecycle_authority = false".to_string(),
"direct_hands_authority = false".to_string(),
"publication_authorized = false".to_string(),
"merge_authorized = false".to_string(),
"cross_body_mutation_authorized = false".to_string(),
"private_verse_rummaging = false".to_string(),
"idunn_deployment_authority_required = true".to_string(),
String::new(),
"[verification]".to_string(),
"asks = [".to_string(),
" \"Soul verifies the deployment request path changed and contains the accepted pressure summary.\",".to_string(),
" \"Soul verifies the request names git-push-triggered Idunn ownership, deployment script review, host access policy, secret policy, rollback, aftercare audit, and Idunn deployment receipts.\",".to_string(),
" \"Soul verifies no direct SSH, deployment, git push, service lifecycle, publication, merge, Hands, cross-body, or private Verse authority is granted.\"".to_string(),
"]".to_string(),
String::new(),
"[rollback]".to_string(),
"hints = [\"Remove the deployment request if the deployment path is not ready for Idunn review.\"]"
.to_string(),
String::new(),
];
let command = powershell_set_lines_command(&target_path, &lines);
Ok(DerivedSafePlan {
safe_action_family: "repo.deployment_request".to_string(),
target_path,
plan_summary: format!(
"Imagination derived a repo deployment request from accepted {} pressure.",
input.source
),
command,
commit_message: format!("Add deployment request for repo work item {}", input.item),
verification_asks: vec![
"Soul verifies the repo deployment request path changed and contains the accepted pressure summary.".to_string(),
"Soul verifies the request names Idunn-owned git-push-triggered deployment, script review, host access policy, secret policy, rollback, aftercare, and no direct deployment/SSH/push authority.".to_string(),
"Soul verifies no paths outside the declared deployment request changed.".to_string(),
],
rollback_hints: vec![
"Remove the generated deployment request if the deployment review is not ready.".to_string(),
],
derivation: plan_derivation_receipt(input, action_family, "repo.deployment_request"),
})
}
fn closure_family_assertions(
workspace: &Path,
commit_sha: &str,
@ -7094,6 +7233,120 @@ fn closure_family_assertions(
"Committed secret policy request preserves the private-state seal.".to_string(),
);
}
"repo.deployment_request" => {
push_assertion(
&mut assertions,
"deployment-request-schema-present",
content.contains("schema_version = \"epiphany.repo_deployment_request.v0\""),
"Committed deployment request carries the schema version.".to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-family-present",
content.contains("safe_action_family = \"repo.deployment_request\""),
"Committed deployment request carries the safe action family.".to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-summary-present",
content.contains(&compact_summary),
"Committed deployment request contains the accepted pressure summary.".to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-awaits-idunn-review",
content.contains("[request]")
&& content.contains("status = \"awaiting-idunn-review\"")
&& content.contains("requested_owner = \"Idunn/Maintainer\"")
&& content.contains(
"requested_effect = \"review-repo-deployment-trigger-and-script\"",
)
&& content.contains("deployment_trigger = \"git-push-observed-by-idunn\"")
&& content.contains("deployment_owner = \"Idunn\"")
&& content.contains("requires_explicit_deployment_policy = true")
&& content.contains("requires_idunn_receipt = true")
&& content.contains("requires_aftercare_audit = true"),
"Committed deployment request waits for Idunn/maintainer review before deployment consequence."
.to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-antecedents-present",
content.contains("[antecedents]")
&& content.contains("source_grounding_required = true")
&& content.contains("mind_adoption_required = true")
&& content.contains("soul_review_required = true")
&& content.contains("maintainer_review_required = true")
&& content.contains("secret_policy_review_required = true")
&& content.contains("bifrost_publication_review_required = true"),
"Committed deployment request requires Eyes, Mind, Soul, maintainer, secret-policy, and Bifrost antecedents."
.to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-receipt-contract",
content.contains("[required_receipts]")
&& content.contains("source_grounding = \"epiphany.eyes.evidence_packet\"")
&& content.contains(
"mind_adoption = \"epiphany.repo_work_mind_adoption_decision.v0\"",
)
&& content.contains(
"soul_review = \"epiphany.repo_work_closure_review.v0\"",
)
&& content.contains(
"maintainer_review = \"gamecult.maintainer.review_receipt.v0\"",
)
&& content.contains(
"secret_policy = \"epiphany.repo_secret_policy_request.v0\"",
)
&& content.contains(
"idunn_deployment = \"gamecult.idunn.deployment_receipt.v0\"",
)
&& content.contains(
"aftercare_audit = \"gamecult.idunn.deployment_aftercare_audit.v0\"",
),
"Committed deployment request names Eyes, Mind, Soul, maintainer, secret-policy, Idunn deployment, and aftercare receipts."
.to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-packet-contract",
content.contains("[deployment_packet]")
&& content.contains("requires_target_environment = true")
&& content.contains("requires_git_ref_or_branch = true")
&& content.contains("requires_deployment_script_ref = true")
&& content.contains("requires_script_hash_or_review_ref = true")
&& content.contains("requires_host_access_policy_ref = true")
&& content.contains("requires_secret_policy_ref = true")
&& content.contains("requires_rollback_plan = true")
&& content.contains("requires_aftercare_checks = true"),
"Committed deployment request names environment, git ref, script review, host policy, secret policy, rollback, and aftercare requirements."
.to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-authority-seals",
content.contains("[authority]")
&& content.contains("direct_deployment_authority = false")
&& content.contains("direct_ssh_authority = false")
&& content.contains("direct_git_push_authority = false")
&& content.contains("direct_service_lifecycle_authority = false")
&& content.contains("direct_hands_authority = false")
&& content.contains("publication_authorized = false")
&& content.contains("merge_authorized = false")
&& content.contains("cross_body_mutation_authorized = false")
&& content.contains("private_verse_rummaging = false")
&& content.contains("idunn_deployment_authority_required = true"),
"Committed deployment request denies deployment/SSH/push/service/action/publication/cross-body authority."
.to_string(),
);
push_assertion(
&mut assertions,
"deployment-request-private-seal",
content.contains("private_state_exposed = false"),
"Committed deployment request preserves the private-state seal.".to_string(),
);
}
_ => {
return Ok((
json!({
@ -11257,6 +11510,7 @@ fn repo_work_safe_family_is_recognized(safe_family: &str) -> bool {
| "repo.metrics_request"
| "repo.doctrine_update_request"
| "repo.secret_policy_request"
| "repo.deployment_request"
)
}
@ -11376,7 +11630,7 @@ fn print_usage() {
"usage: epiphany-work <persona-intake|accept|derive-plan|plan|run|adopt|execute|close|publish|sync|overview|export-proof|tick|queue-run|serve> ...\n\
persona-intake --workspace <repo> --item <id> --message <text> [--topic <topic>] [--store <local-verse.ccmp>] [--runtime-id <id>]\n\
accept --workspace <repo> --from <persona|bifrost|persona-or-bifrost> --item <id> [--summary <text>] [--topic <topic>] [--store <local-verse.ccmp>] [--runtime-id <id>] [--online-receipt <path>] [--public-discussion-ref <ref>] [--candidate-action-ref <ref>]\n\
derive-plan --workspace <repo> [--item <id>] [--accept-receipt <path>] [--action-family append-worklog|planning-note|checklist-note|section-note|repo-status-section|task-card|repo-manifest|repo-tool-capabilities|repo-tool-request|repo-eve-surface|repo-collaboration-policy|repo-collaboration-topic|repo-consensus-brief|repo-objective-draft|repo-adoption-request|repo-scheduling-request|repo-work-order|repo-verification-request|repo-publication-request|repo-sync-request|repo-maintainer-review-request|repo-pr-request|repo-credit-request|repo-artifact-acceptance-request|repo-metrics-request|repo-doctrine-update-request|repo-secret-policy-request] [--target-path <path>] [--model-ref <ref>] [--model-authored] [--action-summary <text>] [--verification-ask <text>] [--stop-condition <text>] [--escalation-reason <text>] [--assumption <text>] [--constraint <text>] [--non-goal <text>] [--open-question <text>] [--decision-point <text>] [--evidence-need <text>]\n\
derive-plan --workspace <repo> [--item <id>] [--accept-receipt <path>] [--action-family append-worklog|planning-note|checklist-note|section-note|repo-status-section|task-card|repo-manifest|repo-tool-capabilities|repo-tool-request|repo-eve-surface|repo-collaboration-policy|repo-collaboration-topic|repo-consensus-brief|repo-objective-draft|repo-adoption-request|repo-scheduling-request|repo-work-order|repo-verification-request|repo-publication-request|repo-sync-request|repo-maintainer-review-request|repo-pr-request|repo-credit-request|repo-artifact-acceptance-request|repo-metrics-request|repo-doctrine-update-request|repo-secret-policy-request|repo-deployment-request] [--target-path <path>] [--model-ref <ref>] [--model-authored] [--action-summary <text>] [--verification-ask <text>] [--stop-condition <text>] [--escalation-reason <text>] [--assumption <text>] [--constraint <text>] [--non-goal <text>] [--open-question <text>] [--decision-point <text>] [--evidence-need <text>]\n\
plan --workspace <repo> [--item <id>] --objective <text> --plan-summary <text> --command <command> --changed-path <path> --commit-message <text> [--adoption-evidence-ref <ref>]\n\
run --workspace <repo> [--item <id>] [--accept-receipt <path>] [--runtime-store <path>] [--requested-path <path>]\n\
adopt --workspace <repo> [--item <id>] [--run-receipt <path>] [--from-plan <path>] [--plan-summary <text>] [--adoption-evidence-ref <ref>] [--mind-adoption-rationale <text>]\n\