Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Takeshi
|
c77639a9d7 |
@@ -330,7 +330,6 @@ func initialize(clock: SimulationKernel, state: Variant, seed := DEFAULT_WORLD_S
|
||||
register_command_executor(&"begin_staff_task", Callable(self, "_execute_begin_staff_task"))
|
||||
register_command_executor(&"progress_staff_task", Callable(self, "_execute_progress_staff_task"))
|
||||
register_command_executor(&"create_relationship", Callable(self, "_execute_create_relationship"))
|
||||
register_command_executor(&"register_original_relationship", Callable(self, "_execute_register_original_relationship"))
|
||||
register_command_executor(&"change_relationship", Callable(self, "_execute_change_relationship"))
|
||||
register_command_executor(&"attack_relationship_shield", Callable(self, "_execute_attack_relationship_shield"))
|
||||
register_command_executor(&"request_route_lock", Callable(self, "_execute_request_route_lock"))
|
||||
@@ -1055,15 +1054,8 @@ func _restore_snapshot_internal(snapshot: Dictionary, recovery_mode: bool) -> bo
|
||||
):
|
||||
return false
|
||||
var restored_relationships := RelationshipService.new()
|
||||
restored_relationships.configure_original_identity_validator(
|
||||
func(payload: Dictionary) -> bool: return _original_relationship_identities_valid(payload, restored_staff)
|
||||
)
|
||||
if not restored_relationships.restore_snapshot(runtime_data[&"relationships"]):
|
||||
return false
|
||||
for relationship: RelationshipState in restored_relationships.get_relationships():
|
||||
for actor_id: StringName in [relationship.actor_a_id, relationship.actor_b_id]:
|
||||
if actor_id != &"player" and not restored_staff.has_staff(actor_id) and not restored_guests.has_guest(actor_id):
|
||||
return false
|
||||
var restored_events := EventService.new()
|
||||
for raw_definition: Variant in runtime_data[&"event_definitions"]:
|
||||
var definition := EventDefinition.from_variant(raw_definition)
|
||||
@@ -5386,9 +5378,6 @@ func _initialize_s4_relationship_events() -> void:
|
||||
func _configure_relationship_event_boundaries() -> void:
|
||||
if relationship_service == null or event_service == null:
|
||||
return
|
||||
relationship_service.configure_original_identity_validator(
|
||||
func(payload: Dictionary) -> bool: return _original_relationship_identities_valid(payload, staff_service)
|
||||
)
|
||||
relationship_service.configure_candidate_callback(
|
||||
Callable(self, "_on_relationship_threshold_candidate")
|
||||
)
|
||||
@@ -6770,30 +6759,6 @@ func _execute_progress_staff_task(command: SimulationCommand) -> CommandResult:
|
||||
result.command_id = command.command_id
|
||||
return result
|
||||
|
||||
func _original_relationship_identities_valid(payload: Dictionary, staff_registry: StaffService) -> bool:
|
||||
if payload.get("protagonist_id") != "player" or staff_registry == null:
|
||||
return false
|
||||
var subject := StringName(payload.get("subject_id", ""))
|
||||
var rival := StringName(payload.get("rival_id", ""))
|
||||
if subject == &"player" or rival == &"player" or subject == rival or not staff_registry.has_staff(subject):
|
||||
return false
|
||||
var heroine_definition := mvp_content_catalog.get_entry(&"unique_characters", subject)
|
||||
var rival_definition := mvp_content_catalog.get_entry(&"unique_characters", rival)
|
||||
var subject_staff := staff_registry.get_staff(subject)
|
||||
return subject_staff.employment_kind == StaffRuntime.EmploymentKind.UNIQUE \
|
||||
and heroine_definition.get(&"role_id") == String(subject_staff.role_id) \
|
||||
and heroine_definition.get(&"character_kind") == "heroine" \
|
||||
and rival_definition.get(&"character_kind") == "rival" \
|
||||
and heroine_definition.get(&"counterpart_id") == String(rival) \
|
||||
and rival_definition.get(&"counterpart_id") == String(subject)
|
||||
|
||||
|
||||
func _execute_register_original_relationship(command: SimulationCommand) -> CommandResult:
|
||||
var result := relationship_service.register_original_relationship(command.payload)
|
||||
result.command_id = command.command_id
|
||||
return result
|
||||
|
||||
|
||||
func _execute_create_relationship(command: SimulationCommand) -> CommandResult:
|
||||
var actor_a_id := StringName(command.payload.get(&"actor_a_id", command.payload.get("actor_a_id", "")))
|
||||
var actor_b_id := StringName(command.payload.get(&"actor_b_id", command.payload.get("actor_b_id", "")))
|
||||
@@ -10894,7 +10859,6 @@ func get_staff_management_report() -> Dictionary:
|
||||
&"can_edit": block_reason.is_empty(),
|
||||
&"assignment_block_reason": block_reason,
|
||||
&"unique_contract": _staff_unique_contract_report(staff),
|
||||
&"original_relationship": relationship_service.get_original_relationship(staff.staff_id),
|
||||
})
|
||||
var facilities: Array[Dictionary] = []
|
||||
for facility: FacilityInstance in facility_service.get_instances():
|
||||
|
||||
@@ -2,28 +2,6 @@
|
||||
"schema_version": 1,
|
||||
"scope": "exact per-suite completion label/schema; all check counts from actual raw only",
|
||||
"rows": [
|
||||
{
|
||||
"test": "tests/s4/test_original_relationship_model.gd",
|
||||
"template": "Original relationship model: <checks> checks, <failures> failures",
|
||||
"required": true,
|
||||
"fixed_check_count_used": false,
|
||||
"source_sha256_at_schema_audit": "ad509f5fb67ab91e1d1d99a08af51e4695e411b9a2541ea63ee22b1555cb0924",
|
||||
"authority": {
|
||||
"path": "docs/spec/acceptance/P18-01-code-r01.json",
|
||||
"scope": "new backend suite marker; native execution pending"
|
||||
}
|
||||
},
|
||||
{
|
||||
"test": "tests/s4/test_original_relationship_runtime.gd",
|
||||
"template": "Original relationship runtime: <checks> checks, <failures> failures",
|
||||
"required": true,
|
||||
"fixed_check_count_used": false,
|
||||
"source_sha256_at_schema_audit": "374f3d31a65d2f2b62dfef29721c8c838575b856f4fa5a0bca31c6ba4c7e09dd",
|
||||
"authority": {
|
||||
"path": "docs/spec/acceptance/P18-01-code-r01.json",
|
||||
"scope": "new backend suite marker; native execution pending"
|
||||
}
|
||||
},
|
||||
{
|
||||
"test": "tests/ui/test_selection_departure.gd",
|
||||
"template": "Selection departure: <checks> checks, <failures> failures",
|
||||
|
||||
@@ -1,79 +0,0 @@
|
||||
# P18-01-CODE implementation handoff
|
||||
|
||||
Status: submitted for Runner validation; no acceptance or unit completion claimed.
|
||||
|
||||
Scope: dedicated original relationship state, lossless legacy snapshot preservation,
|
||||
Runtime registration and read projection, and the contract-listed tests and collector.
|
||||
Production initial values and gameplay coefficients are not supplied or inferred.
|
||||
|
||||
Validation: worker static inspection only; authoritative native local and affected
|
||||
validation, independent review, and integration belong to Runner.
|
||||
|
||||
Source inspection: HEAD matches d2a1f80a613e7c77b02b941026bc49c2d85db863.
|
||||
The acceptance specification without its final newline matches the contract SHA256
|
||||
04e9ae701b6ee1e399542564add695ca7fce54499e52dd2e907b1dbdc23a366d.
|
||||
|
||||
## Submitted behavior
|
||||
|
||||
- OriginalRelationshipState stores explicit directional subject/protagonist/rival
|
||||
facts with Affection, Lust, Netorare and shield current/max. All fields are
|
||||
required for a configured record. Numeric inputs must be finite numbers;
|
||||
shield current must be nonnegative and at most max, and max equals Affection.
|
||||
No additional emotion ranges, coefficients or production values are imposed.
|
||||
- RelationshipService retains its five-axis API. Its v2 snapshot contains the
|
||||
whole v1 payload under `legacy`, plus separate `original_relationships`.
|
||||
Top-level `relationships` is a compatibility projection for existing consumers;
|
||||
disagreement with `legacy.relationships` is rejected. Additional legacy fields,
|
||||
raw aliases, collection order and untouched values survive migration. The
|
||||
existing normalized state remains usable; only actual legacy changes are merged
|
||||
into retained raw facts. Aliases never initialize original fields.
|
||||
- Registration uses `register_original_relationship` with the complete payload.
|
||||
Runtime validates the protagonist against `player`, the subject against hired
|
||||
UNIQUE staff and its canonical role, and heroine/rival identities and reciprocal
|
||||
counterpart references against the existing unique-character catalog. Rival
|
||||
catalog membership does not invent recruitment. No new original update policy,
|
||||
contact, route, attack, threshold or duel behavior is defined.
|
||||
- Snapshot restore validates candidates before replacing live services, then
|
||||
rebinds the identity validator to live staff. Existing legacy actor references
|
||||
must resolve against player, restored staff or restored guests.
|
||||
- Every staff-management row exposes `original_relationship`. Missing records
|
||||
have `configured: false` and null values, distinct from explicit zero. Configured
|
||||
projections are copies, so reads and caller edits cannot change service state.
|
||||
|
||||
## Validation and handoff
|
||||
|
||||
Two new s4 suites exercise explicit/unset/zero data, malformed and nonfinite values,
|
||||
identity invariants, lossless raw aliases/extensions, new and mixed round trips,
|
||||
atomic service/Runtime rejection, actual hiring/commands, restore/rebind and reports.
|
||||
Existing test bodies and limits are unchanged. New marker and suite-policy rows
|
||||
are pinned to the exact new test sources.
|
||||
|
||||
`python3 -B tools/run_p18_relationship_tests.py --prepare-only` previews the exact
|
||||
seven-suite roster, source bytes, capacity and all-script parse count without
|
||||
engines, profiles, stage creation or test execution. The native collector reuses
|
||||
run_all_tests.source_refs/execute_phase and the existing Guard, owned_outer,
|
||||
diagnostic, artifact, PID, marker and cleanup gates. It stops at the first failure;
|
||||
Runner owns repair/validation sequencing and independent review.
|
||||
|
||||
Worker checks: Python AST syntax, JSON/source-marker consistency, allowed-path
|
||||
inspection, unchanged pre-existing marker/policy records, and git diff whitespace.
|
||||
Native import, GDScript parse and all seven suites remain **unexecuted** by worker.
|
||||
Worker reinspection on 2026-10-13 confirmed the existing submitted implementation
|
||||
and repeated Python AST, specification digest, exact new marker/policy source
|
||||
hashes, unchanged existing marker/policy records, and `git diff --check`.
|
||||
Prepare-only exited 0: seven suites, 1,311 source files / 67,287,056 bytes,
|
||||
308 parse paths, nine future native phases, 381,859,856 conservative required
|
||||
bytes and 1,773,187,072 available bytes. Engines and stages were both zero;
|
||||
actual checks were null and formal acceptance was false. Capacity is a preview
|
||||
at that instant, not a reservation or native result.
|
||||
An initial shell here-document temporary-file attempt was denied with
|
||||
`operation not permitted`; normal allowed-path patch edits worked. No isolation
|
||||
rule or permission was relaxed.
|
||||
|
||||
P18-C-1 through P18-C-3 are implementation submissions, not accepted results.
|
||||
P18-C-4 awaits Runner native local/affected evidence, separate Opus review,
|
||||
integration and final affected validation. The original P18-01 unit remains
|
||||
in_progress: ordinary Japanese UI rendering/equality, approved production values,
|
||||
all-seven recruitment, final full required roster and applicable Windows final
|
||||
acceptance remain outstanding. No git writes, other agents or Runner controls
|
||||
were used by worker.
|
||||
-80
@@ -1,80 +0,0 @@
|
||||
# P18-01-CODE recorded repair 2/2: collection / verification split
|
||||
|
||||
Resumes candidate `f76ad96990a4d7371b6ab667df0a068cc06be798`. No counter reset,
|
||||
game/test reconstruction, Runner change, commit or integration. Changes are confined
|
||||
to the narrow collector and this note. Existing game behavior evidence remains the
|
||||
retained Astra preflight; this worker did not rerun or reinterpret it as final proof.
|
||||
|
||||
## Modes
|
||||
|
||||
- Default: `python -B tools/run_p18_relationship_tests.py --output {build_dir}/p18-relationship-evidence`.
|
||||
Read-only verification in the ordinary registered sandbox. No subprocess call,
|
||||
process discovery, native launch, or access to the external player/private profiles.
|
||||
Current checkout source/settings/support/marker bytes and the locally configured
|
||||
`godot` binary are read for pins. Receipt-provided paths never select an external
|
||||
file to open. Original absolute paths remain historical identity strings.
|
||||
- `--collect`: Root orchestration only, outside Seatbelt. Uses the existing
|
||||
`source_refs`, private source copy, `execute_phase`, owned_outer, Guard, logger,
|
||||
diagnostic, marker and bounded cleanup contracts unchanged. Fresh output outside
|
||||
the checkout, with an existing parent, is required. Runs import, all 308 scripts,
|
||||
and exactly the seven fixed tests once. Owned profile bytes are archived after
|
||||
each phase. The final verifier runs after collection; no duplicate regression.
|
||||
“Root” identifies the authorized orchestrator, not a requirement to run as Unix uid 0.
|
||||
- `--prepare-only`: reports source bytes, available capacity, 308 parse paths and
|
||||
the exact seven-test/nine-phase roster; creates no stage/profile and starts no engine.
|
||||
|
||||
Only `--output`, `--collect`, `--prepare-only` and help are accepted. Duplicate,
|
||||
abbreviated, unknown and malformed flags, combined modes, traversal, symlinks,
|
||||
nonregular evidence and hardlinked evidence reject. Verification never rewrites
|
||||
raw paths or files. The ordinary-owner pure proof reader maps only the original
|
||||
output prefix to the supplied output and checks confinement before opening files.
|
||||
|
||||
## Receipt schema
|
||||
|
||||
`receipt.json` (`guarded-p18-v2`) is written last after successful collection.
|
||||
It contains the full relative source content map (bytes/SHA-256, no checkout-path
|
||||
dependency), its canonical JSON SHA-256, project and marker-contract SHA-256,
|
||||
engine SHA-256, and a complete relative file inventory with byte sizes/SHA-256.
|
||||
The inventory covers the retained private source, engine bytes, bootstraps,
|
||||
starters, raw stdout/stderr/native logger, phase receipts, START/END/process and
|
||||
both cleanup records, Guard reports, ordinary/audio ownership proofs, typed
|
||||
snapshots, and complete archived startup/runtime profiles. Only the enclosing
|
||||
receipt itself is outside its own inventory.
|
||||
|
||||
Verification checks the inventory and recomputes raw marker/diagnostic gates,
|
||||
source and helper pins, exact commands, START/END identity, all nine distinct PIDs
|
||||
and bounded cleanup, Guard conditions, proof gates, complete player before/after
|
||||
inventory equality, and seven test rows against nine phase receipts. It requires
|
||||
one exact `FULL_DEPENDENCY_PARSE checks=308 failures=0` marker. Old v1, absent,
|
||||
incomplete, mismatched or altered evidence rejects. A source change, including
|
||||
this collector, requires fresh Root collection; no source exemptions exist.
|
||||
|
||||
## Worker checks and environment observations
|
||||
|
||||
AST/in-memory compile and prepare-only passed. Prepare-only found 1311 source
|
||||
files, 308 parse scripts, seven tests and nine future phases, with sufficient
|
||||
reported capacity. Synthetic negative checks rejected missing receipts, changed
|
||||
hashes, symlinks, relative and absolute escapes, incomplete files and invalid or
|
||||
duplicate flags/mode combinations. Those checks replaced subprocess entry points
|
||||
and default-player access with fail-fast functions; neither was called. No native
|
||||
test, full regression, `--collect`, Runner operation or review was executed.
|
||||
|
||||
Environment evidence: a shell here-document failed with
|
||||
`zsh:1: can't create temp file for here document: operation not permitted`.
|
||||
The `python` alias was unavailable (`zsh:1: command not found: python`);
|
||||
worker checks used `/usr/bin/python3 -B`. Ordinary authorized file edits and
|
||||
temporary negative fixtures under the task allocation succeeded. No isolation
|
||||
or permission policy was changed. Root/Runner must provide the configured
|
||||
`python` command used by the fixed validator argv.
|
||||
|
||||
## Root next steps
|
||||
|
||||
1. On the final unchanged source, run the native `--collect` exactly once outside
|
||||
Seatbelt into the allocation build directory's fresh `p18-relationship-evidence`.
|
||||
Do not reuse old v1 evidence or run collection from ordinary Runner validation.
|
||||
2. Run ordinary Runner validation using the fixed default verify-only argv.
|
||||
3. Obtain a separate Opus review, then perform the authorized integration and
|
||||
affected final validation. This worker submits implementation, not acceptance.
|
||||
|
||||
P18-01 remains incomplete: ordinary UI rendering/display equality, approved initial
|
||||
values, the full final roster and applicable Windows final acceptance remain unmet.
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
{
|
||||
"project": "the-tree-p18-01-model",
|
||||
"task": "P18-01-CODE",
|
||||
"decision": "/Users/korizatou114/Projects/とりにく工房ゲーム制作部/docs/plans/original-completion-2026-10-02/execution/p18-01-contract-r01/opus-run-decision-r01.json",
|
||||
"actual_processes": [
|
||||
{
|
||||
"id": "65473b7a1fda4695a5be88c0ca0a1038",
|
||||
"role": "commander",
|
||||
"service": "claude",
|
||||
"status": "finished",
|
||||
"pid": 97963,
|
||||
"artifact": "/Users/korizatou114/Library/Application Support/agent-control/the-tree-p18-01-model/runs/65473b7a1fda4695a5be88c0ca0a1038",
|
||||
"argv_model": "claude-opus-5-5",
|
||||
"command_sha256": "b8da04043b58f45e3eaf5baad884fbf57d29564564e606c8c51029ef48d70bdc"
|
||||
},
|
||||
{
|
||||
"id": "b1931a8dcbc24d88bb3cbdce45140e02",
|
||||
"role": "implementer",
|
||||
"service": "codex",
|
||||
"status": "running",
|
||||
"pid": 98215,
|
||||
"artifact": "/Users/korizatou114/Library/Application Support/agent-control/the-tree-p18-01-model/runs/b1931a8dcbc24d88bb3cbdce45140e02",
|
||||
"argv_model": "gpt-6-astra",
|
||||
"command_sha256": "9f4f9d953ad8383f8d9f6284cf1cbc1a57c052aee50bcc3e47f253400525de1e"
|
||||
}
|
||||
],
|
||||
"no_unit_acceptance": true,
|
||||
"defaults": {
|
||||
"codex": "gpt-6.1-sol",
|
||||
"claude": "claude-opus-5-5",
|
||||
"agy": null
|
||||
}
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"action": "run",
|
||||
"task_id": "P18-01-CODE",
|
||||
"reason": "P18-01-CODE is ready. It has no declared dependencies and no other code worker is running. The P24-02 candidate 666c87bd stays separate and unchanged. The spec (docs/spec/acceptance/P18-01-code-r01.json, base d2a1f80) can be built without inventing values. Original Affection/Lust/Netorare and shield values are explicitly unset, which is different from zero, and shield_max is tied to the configured Affection. Supplied numbers are only validation fixtures. Legacy v1 five-axis data is kept raw through a v2 round trip with no conversion. The Runtime save/restore/read-model path rejects bad input atomically. None of this needs approved initial values, so not knowing them is no reason to wait. Run conditions: worker edits only the allowed_paths and touches no UI files. Worker does static, parse and --prepare-only checks first (byte/capacity/roster preview, 2GiB capacity unchanged) before any import. The Root Runner owns the authoritative native local+affected run (the two new P18 tests, s4 relationship_event_service/runtime_relationship_events, s6 runtime_snapshot_serialization/runtime_save_lifecycle, ui staff_management), with no duplicate full regression. Test isolation, owned profiles, process ownership, marker provenance and caps stay as they are. Existing tests are not weakened. Worker does not commit, push or touch main. This backend phase does not accept P18-C-1 to C-4 or the P18-01 unit. Ordinary UI (Antigravity later), approved initial values and the full final, Windows and main-integration acceptance remain unmet.",
|
||||
"codex_model": "gpt-6-astra",
|
||||
"codex_model_reason": "Astra is justified because this task is hard and risky, not routine. (1) It is a save-format migration (v1 to v2) that must keep unknown raw legacy fields byte-for-byte and must never convert affinity into Affection or dependence into Netorare. (2) It needs atomic rejection with no partial commit across RelationshipService and SimulationRuntime snapshot create/restore/rebind, reusing the P03 restore safeguards. (3) It must check player/staff identity, duplicates and references against the P17 registry. (4) It needs a new strict native collector that reuses the run_all_tests, owned_outer, Guard and marker provenance contracts and keeps isolation intact. A mistake here could corrupt saves or break legacy relationship events and snapshot regressions, and only 2 repairs are allowed, so doing it right the first time is worth Astra's extra time and usage. This matches my earlier Astra choice for P18 migration safety. Choosing the model does not authorize any cap change or acceptance waiver."
|
||||
}
|
||||
@@ -27,6 +27,16 @@
|
||||
"action": "wait",
|
||||
"evidence": "/Users/korizatou114/Projects/とりにく工房ゲーム制作部/docs/plans/original-completion-2026-10-02/execution/rp24-02-codex-model-decision-r01.json",
|
||||
"actual_codex_inference_confirmed": false
|
||||
},
|
||||
"latest_registered_task_selection": {
|
||||
"task": "P18-01-CODE",
|
||||
"model": "gpt-6-astra",
|
||||
"decision_owner": "Claude Opus5.5",
|
||||
"evidence": "docs/plans/original-completion-2026-10-02/execution/p18-01-contract-r01/opus-run-decision-r01.json",
|
||||
"dispatch_evidence": "docs/plans/original-completion-2026-10-02/execution/p18-01-contract-r01/actual-model-dispatch-r01.json",
|
||||
"worker_state": "implementing",
|
||||
"actual_argv_confirmed": true,
|
||||
"unit_acceptance": false
|
||||
}
|
||||
},
|
||||
"agy": "unchanged",
|
||||
|
||||
@@ -205,8 +205,8 @@
|
||||
"remaining_delivery_units": 88,
|
||||
"current_package_state_counts": {
|
||||
"completed": 1,
|
||||
"in_progress": 26,
|
||||
"planned": 3
|
||||
"in_progress": 27,
|
||||
"planned": 2
|
||||
},
|
||||
"initial_snapshot_checked": false,
|
||||
"historical_source_bytes_compared": false,
|
||||
@@ -223,7 +223,7 @@
|
||||
"ASSETS_PLATFORM_AUDIT.md": "a3a4b8ca0fb39a9abf88692285d26aa879815e092352ba304ef2758e71da50bd",
|
||||
"ATOMIC_REGISTER.md": "6070143b85b7c3b9b73d7c9768d88d2dae4d20407ad54a563cb6ffd74f2373ae",
|
||||
"ATOMIC_SEMANTIC_REVIEW.md": "c156b1fb57c2b4a900f27a19049510f3e9616e723d5edb3417f50d733de5be48",
|
||||
"IMPLEMENTATION_PLAN.md": "00004ff16c10cda0cc29429770afc90f66e40672e058939f8cac1cc451c32a46",
|
||||
"IMPLEMENTATION_PLAN.md": "2f1a933d1f47966b66945efc2d44747d7b9ea63cd223271fad0fad010f080ba3",
|
||||
"IMPORT_UNICODE_AUDIT.md": "88b2382bfbb3411fece8be7e6004ba21d8bf6a47e9d1f3cf573ea6638f79c12f",
|
||||
"P09_VALUE_CONTRACTS.md": "c5abdc4543e54033b1fcfd0943cba266f664d8c10968965fd36ade40da488a25",
|
||||
"PERFORMANCE_AUDIT.md": "c75e806acf825fc4a61f773a2cce7e71be335a1e25dbb15d98091097e8dc47c1",
|
||||
@@ -254,6 +254,6 @@
|
||||
"validate_facility_value_contracts.py": "91640e2a76cd6cc9186f7b85c0bf379b24b6cac0d48962815235ee628e7ae43e",
|
||||
"validate_plan.py": "23678227d9b3c556f1bd903f4b5b3147c4a82ce5085e10055481026803451b80",
|
||||
"validator_update_checks.json": "f997d0f3de2cea29550840b1d5cb23647d64f81329de46758551e2b6c8fecc27",
|
||||
"work_packages.json": "1682bd3fe49a16f520cede855ca07814212541b2090971327954d6569245517c"
|
||||
"work_packages.json": "dd68057aa4a00291dd9107c989983277568dcd8d5dc6e3560e89119e8583bf98"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8503,7 +8503,7 @@
|
||||
},
|
||||
"legacy_state": "planned",
|
||||
"state_scope": "package-level; completed means whole package accepted; partial implementation is not completion",
|
||||
"current_summary": "P18-01 actual original/legacy save audit and backend implementation contract prepared. Opus5.5 recommends Astra for migration/atomic restore complexity. Backend code phase remains part of P18-01; no new delivery unit and no acceptance yet. UI and approved initialization remain unmet.",
|
||||
"current_summary": "P18-01 code phase registered at base d2a1f80 and actually implementing with gpt-6-astra selected by Opus5.5. Original model/legacy raw preservation/Runtime save and read-model scoped; UI and initialization values remain unmet. No new delivery unit or acceptance.",
|
||||
"remaining_deliverables": [
|
||||
{
|
||||
"id": "P18-01",
|
||||
@@ -8527,7 +8527,7 @@
|
||||
}
|
||||
],
|
||||
"updated_at_jst": "2026-10-13T14:01:57.377446+09:00",
|
||||
"progress_summary": "P18-01 actual original/legacy save audit and backend implementation contract prepared. Opus5.5 recommends Astra for migration/atomic restore complexity. Backend code phase remains part of P18-01; no new delivery unit and no acceptance yet. UI and approved initialization remain unmet.",
|
||||
"progress_summary": "P18-01 code phase registered at base d2a1f80 and actually implementing with gpt-6-astra selected by Opus5.5. Original model/legacy raw preservation/Runtime save and read-model scoped; UI and initialization values remain unmet. No new delivery unit or acceptance.",
|
||||
"remaining_gaps": [
|
||||
"Implement original three-axis meaning and protagonist Affection-bound shield maximum across model/UI/save.",
|
||||
"Preserve old generic five-axis facts without guessed migration; pin new/old/missing/unknown/corrupt save contract.",
|
||||
|
||||
@@ -1,38 +0,0 @@
|
||||
class_name OriginalRelationshipState
|
||||
extends RefCounted
|
||||
|
||||
## Explicit facts only. Numeric values are not production initialization approval.
|
||||
## No update, attack, reduction, threshold or route policy is defined here.
|
||||
const FIELDS := ["subject_id", "protagonist_id", "rival_id", "affection", "lust", "netorare", "shield_current", "shield_max"]
|
||||
var _payload: Dictionary = {}
|
||||
|
||||
|
||||
static func from_snapshot(value: Variant) -> OriginalRelationshipState:
|
||||
if not value is Dictionary or value.size() != FIELDS.size():
|
||||
return null
|
||||
for field: String in FIELDS:
|
||||
if not value.has(field):
|
||||
return null
|
||||
for field: String in ["subject_id", "protagonist_id", "rival_id"]:
|
||||
if not (value[field] is String or value[field] is StringName) or String(value[field]).is_empty():
|
||||
return null
|
||||
if value["subject_id"] == value["protagonist_id"] or value["subject_id"] == value["rival_id"] or value["protagonist_id"] == value["rival_id"]:
|
||||
return null
|
||||
for field: String in ["affection", "lust", "netorare", "shield_current", "shield_max"]:
|
||||
if not (value[field] is int or value[field] is float):
|
||||
return null
|
||||
if value[field] is float and not is_finite(value[field]):
|
||||
return null
|
||||
if value["shield_max"] != value["affection"] or value["shield_current"] < 0 or value["shield_current"] > value["shield_max"]:
|
||||
return null
|
||||
var state := OriginalRelationshipState.new()
|
||||
state._payload = value.duplicate(true)
|
||||
return state
|
||||
|
||||
|
||||
func create_snapshot() -> Dictionary:
|
||||
return _payload.duplicate(true)
|
||||
|
||||
|
||||
func subject_id() -> StringName:
|
||||
return StringName(_payload.get("subject_id", ""))
|
||||
@@ -1 +0,0 @@
|
||||
uid://cqxwpbkgjtnsa
|
||||
@@ -9,9 +9,8 @@ signal route_lock_changed(relationship_id: StringName, old_lock: int, new_lock:
|
||||
|
||||
const RelationshipStateType = preload("res://scripts/relationship/relationship_state.gd")
|
||||
const CommandResultType = preload("res://scripts/core/command_result.gd")
|
||||
const OriginalStateType = preload("res://scripts/relationship/original_relationship_state.gd")
|
||||
|
||||
const SNAPSHOT_VERSION := 2
|
||||
const SNAPSHOT_VERSION := 1
|
||||
const DAILY_AUTOMATIC_DELTA_LIMIT := 10
|
||||
const GATED_THRESHOLDS: Array[int] = [50, 80]
|
||||
const STAGE_THRESHOLDS: Array[int] = [20, 50, 80, 100]
|
||||
@@ -23,46 +22,6 @@ var _pair_index: Dictionary = {}
|
||||
var _threshold_candidates: Array[Dictionary] = []
|
||||
var _next_candidate_sequence := 1
|
||||
var _candidate_callback := Callable()
|
||||
var _original_records: Dictionary = {}
|
||||
var _original_identity_validator := Callable()
|
||||
var _legacy_raw: Dictionary = {}
|
||||
var _legacy_baselines: Dictionary = {}
|
||||
var _container_raw: Dictionary = {}
|
||||
|
||||
|
||||
func configure_original_identity_validator(callback: Callable) -> RelationshipService:
|
||||
_original_identity_validator = callback
|
||||
return self
|
||||
|
||||
|
||||
func register_original_relationship(payload: Variant) -> CommandResult:
|
||||
var state := OriginalStateType.from_snapshot(payload)
|
||||
if state == null:
|
||||
return _invalid("Original relationship requires complete explicit facts.")
|
||||
if not _original_identity_validator.is_valid() or not bool(_original_identity_validator.call(state.create_snapshot())):
|
||||
return _invalid("Original relationship identities are not registered.")
|
||||
if _original_records.has(state.subject_id()):
|
||||
return _duplicate("Original relationship subject", state.subject_id())
|
||||
_original_records[state.subject_id()] = state.create_snapshot()
|
||||
last_error = ""
|
||||
return _success({&"subject_id": state.subject_id()})
|
||||
|
||||
|
||||
func get_original_relationship(subject_id: StringName) -> Dictionary:
|
||||
if _original_records.has(subject_id):
|
||||
var result: Dictionary = _original_records[subject_id].duplicate(true)
|
||||
result[&"configured"] = true
|
||||
return result
|
||||
return {&"configured": false, &"subject_id": subject_id,
|
||||
&"protagonist_id": null, &"rival_id": null, &"affection": null,
|
||||
&"lust": null, &"netorare": null, &"shield_current": null, &"shield_max": null}
|
||||
|
||||
|
||||
func validate_original_identities() -> bool:
|
||||
for payload: Dictionary in _original_records.values():
|
||||
if not _original_identity_validator.is_valid() or not bool(_original_identity_validator.call(payload.duplicate(true))):
|
||||
return false
|
||||
return true
|
||||
|
||||
|
||||
func configure_candidate_callback(callback: Callable = Callable()) -> RelationshipService:
|
||||
@@ -370,8 +329,6 @@ func consume_threshold_candidate(candidate_id: StringName) -> Dictionary:
|
||||
|
||||
func validate_invariants() -> Dictionary:
|
||||
var errors: Array[String] = []
|
||||
if not validate_original_identities():
|
||||
errors.append("Original relationship identity reference is invalid.")
|
||||
var seen_pairs: Dictionary = {}
|
||||
for relationship_id: StringName in _sorted_name_keys(_relationships):
|
||||
var state := get_relationship(relationship_id)
|
||||
@@ -390,92 +347,22 @@ func validate_invariants() -> Dictionary:
|
||||
func create_snapshot() -> Dictionary:
|
||||
var relationships: Array[Dictionary] = []
|
||||
for state: RelationshipState in get_relationships():
|
||||
var current := state.create_snapshot()
|
||||
var original: Dictionary = _legacy_baselines.get(state.relationship_id, {})
|
||||
var raw: Dictionary = {}
|
||||
for entry: Dictionary in _legacy_raw.get(&"relationships", []):
|
||||
if StringName(_value(entry, &"relationship_id", "")) == state.relationship_id:
|
||||
raw = entry
|
||||
break
|
||||
relationships.append(_merge_legacy_changes(raw, original, current) if not original.is_empty() else current)
|
||||
relationships.append(state.create_snapshot())
|
||||
var candidates := _threshold_candidates.duplicate(true)
|
||||
candidates.sort_custom(
|
||||
func(a: Dictionary, b: Dictionary) -> bool:
|
||||
return String(a.get(&"candidate_id", "")) < String(b.get(&"candidate_id", ""))
|
||||
)
|
||||
var legacy := _legacy_raw.duplicate(true)
|
||||
legacy[&"version"] = 1
|
||||
# Preserve input collection order as well as every untouched raw field.
|
||||
if _legacy_raw.has(&"relationships"):
|
||||
var ordered: Array[Dictionary] = []
|
||||
for raw: Dictionary in _legacy_raw[&"relationships"]:
|
||||
for entry: Dictionary in relationships:
|
||||
if _value(entry, &"relationship_id", "") == _value(raw, &"relationship_id", ""):
|
||||
ordered.append(entry)
|
||||
for entry: Dictionary in relationships:
|
||||
if not ordered.has(entry):
|
||||
ordered.append(entry)
|
||||
relationships = ordered
|
||||
if legacy.get(&"relationships") != relationships:
|
||||
legacy[&"relationships"] = relationships
|
||||
var current_candidates := _threshold_candidates.duplicate(true) if not _legacy_raw.is_empty() else candidates
|
||||
if legacy.get(&"threshold_candidates") != current_candidates:
|
||||
legacy[&"threshold_candidates"] = current_candidates
|
||||
legacy[&"next_candidate_sequence"] = _next_candidate_sequence
|
||||
var result := _container_raw.duplicate(true)
|
||||
result[&"version"] = SNAPSHOT_VERSION
|
||||
result[&"legacy"] = legacy
|
||||
# Compatibility projection for existing snapshot consumers; the nested v1
|
||||
# record remains lossless, including extension names reserved by v2.
|
||||
if result.get(&"relationships") != relationships:
|
||||
result[&"relationships"] = relationships.duplicate(true)
|
||||
var originals: Array[Dictionary] = []
|
||||
for payload: Dictionary in _original_records.values():
|
||||
originals.append(payload.duplicate(true))
|
||||
if result.get(&"original_relationships") != originals:
|
||||
result[&"original_relationships"] = originals
|
||||
return result
|
||||
|
||||
|
||||
static func _merge_legacy_changes(raw: Dictionary, baseline: Dictionary, current: Dictionary) -> Dictionary:
|
||||
var result := raw.duplicate(true)
|
||||
for key: Variant in baseline:
|
||||
if not current.has(key):
|
||||
result.erase(key)
|
||||
for key: Variant in current:
|
||||
if baseline.has(key) and current[key] == baseline[key]:
|
||||
continue
|
||||
if current[key] is Dictionary and baseline.get(key) is Dictionary and result.get(key) is Dictionary:
|
||||
result[key] = _merge_legacy_changes(result[key], baseline[key], current[key])
|
||||
else:
|
||||
result[key] = current[key]
|
||||
return result
|
||||
return {
|
||||
&"version": SNAPSHOT_VERSION,
|
||||
&"relationships": relationships,
|
||||
&"threshold_candidates": candidates,
|
||||
&"next_candidate_sequence": _next_candidate_sequence,
|
||||
}
|
||||
|
||||
|
||||
func restore_snapshot(snapshot: Dictionary) -> bool:
|
||||
var version: Variant = _value(snapshot, &"version", null)
|
||||
if not version is int or version not in [1, SNAPSHOT_VERSION]:
|
||||
last_error = "Unsupported Relationship snapshot version."
|
||||
return false
|
||||
var legacy: Variant = snapshot if version == 1 else _value(snapshot, &"legacy", null)
|
||||
var originals: Variant = [] if version == 1 else _value(snapshot, &"original_relationships", null)
|
||||
if not legacy is Dictionary or not originals is Array:
|
||||
last_error = "Malformed Relationship snapshot container."
|
||||
return false
|
||||
if version == SNAPSHOT_VERSION and _value(snapshot, &"relationships", null) != _value(legacy, &"relationships", null):
|
||||
last_error = "Legacy compatibility projection disagrees with its source."
|
||||
return false
|
||||
var original_records: Dictionary = {}
|
||||
for raw: Variant in originals:
|
||||
var state := OriginalStateType.from_snapshot(raw)
|
||||
if state == null or original_records.has(state.subject_id()):
|
||||
last_error = "Invalid or duplicate original relationship."
|
||||
return false
|
||||
if not _original_identity_validator.is_valid() or not bool(_original_identity_validator.call(state.create_snapshot())):
|
||||
last_error = "Invalid original relationship identity reference."
|
||||
return false
|
||||
original_records[state.subject_id()] = state.create_snapshot()
|
||||
var parsed := _parse_snapshot(legacy)
|
||||
var parsed := _parse_snapshot(snapshot)
|
||||
if not bool(parsed.get(&"ok", false)):
|
||||
last_error = String(parsed.get(&"error", "Invalid Relationship snapshot."))
|
||||
return false
|
||||
@@ -483,18 +370,12 @@ func restore_snapshot(snapshot: Dictionary) -> bool:
|
||||
_pair_index = parsed[&"pair_index"]
|
||||
_threshold_candidates = parsed[&"threshold_candidates"]
|
||||
_next_candidate_sequence = int(parsed[&"next_candidate_sequence"])
|
||||
_original_records = original_records
|
||||
_legacy_raw = legacy.duplicate(true)
|
||||
_container_raw = snapshot.duplicate(true) if version == SNAPSHOT_VERSION else {}
|
||||
_legacy_baselines = {}
|
||||
for state: RelationshipState in get_relationships():
|
||||
_legacy_baselines[state.relationship_id] = state.create_snapshot()
|
||||
last_error = ""
|
||||
return true
|
||||
|
||||
|
||||
func _parse_snapshot(snapshot: Dictionary) -> Dictionary:
|
||||
if not _value(snapshot, &"version", null) is int or _value(snapshot, &"version", null) != 1:
|
||||
if int(_value(snapshot, &"version", 0)) != SNAPSHOT_VERSION:
|
||||
return {&"ok": false, &"error": "Unsupported Relationship snapshot version."}
|
||||
var raw_relationships: Variant = _value(snapshot, &"relationships", null)
|
||||
var raw_candidates: Variant = _value(snapshot, &"threshold_candidates", null)
|
||||
@@ -503,7 +384,7 @@ func _parse_snapshot(snapshot: Dictionary) -> Dictionary:
|
||||
var relationships: Dictionary = {}
|
||||
var pair_index: Dictionary = {}
|
||||
for raw_state: Variant in raw_relationships:
|
||||
if not raw_state is Dictionary or not _legacy_types_valid(raw_state):
|
||||
if not raw_state is Dictionary:
|
||||
return {&"ok": false, &"error": "Relationship snapshot entry is malformed."}
|
||||
var state := RelationshipStateType.from_snapshot(raw_state)
|
||||
if not state.is_valid() or relationships.has(state.relationship_id):
|
||||
@@ -517,9 +398,6 @@ func _parse_snapshot(snapshot: Dictionary) -> Dictionary:
|
||||
for raw_candidate: Variant in raw_candidates:
|
||||
if not raw_candidate is Dictionary:
|
||||
return {&"ok": false, &"error": "Threshold candidate is malformed."}
|
||||
for key: String in ["candidate_id", "relationship_id"]:
|
||||
if not (raw_candidate.get(key) is String or raw_candidate.get(key) is StringName):
|
||||
return {&"ok": false, &"error": "Threshold candidate identity type is invalid."}
|
||||
var candidate: Dictionary = raw_candidate.duplicate(true)
|
||||
var candidate_id := StringName(candidate.get(&"candidate_id", candidate.get("candidate_id", "")))
|
||||
var relationship_id := StringName(candidate.get(&"relationship_id", candidate.get("relationship_id", "")))
|
||||
@@ -527,8 +405,6 @@ func _parse_snapshot(snapshot: Dictionary) -> Dictionary:
|
||||
return {&"ok": false, &"error": "Threshold candidate reference is invalid."}
|
||||
candidate_ids[candidate_id] = true
|
||||
candidates.append(candidate)
|
||||
if not _value(snapshot, &"next_candidate_sequence", null) is int:
|
||||
return {&"ok": false, &"error": "Relationship candidate sequence type is invalid."}
|
||||
var next_sequence := int(_value(snapshot, &"next_candidate_sequence", 0))
|
||||
if next_sequence < 1:
|
||||
return {&"ok": false, &"error": "Relationship candidate sequence is invalid."}
|
||||
@@ -541,44 +417,6 @@ func _parse_snapshot(snapshot: Dictionary) -> Dictionary:
|
||||
}
|
||||
|
||||
|
||||
static func _legacy_types_valid(raw: Dictionary) -> bool:
|
||||
for key: String in ["relationship_id", "actor_a_id", "actor_b_id"]:
|
||||
if not (raw.get(key) is String or raw.get(key) is StringName):
|
||||
return false
|
||||
for key: String in ["shield_max", "shield_current", "last_event_at", "daily_attack_count", "attack_day", "metric_delta_day"]:
|
||||
if raw.has(key) and not raw[key] is int:
|
||||
return false
|
||||
for key: String in ["metrics", "action_counts", "daily_metric_deltas", "flags", "crossed_thresholds"]:
|
||||
if raw.has(key) and not raw[key] is Dictionary:
|
||||
return false
|
||||
for key: String in ["trust", "respect", "affection", "fear", "dependence", "affinity", "obligation"]:
|
||||
var metrics: Dictionary = raw.get("metrics", raw)
|
||||
if metrics.has(key) and not metrics[key] is int:
|
||||
return false
|
||||
for key: String in ["action_counts", "daily_metric_deltas"]:
|
||||
for value: Variant in raw.get(key, {}).values():
|
||||
if not value is int:
|
||||
return false
|
||||
for key: String in ["action_counts", "flags"]:
|
||||
for identity: Variant in raw.get(key, {}):
|
||||
if not (identity is String or identity is StringName):
|
||||
return false
|
||||
for value: Variant in raw.get("flags", {}).values():
|
||||
if not value is bool:
|
||||
return false
|
||||
for value: Variant in raw.get("crossed_thresholds", {}).values():
|
||||
if not value is Array:
|
||||
return false
|
||||
for threshold: Variant in value:
|
||||
if not threshold is int:
|
||||
return false
|
||||
if raw.has("route_id") and not (raw["route_id"] is String or raw["route_id"] is StringName):
|
||||
return false
|
||||
if raw.has("route_lock") and not (raw["route_lock"] is int or raw["route_lock"] is String or raw["route_lock"] is StringName):
|
||||
return false
|
||||
return true
|
||||
|
||||
|
||||
func _register_threshold_candidate(
|
||||
state: RelationshipState,
|
||||
metric_id: StringName,
|
||||
|
||||
@@ -1,110 +0,0 @@
|
||||
extends SceneTree
|
||||
|
||||
const Model = preload("res://scripts/relationship/original_relationship_state.gd")
|
||||
const Service = preload("res://scripts/relationship/relationship_service.gd")
|
||||
var _checks := 0
|
||||
var _failures := 0
|
||||
|
||||
|
||||
func _initialize() -> void:
|
||||
call_deferred("_run")
|
||||
|
||||
|
||||
func _expect(value: bool, message: String) -> void:
|
||||
_checks += 1
|
||||
if not value:
|
||||
_failures += 1
|
||||
push_error(message)
|
||||
|
||||
|
||||
static func fixture() -> Dictionary:
|
||||
# Validation fixtures, never approved initialization or range limits.
|
||||
return {"subject_id": "heroine_anri", "protagonist_id": "player", "rival_id": "rival_rai",
|
||||
"affection": 142.5, "lust": 23.25, "netorare": 11, "shield_current": 90.5, "shield_max": 142.5}
|
||||
|
||||
|
||||
func _service() -> RelationshipService:
|
||||
return Service.new().configure_original_identity_validator(
|
||||
func(p: Dictionary) -> bool:
|
||||
return p["subject_id"] == "heroine_anri" and p["protagonist_id"] == "player" and p["rival_id"] == "rival_rai"
|
||||
)
|
||||
|
||||
|
||||
func _run() -> void:
|
||||
var service := _service()
|
||||
var before := var_to_bytes(service.create_snapshot())
|
||||
var unset := service.get_original_relationship(&"heroine_anri")
|
||||
_expect(not unset[&"configured"] and unset[&"affection"] == null, "missing record is unset")
|
||||
unset[&"affection"] = 999
|
||||
_expect(var_to_bytes(service.create_snapshot()) == before, "reads own their dictionaries")
|
||||
var payload := fixture()
|
||||
var payload_bytes := var_to_bytes(payload)
|
||||
_expect(service.register_original_relationship(payload).is_success(), "complete directional fixture registers")
|
||||
payload["affection"] = 0
|
||||
_expect(service.get_original_relationship(&"heroine_anri")["affection"] == 142.5, "caller cannot mutate stored facts")
|
||||
_expect(not service.register_original_relationship(fixture()).is_success(), "duplicate subject rejected")
|
||||
var saved := service.create_snapshot()
|
||||
var restored := _service()
|
||||
_expect(restored.restore_snapshot(saved), "new-only v2 restores")
|
||||
_expect(var_to_bytes(restored.create_snapshot()) == var_to_bytes(saved), "new-only exact bytes")
|
||||
_expect(var_to_bytes(fixture()) == payload_bytes, "fixture is explicit and stable")
|
||||
for field: String in Model.FIELDS:
|
||||
var missing := fixture()
|
||||
missing.erase(field)
|
||||
_expect(Model.from_snapshot(missing) == null, "missing required field " + field)
|
||||
for value: Variant in [null, true, "12", INF, NAN, {}, []]:
|
||||
var wrong := fixture()
|
||||
wrong["lust"] = value
|
||||
_expect(Model.from_snapshot(wrong) == null, "wrong/nonfinite numeric value rejected")
|
||||
for patch: Dictionary in [{"shield_max": 1}, {"shield_current": -1}, {"shield_current": 143}, {"rival_id": "player"}, {"subject_id": "player"}]:
|
||||
var wrong := fixture()
|
||||
wrong.merge(patch, true)
|
||||
_expect(Model.from_snapshot(wrong) == null, "value/identity invariant rejected")
|
||||
var zero := fixture()
|
||||
for field: String in ["affection", "lust", "netorare", "shield_current", "shield_max"]:
|
||||
zero[field] = 0
|
||||
_expect(Model.from_snapshot(zero) != null, "explicit zero is configured")
|
||||
var legacy := {"version": 1, "relationships": [{"relationship_id": "old", "actor_a_id": "player", "actor_b_id": "heroine_anri",
|
||||
"metrics": {"affinity": 117, "dependence": 29, "extension": {"opaque": [3, "keep"]}}, "extra": ["raw", 2.5]}],
|
||||
"threshold_candidates": [], "next_candidate_sequence": 1, "extension": {"version": 70}}
|
||||
var legacy_bytes := var_to_bytes(legacy)
|
||||
var migrated := _service()
|
||||
_expect(migrated.restore_snapshot(legacy), "legacy aliases still usable")
|
||||
_expect(migrated.get_relationship(&"old").get_metric(&"affection") == 100, "legacy normalization behavior retained")
|
||||
_expect(not migrated.get_original_relationship(&"heroine_anri")[&"configured"], "legacy never configures original facts")
|
||||
_expect(var_to_bytes(migrated.create_snapshot()[&"legacy"]) == legacy_bytes, "all raw legacy values and extensions preserved")
|
||||
_expect(var_to_bytes(legacy) == legacy_bytes, "legacy input bytes untouched")
|
||||
_expect(migrated.register_original_relationship(fixture()).is_success(), "mixed state registers independently")
|
||||
var mixed := migrated.create_snapshot()
|
||||
_expect(restored.restore_snapshot(mixed), "mixed snapshot restores")
|
||||
_expect(var_to_bytes(restored.create_snapshot()) == var_to_bytes(mixed), "mixed exact bytes")
|
||||
_expect(migrated.apply_value_change(&"old", &"trust", 3, 0).is_success(), "legacy changes still apply")
|
||||
var changed: Dictionary = migrated.create_snapshot()[&"legacy"]
|
||||
_expect(changed["relationships"][0]["metrics"]["affinity"] == 117 and changed["relationships"][0]["metrics"]["trust"] == 3, "changed metric preserves raw alias")
|
||||
for version: Variant in [0, 3, "2", 2.0, true]:
|
||||
var bad := mixed.duplicate(true)
|
||||
bad[&"version"] = version
|
||||
_rejected(restored, bad)
|
||||
var duplicate := mixed.duplicate(true)
|
||||
duplicate[&"original_relationships"].append(fixture())
|
||||
_rejected(restored, duplicate)
|
||||
for patch: Dictionary in [{"rival_id": "unknown"}, {"protagonist_id": "unknown"}, {"lust": false}, {"shield_max": 10}]:
|
||||
var bad := mixed.duplicate(true)
|
||||
bad[&"original_relationships"][0].merge(patch, true)
|
||||
_rejected(restored, bad)
|
||||
var bad_legacy := legacy.duplicate(true)
|
||||
bad_legacy["relationships"][0]["metrics"]["affinity"] = "117"
|
||||
_rejected(restored, bad_legacy)
|
||||
bad_legacy = legacy.duplicate(true)
|
||||
bad_legacy["relationships"].append(bad_legacy["relationships"][0].duplicate(true))
|
||||
_rejected(restored, bad_legacy)
|
||||
print("Original relationship model: %d checks, %d failures" % [_checks, _failures])
|
||||
quit(_failures)
|
||||
|
||||
|
||||
func _rejected(service: RelationshipService, payload: Dictionary) -> void:
|
||||
var before := var_to_bytes(service.create_snapshot())
|
||||
var input := var_to_bytes(payload)
|
||||
_expect(not service.restore_snapshot(payload), "corrupt snapshot rejected")
|
||||
_expect(var_to_bytes(service.create_snapshot()) == before, "rejection preserves prior state")
|
||||
_expect(var_to_bytes(payload) == input, "rejection preserves input bytes")
|
||||
@@ -1 +0,0 @@
|
||||
uid://cqxwpbkgjtnsb
|
||||
@@ -1,78 +0,0 @@
|
||||
extends SceneTree
|
||||
|
||||
const Fixtures = preload("res://tests/s4/test_original_relationship_model.gd")
|
||||
var _checks := 0
|
||||
var _failures := 0
|
||||
|
||||
|
||||
func _initialize() -> void:
|
||||
call_deferred("_run")
|
||||
|
||||
|
||||
func _expect(value: bool, message: String) -> void:
|
||||
_checks += 1
|
||||
if not value:
|
||||
_failures += 1
|
||||
push_error(message)
|
||||
|
||||
|
||||
func _run() -> void:
|
||||
var clock = load("res://autoload/game_clock.gd").new()
|
||||
var state = load("res://autoload/game_state.gd").new()
|
||||
var runtime = load("res://autoload/simulation_runtime.gd").new()
|
||||
clock.reset(1, 6, 0)
|
||||
state.reset()
|
||||
_expect(runtime.initialize(clock, state, 18001)[&"valid"], "Runtime initialized")
|
||||
clock.set_paused(true)
|
||||
var fixture := Fixtures.fixture()
|
||||
_expect(not runtime.relationship_service.register_original_relationship(fixture).is_success(), "unhired subject rejected by service boundary")
|
||||
_expect(runtime.submit_command(&"hire_staff_candidate", {&"candidate_id": &"heroine_anri"}).is_success(), "actual approved Anri hire")
|
||||
var read_before := var_to_bytes(runtime.create_snapshot())
|
||||
var report: Dictionary = runtime.get_staff_management_report()
|
||||
var found := false
|
||||
for row: Dictionary in report[&"staff"]:
|
||||
if row[&"staff_id"] == &"heroine_anri":
|
||||
found = true
|
||||
_expect(not row[&"original_relationship"][&"configured"] and row[&"original_relationship"][&"affection"] == null, "actual report exposes unset")
|
||||
_expect(found, "hired staff appears in actual report")
|
||||
_expect(var_to_bytes(runtime.create_snapshot()) == read_before, "unset report read has no mutation")
|
||||
var old_events: Array = runtime.domain_events.create_snapshot()["recent_events"]
|
||||
_expect(runtime.submit_command(&"register_original_relationship", fixture).is_success(), "registered Runtime command stores explicit fixture")
|
||||
var new_events: Array = runtime.domain_events.create_snapshot()["recent_events"]
|
||||
_expect(new_events.size() == old_events.size() + 1 and new_events[-1][&"event_type"] == "COMMAND_COMPLETED", "only existing command completion event is emitted")
|
||||
_expect(runtime.relationship_service.create_relationship(&"legacy", &"heroine_anri", &"player", {&"affinity": 44}).is_success(), "legacy service remains usable")
|
||||
var saved: Dictionary = runtime.create_snapshot()
|
||||
var input := var_to_bytes(saved)
|
||||
_expect(runtime.restore_snapshot(saved), "mixed Runtime snapshot restores")
|
||||
_expect(var_to_bytes(runtime.create_snapshot()) == input, "Runtime snapshot exact round trip")
|
||||
_expect(var_to_bytes(saved) == input, "restore preserves caller bytes")
|
||||
read_before = var_to_bytes(runtime.create_snapshot())
|
||||
report = runtime.get_staff_management_report()
|
||||
for row: Dictionary in report[&"staff"]:
|
||||
if row[&"staff_id"] == &"heroine_anri":
|
||||
var original: Dictionary = row[&"original_relationship"]
|
||||
_expect(original[&"configured"] and original["affection"] == 142.5 and original["shield_max"] == 142.5, "restored report equals stored original values")
|
||||
original["affection"] = -99
|
||||
_expect(var_to_bytes(runtime.create_snapshot()) == read_before, "configured report owns projection containers")
|
||||
for patch: Dictionary in [{"subject_id": "missing"}, {"protagonist_id": "rival_rai"}, {"rival_id": "missing"}, {"shield_current": 999}, {"lust": "bad"}]:
|
||||
var corrupt := saved.duplicate(true)
|
||||
corrupt[&"systems"][&"runtime"][&"relationships"][&"original_relationships"][0].merge(patch, true)
|
||||
var bad_bytes := var_to_bytes(corrupt)
|
||||
var service_before: Variant = runtime.relationship_service
|
||||
_expect(not runtime.restore_snapshot(corrupt), "bad original Runtime restore rejected")
|
||||
_expect(runtime.relationship_service == service_before, "failed restore preserves service identity")
|
||||
_expect(var_to_bytes(runtime.create_snapshot()) == read_before, "failed restore preserves whole Runtime")
|
||||
_expect(var_to_bytes(corrupt) == bad_bytes, "failed restore preserves input")
|
||||
var v1 := saved.duplicate(true)
|
||||
v1[&"systems"][&"runtime"][&"relationships"] = saved[&"systems"][&"runtime"][&"relationships"][&"legacy"].duplicate(true)
|
||||
_expect(runtime.restore_snapshot(v1), "Runtime accepts genuine v1 relationship payload")
|
||||
_expect(not runtime.relationship_service.get_original_relationship(&"heroine_anri")[&"configured"], "v1 restore does not map legacy affection")
|
||||
var invalid := fixture.duplicate(true)
|
||||
invalid["rival_id"] = "missing"
|
||||
_expect(not runtime.relationship_service.register_original_relationship(invalid).is_success(), "restore rebind keeps identity validator")
|
||||
_expect(runtime.relationship_service.register_original_relationship(fixture).is_success(), "restored service accepts correct identities")
|
||||
runtime.free()
|
||||
clock.free()
|
||||
state.free()
|
||||
print("Original relationship runtime: %d checks, %d failures" % [_checks, _failures])
|
||||
quit(_failures)
|
||||
@@ -1 +0,0 @@
|
||||
uid://cqxwpbkgjtnsc
|
||||
@@ -1,20 +1,6 @@
|
||||
{
|
||||
"schema_version": 1,
|
||||
"suite_policies": {
|
||||
"tests/s4/test_original_relationship_model.gd": {
|
||||
"source_sha256": "ad509f5fb67ab91e1d1d99a08af51e4695e411b9a2541ea63ee22b1555cb0924",
|
||||
"ordinary_cleanup_prepared": false,
|
||||
"ordinary_control_labels": [],
|
||||
"old_bounded_teardown": false,
|
||||
"new_audio_QA": false
|
||||
},
|
||||
"tests/s4/test_original_relationship_runtime.gd": {
|
||||
"source_sha256": "374f3d31a65d2f2b62dfef29721c8c838575b856f4fa5a0bca31c6ba4c7e09dd",
|
||||
"ordinary_cleanup_prepared": false,
|
||||
"ordinary_control_labels": [],
|
||||
"old_bounded_teardown": false,
|
||||
"new_audio_QA": false
|
||||
},
|
||||
"tests/ui/test_selection_departure.gd": {
|
||||
"source_sha256": "3137f36f547514f25ce6ac775fa7a5141d12f83ca4b95da0be45fecfafe9d9b4",
|
||||
"ordinary_cleanup_prepared": true,
|
||||
|
||||
@@ -1,565 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Root-owned narrow P18 collection using the unchanged guarded phase protocol."""
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import stat
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import sys
|
||||
import uuid
|
||||
|
||||
sys.dont_write_bytecode = True
|
||||
import run_all_tests as shared
|
||||
|
||||
ROSTER = [
|
||||
'tests/s4/test_original_relationship_model.gd',
|
||||
'tests/s4/test_original_relationship_runtime.gd',
|
||||
'tests/s4/test_relationship_event_service.gd',
|
||||
'tests/s4/test_runtime_relationship_events.gd',
|
||||
'tests/s6/test_runtime_snapshot_serialization.gd',
|
||||
'tests/s6/test_runtime_save_lifecycle.gd',
|
||||
'tests/ui/test_staff_management.gd',
|
||||
]
|
||||
|
||||
|
||||
def collect(args, root, out, refs, markers, contracts, policy, contract_path, contract_sha, parse_paths):
|
||||
source_bytes = sum(pin['bytes'] for pin in refs.values())
|
||||
free = shutil.disk_usage(out.parent).free
|
||||
needed = source_bytes + shared.MIN_SPACE
|
||||
shared.require(free >= needed, 'fresh source and phase disk admission')
|
||||
outer = shared.module('p18_owned_outer', shared.SUPPORT / 'owned_outer.py')
|
||||
shared.require(not outer.native.helper['live_engines'](), 'another Godot owns CPU')
|
||||
engine = shutil.which('godot')
|
||||
shared.require(engine and Path(engine).is_file(), 'native launcher exists')
|
||||
engine = str(Path(engine).resolve())
|
||||
out.mkdir(parents=True, exist_ok=False)
|
||||
stage = out / 'stage'
|
||||
stage.mkdir()
|
||||
(out / 'starters').mkdir()
|
||||
(out / 'bootstrap').mkdir()
|
||||
for name, pin in shared.read(shared.SUPPORT / 'bootstrap-scripts.json').items():
|
||||
data = pin['text'].encode('utf-8')
|
||||
shared.require(hashlib.sha256(data).hexdigest() == pin['sha256'], 'unchanged external bootstrap bytes')
|
||||
(out / 'bootstrap' / name).write_bytes(data)
|
||||
protected = shared.default_player(root)
|
||||
expected = {name: {'bytes': pin['bytes'], 'sha256': pin['sha256']} for name, pin in refs.items()}
|
||||
selected = {'root_before': refs, 'map': {name: pin['sha256'] for name, pin in refs.items()}, 'timeout': args.timeout}
|
||||
for name, pin in refs.items():
|
||||
target = stage / name
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
shared.copy_source(Path(pin['path']), target)
|
||||
shared.require(shared.inventory(stage, stage=True) == expected, 'complete private source copy')
|
||||
public = (stage / 'project.godot').read_bytes()
|
||||
shared.write(out / 'parse-paths.json', parse_paths)
|
||||
run_id = uuid.uuid4().hex
|
||||
shared.write(out / 'runner-input.json', dict(protocol='guarded-p18-v2', run_id=run_id,
|
||||
owner_runner_pid=os.getpid(), project_root=str(root), stage=str(stage), roster=ROSTER,
|
||||
selected_source_map=selected['map'], marker_contract_sha256=contract_sha,
|
||||
runner_sha256=shared.sha(Path(__file__)), shared_runner_sha256=shared.sha(shared.HERE / 'run_all_tests.py'),
|
||||
marker_module_sha256=shared.sha(shared.HERE / 'strict_test_markers.py'),
|
||||
engine=engine, engine_sha256=shared.sha(engine), default_player_before=protected,
|
||||
formal_acceptance=False, original_unit_complete=False))
|
||||
shared.write(out / 'source-start.json', refs)
|
||||
diagnostics = shared.module('p18_diagnostics', shared.SUPPORT / 'diagnostic_gate.py')
|
||||
owners = shared.module('p18_owners', shared.SUPPORT / 'ordinary_proof_gate.py')
|
||||
audio = shared.module('p18_audio', shared.SUPPORT / 'audio_evidence_gate.py')
|
||||
phases, rows, previous = [], [], {}
|
||||
error = None
|
||||
try:
|
||||
for phase, test in [('import', None), ('parse', None)] + [(str(i).zfill(3), name) for i, name in enumerate(ROSTER)]:
|
||||
shared.require(shared.sha(contract_path) == contract_sha, 'marker contract unchanged')
|
||||
row = shared.execute_phase(engine, stage, out, phase, test, selected, expected, previous,
|
||||
policy, contracts, parse_paths, public, protected, root, outer, markers, diagnostics, owners, audio)
|
||||
archive_profiles(out, row)
|
||||
phases.append(row)
|
||||
if test:
|
||||
row.update(sequence=len(rows), godot=engine)
|
||||
rows.append(row)
|
||||
(out / 'all-tests.json').write_text(json.dumps(rows, ensure_ascii=False, indent=2) + '\n')
|
||||
print(('PASS ' if row['passed'] else 'FAIL ') + test, flush=True)
|
||||
shared.require(row['passed'], 'first failed phase stops without retry: ' + phase)
|
||||
except BaseException as caught:
|
||||
error = type(caught).__name__ + ': ' + str(caught)
|
||||
finally:
|
||||
cleanup, cleanup_errors = outer.finish_captured(outer.OWNED)
|
||||
guard_errors = []
|
||||
try:
|
||||
shared.require(shared.source_refs(root) == refs, 'whole source unchanged')
|
||||
shared.require(shared.sha(contract_path) == contract_sha, 'marker contract unchanged at end')
|
||||
shared.require(shared.default_player(root) == protected, 'default profile untouched')
|
||||
shared.require(shared.inventory(stage, stage=True) == dict(expected, **previous), 'whole stage exact')
|
||||
except BaseException as caught:
|
||||
guard_errors.append(type(caught).__name__ + ': ' + str(caught))
|
||||
ended = bool(outer.OWNED) and all(row['engine_ended'] is True for row in cleanup)
|
||||
passed = error is None and not cleanup_errors and not guard_errors and ended and len(phases) == len(ROSTER) + 2 and all(row['passed'] for row in phases)
|
||||
context = shared.totals(rows, ROSTER)
|
||||
shared.write(out / 'runner-ended.json', dict(context, protocol='guarded-p18-v2', run_id=run_id,
|
||||
owner_runner_pid=os.getpid(), passed=passed, engine_ended=ended,
|
||||
actual_captured_PIDs=[process.pid for process in outer.OWNED], final_owned_cleanup=cleanup,
|
||||
cleanup_errors=cleanup_errors, guard_errors=guard_errors, error=error, phases=phases,
|
||||
all_tests_sha256=shared.sha(out / 'all-tests.json') if (out / 'all-tests.json').exists() else None,
|
||||
default_player_after=shared.default_player(root), formal_acceptance=False,
|
||||
original_unit_complete=False, independent_review='pending', native_Windows='pending'))
|
||||
if passed:
|
||||
seal(out, refs, engine, contract_sha)
|
||||
# Root also exercises precisely the verifier that ordinary Runner uses.
|
||||
verify(out, refs, markers, contracts, policy, contract_sha, parse_paths)
|
||||
print(json.dumps(dict(context, passed=passed, error=error, cleanup_errors=cleanup_errors, guard_errors=guard_errors)), flush=True)
|
||||
return 0 if passed else 1
|
||||
|
||||
|
||||
|
||||
# Receipt file names are always relative; absolute paths in native receipts are
|
||||
# historical identity strings only and are never opened by the verifier.
|
||||
def require(ok, reason):
|
||||
shared.require(ok, reason)
|
||||
|
||||
|
||||
def digest(value):
|
||||
return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(',', ':'),
|
||||
ensure_ascii=False).encode()).hexdigest()
|
||||
|
||||
|
||||
def content_map(refs):
|
||||
return {name: {'bytes': pin['bytes'], 'sha256': pin['sha256']}
|
||||
for name, pin in refs.items()}
|
||||
|
||||
|
||||
def plain_path(path):
|
||||
path = Path(path)
|
||||
require('..' not in path.parts, 'parent traversal refused')
|
||||
absolute = Path(os.path.abspath(path))
|
||||
for part in [absolute, *absolute.parents]:
|
||||
require(not part.is_symlink(), 'symlink path refused: ' + str(part))
|
||||
return absolute
|
||||
|
||||
|
||||
def confined(out, name):
|
||||
require(type(name) is str and name and '\\' not in name, 'ordinary relative evidence name')
|
||||
path = Path(name)
|
||||
require(not path.is_absolute() and '..' not in path.parts
|
||||
and path.as_posix() == name and name != '.', 'evidence path escape or alias')
|
||||
result = plain_path(out / path)
|
||||
require(result.is_relative_to(out), 'evidence confined to output')
|
||||
return result
|
||||
|
||||
|
||||
def inventory(out):
|
||||
result = {}
|
||||
require(out.is_dir(), 'output directory required')
|
||||
for directory, dirs, files in os.walk(out, followlinks=False):
|
||||
for name in dirs + files:
|
||||
p = Path(directory) / name
|
||||
mode = p.lstat().st_mode
|
||||
require(stat.S_ISREG(mode) or stat.S_ISDIR(mode), 'nonordinary evidence refused')
|
||||
if stat.S_ISREG(mode):
|
||||
require(p.stat().st_nlink == 1, 'hardlinked evidence refused')
|
||||
result[p.relative_to(out).as_posix()] = {
|
||||
'bytes': p.stat().st_size, 'sha256': shared.sha(p)}
|
||||
return result
|
||||
|
||||
|
||||
def unique_object(pairs):
|
||||
result = {}
|
||||
for key, value in pairs:
|
||||
require(key not in result, 'duplicate JSON key')
|
||||
result[key] = value
|
||||
return result
|
||||
|
||||
|
||||
def read_json(path):
|
||||
return json.loads(path.read_text(encoding='utf-8'), object_pairs_hook=unique_object,
|
||||
parse_constant=lambda token: require(False, 'nonfinite JSON ' + token))
|
||||
|
||||
|
||||
def archive_profiles(out, row):
|
||||
for label in ('startup', 'runtime'):
|
||||
value = row.get('whole_' + label + '_profile_after')
|
||||
if value is None:
|
||||
continue
|
||||
dest = out / 'profiles' / row['phase'] / label
|
||||
dest.mkdir(parents=True, exist_ok=False)
|
||||
source = plain_path(value['path'])
|
||||
require(shared.inventory(source) == value['files'], 'whole owned profile before archive')
|
||||
for name in value['files']:
|
||||
target = confined(out, str((dest / name).relative_to(out)))
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
shutil.copyfile(source / name, target)
|
||||
require(shared.inventory(dest) == value['files'] == shared.inventory(source),
|
||||
'whole owned profile archive exact')
|
||||
|
||||
|
||||
def seal(out, refs, engine, contract_sha):
|
||||
# Last file written: an interrupted collection has no complete receipt.
|
||||
shutil.copyfile(engine, out / 'engine.bin')
|
||||
require(shared.sha(out / 'engine.bin') == shared.sha(engine), 'engine archive exact')
|
||||
source = content_map(refs)
|
||||
shared.write(out / 'receipt.json', {
|
||||
'schema': 'guarded-p18-v2', 'source_map': source,
|
||||
'source_map_sha256': digest(source),
|
||||
'project_settings_sha256': source['project.godot']['sha256'],
|
||||
'marker_contract_sha256': contract_sha,
|
||||
'engine_sha256': shared.sha(engine),
|
||||
'files': inventory(out),
|
||||
})
|
||||
|
||||
|
||||
def cleanup_gate(value):
|
||||
require(value['owned_child_created'] is True and value['engine_ended'] is True
|
||||
and value['actual_process_exit_code'] == 0 and value['errors'] == [],
|
||||
'successful actual owned cleanup')
|
||||
attempts = value['attempts']
|
||||
require(1 <= len(attempts) <= 3, 'bounded cleanup attempts')
|
||||
for index, row in enumerate(attempts):
|
||||
require(row['attempt'] == index + 1 and row['errors'] == []
|
||||
and row['wait_timeout_seconds'] == 5 and row['wait_completed'] is True
|
||||
and row['wait_returned_code'] == 0 and row['poll_after'] == 0,
|
||||
'complete bounded owned wait')
|
||||
|
||||
|
||||
def outer_cleanup(rows, pids):
|
||||
require([r['pid'] for r in rows] == pids, 'exact captured cleanup PID order')
|
||||
for row in rows:
|
||||
require(row['engine_ended'] is True and row['outer_cleanup_errors'] == []
|
||||
and row['foreign_process_or_group_signals'] == 0
|
||||
and row['outer_maximum_helper_invocations'] == 3
|
||||
and row['helper_maximum_waits'] == 3 and row['per_wait_timeout_seconds'] == 5,
|
||||
'unchanged outer cleanup contract')
|
||||
cleanup_gate(row['cleanup'])
|
||||
|
||||
|
||||
def verify(out, refs, markers, contracts, policy, contract_sha, parse_paths):
|
||||
receipt_path = confined(out, 'receipt.json')
|
||||
require(receipt_path.is_file(), 'regular final receipt required')
|
||||
manifest = read_json(receipt_path)
|
||||
require(manifest['schema'] == 'guarded-p18-v2', 'current receipt schema required')
|
||||
files = manifest['files']
|
||||
require(type(files) is dict and files, 'complete raw manifest')
|
||||
for name, pin in files.items():
|
||||
p = confined(out, name)
|
||||
require(p.is_file() and set(pin) == {'bytes', 'sha256'}
|
||||
and type(pin['bytes']) is int and pin['bytes'] >= 0
|
||||
and re.fullmatch('[0-9a-f]{64}', pin['sha256']) is not None,
|
||||
'ordinary artifact pin')
|
||||
actual = inventory(out)
|
||||
receipt_pin = actual.pop('receipt.json')
|
||||
require(actual == files, 'complete raw file set and SHA-256 equality')
|
||||
source = content_map(refs)
|
||||
require(manifest['source_map'] == source and manifest['source_map_sha256'] == digest(source),
|
||||
'current whole source content map independent of checkout path')
|
||||
require(manifest['project_settings_sha256'] == source['project.godot']['sha256']
|
||||
and manifest['marker_contract_sha256'] == contract_sha, 'current project/marker pins')
|
||||
|
||||
def read(name):
|
||||
require(name in files, 'required raw file missing: ' + name)
|
||||
return read_json(confined(out, name))
|
||||
|
||||
def text(name):
|
||||
require(name in files, 'required raw transport missing: ' + name)
|
||||
return confined(out, name).read_text(encoding='utf-8')
|
||||
|
||||
start, end = read('runner-input.json'), read('runner-ended.json')
|
||||
require(start['protocol'] == end['protocol'] == 'guarded-p18-v2'
|
||||
and start['run_id'] == end['run_id']
|
||||
and re.fullmatch('[0-9a-f]{32}', start['run_id']) is not None,
|
||||
'same current run')
|
||||
require(type(start['owner_runner_pid']) is int and start['owner_runner_pid'] > 0
|
||||
and start['owner_runner_pid'] == end['owner_runner_pid'], 'same collector owner')
|
||||
require(start['roster'] == ROSTER and len(set(ROSTER)) == 7, 'exact seven unique tests')
|
||||
require(start['selected_source_map'] == {n: p['sha256'] for n, p in source.items()}
|
||||
and content_map(read('source-start.json')) == source, 'whole selected source pins')
|
||||
for field, name in [('runner_sha256', 'tools/run_p18_relationship_tests.py'),
|
||||
('shared_runner_sha256', 'tools/run_all_tests.py'),
|
||||
('marker_module_sha256', 'tools/strict_test_markers.py')]:
|
||||
require(start[field] == source[name]['sha256'], 'current collector/shared/marker pin')
|
||||
require(start['marker_contract_sha256'] == contract_sha, 'marker contract pin')
|
||||
# Resolve only the locally configured launcher, never the receipt's engine path.
|
||||
engine = shutil.which('godot')
|
||||
require(engine and shared.sha(engine) == start['engine_sha256']
|
||||
== manifest['engine_sha256'] == files['engine.bin']['sha256'],
|
||||
'current native engine and retained bytes pinned')
|
||||
require(read('parse-paths.json') == parse_paths and len(parse_paths) == 308,
|
||||
'all 308 exact source parse paths')
|
||||
require(end['passed'] is True and end['engine_ended'] is True and end['error'] is None
|
||||
and end['cleanup_errors'] == [] and end['guard_errors'] == [],
|
||||
'finished successful collection without guard/cleanup error')
|
||||
for receipt in (start, end):
|
||||
require(receipt['formal_acceptance'] is False and receipt['original_unit_complete'] is False,
|
||||
'backend evidence never completes original unit')
|
||||
before = start['default_player_before']
|
||||
require(before == end['default_player_after'] and before['logs_and_locks_included'] is True
|
||||
and type(before['existed']) is bool and type(before['files']) is dict,
|
||||
'complete default player before/after equality')
|
||||
for name, pin in before['files'].items():
|
||||
confined(out, name) # Validate the inventory name; never open the player.
|
||||
require(set(pin) == {'bytes', 'sha256'} and type(pin['bytes']) is int
|
||||
and pin['bytes'] >= 0 and re.fullmatch('[0-9a-f]{64}', pin['sha256']),
|
||||
'whole default player file pin')
|
||||
require(before['existed'] or before['files'] == {}, 'absent player has no files')
|
||||
|
||||
native = shared.module('p18_verify_native', shared.SUPPORT / 'owned_diagnostic_process.py')
|
||||
diagnostics = shared.module('p18_verify_diagnostics', shared.SUPPORT / 'diagnostic_gate.py')
|
||||
owners = shared.module('p18_verify_owners', shared.SUPPORT / 'ordinary_proof_gate.py')
|
||||
# Helpers are loaded for their pure gates only. No run/probe/cleanup is called.
|
||||
origin = Path(start['stage']).parent
|
||||
require(Path(start['stage']) == origin / 'stage' and origin.is_absolute()
|
||||
and '..' not in origin.parts, 'original output identity')
|
||||
|
||||
def relocated(value):
|
||||
if isinstance(value, dict):
|
||||
return {relocated(k): relocated(v) for k, v in value.items()}
|
||||
if isinstance(value, list):
|
||||
return [relocated(v) for v in value]
|
||||
if isinstance(value, str) and value.startswith(str(origin) + '/'):
|
||||
return str(confined(out, value[len(str(origin)) + 1:]))
|
||||
return value
|
||||
|
||||
def proof_read(path):
|
||||
path = plain_path(path)
|
||||
require(path.is_relative_to(out), 'proof path stays in output')
|
||||
return relocated(read(path.relative_to(out).as_posix()))
|
||||
|
||||
owners.read = proof_read
|
||||
phases = end['phases']
|
||||
require(len(phases) == 9, 'exact nine phases')
|
||||
tests = read('all-tests.json')
|
||||
require(len(tests) == 7 and end['all_tests_sha256'] == files['all-tests.json']['sha256'],
|
||||
'complete test rows')
|
||||
pids = []
|
||||
for index, (phase, test) in enumerate([('import', None), ('parse', None)]
|
||||
+ [(str(i).zfill(3), n) for i, n in enumerate(ROSTER)]):
|
||||
row = read(phase + '-receipt.json')
|
||||
expected_row = dict(row)
|
||||
if test:
|
||||
expected_row.update(sequence=index - 2, godot=start['engine'])
|
||||
require(tests[index - 2] == expected_row, 'test row matches raw phase receipt')
|
||||
require(phases[index] == expected_row and row['phase'] == phase and row['test'] == test
|
||||
and row['passed'] is True and row['failed'] is False
|
||||
and row['validation_error'] is None and not row.get('guard_error')
|
||||
and row['default_player_entire_profile_unchanged'] is True,
|
||||
'exact successful phase')
|
||||
pid = row['actual_pid']
|
||||
require(type(pid) is int and pid > 0 and pid not in pids, 'nine distinct actual PIDs')
|
||||
pids.append(pid)
|
||||
process = read(phase + '/process.json')
|
||||
require(process == row['native_process'] and process['pid'] == pid
|
||||
and process['owned_child_process_helper_sha256'] == native.HELPER_SHA
|
||||
== source['tools/regression/p09_owned_engine_process.py']['sha256'],
|
||||
'actual phase/process/helper agreement')
|
||||
stdout, stderr, logger = (text(phase + '/' + n) for n in
|
||||
('stdout.log', 'stderr.log', 'engine-native.log'))
|
||||
raw = stdout + stderr
|
||||
require(text(row['log']) == raw and row['log_sha256'] == files[row['log']]['sha256'],
|
||||
'literal complete raw stream')
|
||||
require(process['stdout_sha256'] == files[phase + '/stdout.log']['sha256']
|
||||
and process['stderr_sha256'] == files[phase + '/stderr.log']['sha256'],
|
||||
'process transport SHA')
|
||||
require(row['raw_native_log'] == dict(files[phase + '/engine-native.log'],
|
||||
path=str(origin / phase / 'engine-native.log')), 'native logger pin')
|
||||
review = diagnostics.review_streams(native, {
|
||||
'stdout': stdout, 'stderr': stderr, 'native_file': logger}, test)
|
||||
require(row['finite_original_diagnostic_review'] == review
|
||||
and diagnostics.diagnostic_result_gate(process, review)
|
||||
and shared.process_gate(process, review['allowed_e31_error_lines']),
|
||||
'strict diagnostics/process gates')
|
||||
require(native.native_diagnostics(stdout, stderr, row['command'])
|
||||
== process['strict_native_diagnostics'], 'raw banner/diagnostics recomputed')
|
||||
command = [start['engine'], '--headless', '--path', start['stage']]
|
||||
if phase == 'import':
|
||||
command += ['--editor', '--import', '--quit', '--verbose']
|
||||
else:
|
||||
script = ('bootstrap/parse_full_dependencies.gd' if phase == 'parse'
|
||||
else 'starters/' + phase + '.gd')
|
||||
command += ['--script', str(origin / script), '--verbose']
|
||||
require(row['starter_sha256'] == files[script]['sha256'], 'exact starter pin')
|
||||
if test:
|
||||
expected_starter = ('extends ' + json.dumps('res://' + test) + '\nconst Guard := preload('
|
||||
+ json.dumps(str(origin / 'bootstrap/profile_guard.gd'))
|
||||
+ ')\nfunc _initialize() -> void:\n\tif not Guard.activate():\n\t\tquit(97)\n\t\treturn\n\tsuper._initialize()\n')
|
||||
require(text(script) == expected_starter, 'unchanged guarded starter bytes')
|
||||
command += ['--log-file', str(origin / phase / 'engine-native.log')]
|
||||
require(row['command'] == process['argv'] == command, 'exact native argv/logger')
|
||||
for filename, field, event in [('started.json', 'actual_start_binding', 'ENGINE_STARTED'),
|
||||
('ended.json', 'actual_end_binding', 'ENGINE_ENDED')]:
|
||||
binding = read(phase + '/' + filename)
|
||||
require(binding == process[field] and binding['event'] == event
|
||||
and binding['actual_pid'] == binding['pid'] == pid
|
||||
and binding['owner_pid'] == start['owner_runner_pid']
|
||||
and binding['command'] == binding['argv'] == command, 'actual START/END ownership')
|
||||
binding = process['actual_start_binding']
|
||||
identity = binding['current_process_identity']
|
||||
if identity is None:
|
||||
require(binding['tracked_child_ended_before_initial_probe'] is True, 'early ended tracked child')
|
||||
else:
|
||||
require(binding['live_identity_exact'] is True and identity == {
|
||||
'pid': pid, 'ppid': start['owner_runner_pid'], 'pgid': pid, 'args': ' '.join(command)},
|
||||
'recorded live child PID/PPID/PGID/argv')
|
||||
finish = process['actual_end_binding']
|
||||
require(finish['engine_ended'] is True and finish['timed_out'] is False
|
||||
and finish['lifecycle_error'] is None and finish['exit_code'] == 0
|
||||
and finish['actual_process_exit_code'] == 0
|
||||
and finish['start_receipt_written'] is True
|
||||
and finish['monotonic_ns'] >= binding['monotonic_ns'], 'complete native END')
|
||||
cleanup = read(phase + '/adapter-owned-cleanup.json')
|
||||
require(cleanup == process['adapter_owned_cleanup'], 'raw adapter cleanup')
|
||||
cleanup_gate(cleanup)
|
||||
capture = row['outer_actual_capture']
|
||||
require(read(phase + '/outer-owned-finally.json') == {
|
||||
k: v for k, v in capture.items()
|
||||
if k not in ('outer_receipt_written', 'outer_receipt_error', 'passed')},
|
||||
'whole raw outer receipt')
|
||||
require(capture['actual_captured_pids'] == [pid] and capture['passed'] is True
|
||||
and capture['all_captured_ended'] is True and capture['adapter_exception'] is None
|
||||
and capture['outer_cleanup_errors'] == [] and capture['outer_receipt_error'] is None
|
||||
and capture['outer_receipt_written'] is True
|
||||
and capture['all_cleanup_before_outer_receipt'] is True
|
||||
and capture['foreign_process_or_group_signals'] == 0
|
||||
and row['engine_ended'] is True and row['exit_code'] == 0, 'owned outer capture')
|
||||
outer_cleanup(capture['cleanup'], [pid])
|
||||
startup = read(phase + '-startup-profile-before.json')
|
||||
require(startup == {'path': row['whole_startup_profile_after']['path'], 'existed': False,
|
||||
'files': {}, 'before_native_spawn': True}, 'fresh startup profile')
|
||||
require(row['whole_startup_profile_after']['fresh_before_engine'] is True,
|
||||
'startup fresh before engine')
|
||||
name = row['profile_startup_name']
|
||||
require(re.fullmatch('TheTree-PCK-tests-[0-9a-f]{32}-standard-startup-' + phase, name)
|
||||
and Path(startup['path']).name == name and row['private_project_fields'] == 2
|
||||
and row['private_project_sha256'] == hashlib.sha256(shared.private_project(
|
||||
(shared.HERE.parent / 'project.godot').read_bytes(), name)).hexdigest(),
|
||||
'exact two-field startup isolation')
|
||||
for label in ('startup', 'runtime'):
|
||||
if label == 'runtime' and phase == 'import':
|
||||
continue
|
||||
whole = row['whole_' + label + '_profile_after']
|
||||
archive = confined(out, 'profiles/' + phase + '/' + label)
|
||||
require(archive.is_dir() and shared.inventory(archive)
|
||||
== whole['files'], 'complete retained private profile')
|
||||
if phase != 'import':
|
||||
guard = read(phase + '-profile.json')
|
||||
runtime = Path(row['whole_runtime_profile_after']['path'])
|
||||
name = guard['custom_user_dir_name']
|
||||
require(re.fullmatch('TheTree-PCK-tests-[0-9a-f]{32}-standard-runtime-' + phase, name)
|
||||
and runtime.name == name and guard['verified'] is True
|
||||
and guard['conditions'] == [True] * 5 and guard['conditions_checked'] == 5
|
||||
and guard['fresh_before_parent_initialize'] is True
|
||||
and guard['profile_writes_before_guard'] == 0
|
||||
and guard['actual_user_data_dir'] == guard['expected_user_data_dir'] == str(runtime)
|
||||
and guard['globalized_probe'] == str(runtime / 'guard-probe')
|
||||
and guard['project_settings_persisted'] is False, 'all unchanged Guard conditions')
|
||||
require(row['actual_private_profile'] == {
|
||||
'report': guard, 'report_sha256': files[phase + '-profile.json']['sha256'],
|
||||
'whole_files': row['whole_runtime_profile_after']['files']}, 'whole raw Guard report')
|
||||
require(row['controlled_environment'] == {
|
||||
'THE_TREE_PACK_PROFILE_NAME': name, 'THE_TREE_PACK_PROFILE_EXPECTED': str(runtime),
|
||||
'THE_TREE_PACK_PROFILE_REPORT': str(origin / (phase + '-profile.json')),
|
||||
'THE_TREE_FULL_PARSE_PATHS': str(origin / 'parse-paths.json'),
|
||||
**({'THE_TREE_AUDIO_TEARDOWN_PROOF_DIR': str(origin / (phase + '-teardown/owned-audio')),
|
||||
'THE_TREE_AUDIO_FIXTURE_CONTROL_PROOF': str(origin / (phase + '-teardown/control.json'))}
|
||||
if test and policy['suite_policies'].get(test, {}).get('ordinary_cleanup_prepared') else {})},
|
||||
'exact controlled Guard/proof environment')
|
||||
else:
|
||||
require(row['controlled_environment'] == {}, 'fresh import environment')
|
||||
if phase == 'parse':
|
||||
require(re.findall(r'(?m)^FULL_DEPENDENCY_PARSE checks=([0-9]+) failures=([0-9]+)\n', raw)
|
||||
== [('308', '0')] and row['actual_parse_checks'] == 308, 'unique all-script parse marker')
|
||||
if test:
|
||||
parsed = markers.parse_raw(test, raw, contracts, source[test]['sha256'])
|
||||
require(parsed['passed'] and row['completion'] == parsed
|
||||
and row['reported_checks'] == parsed['checks']
|
||||
and row['reported_failures'] == parsed['failures']
|
||||
and row['completion_marker'] == parsed['marker'] and row['collector_errors'] == [],
|
||||
'source-pinned raw completion marker')
|
||||
require(row['source_sha256'] == row['source_sha256_end'] == source[test]['sha256'],
|
||||
'exact test source before/after')
|
||||
p = shared.phase_policy(test, Path(refs[test]['path']), policy['suite_policies'])
|
||||
require(row['policy'] == p, 'current exact suite policy')
|
||||
if p['ordinary_cleanup_prepared']:
|
||||
proof = owners.ordinary_gate(confined(out, phase + '-teardown'), pid, out,
|
||||
p['ordinary_control_labels'])
|
||||
require(proof == relocated(row['ordinary_owner_pairs']), 'full ordinary/audio ownership proof')
|
||||
require(row['generated_reports'] == {}, 'fixed narrow roster has no generated source reports')
|
||||
require(end['actual_captured_PIDs'] == pids, 'all nine captured engines')
|
||||
outer_cleanup(end['final_owned_cleanup'], pids)
|
||||
require(all(end[k] == v for k, v in shared.totals(tests, ROSTER).items()), 'recomputed exact totals')
|
||||
require(shared.inventory(confined(out, 'stage'), stage=True) == source, 'entire retained source/settings exact')
|
||||
for name, pin in shared.read(shared.SUPPORT / 'bootstrap-scripts.json').items():
|
||||
require(text('bootstrap/' + name).encode() == pin['text'].encode()
|
||||
and files['bootstrap/' + name]['sha256'] == pin['sha256'], 'unchanged bootstrap/Guard pins')
|
||||
require(inventory(out) == dict(files, **{'receipt.json': receipt_pin}),
|
||||
'whole raw evidence unchanged during verification')
|
||||
require(content_map(shared.source_refs(shared.HERE.parent)) == source,
|
||||
'whole current source unchanged during verification')
|
||||
print(json.dumps({'verified': True, 'actual_suites': 7, 'parse_checks': 308,
|
||||
'actual_checks': end['actual_all_roster_checks'], 'engines_started': 0,
|
||||
'formal_acceptance': False, 'original_unit_complete': False}))
|
||||
return 0
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
argv = list(sys.argv[1:] if argv is None else argv)
|
||||
# No argparse abbreviation, repeated flags, = aliases or positional tokens.
|
||||
parser = argparse.ArgumentParser(description=__doc__, allow_abbrev=False)
|
||||
parser.add_argument('--output', required=True)
|
||||
modes = parser.add_mutually_exclusive_group()
|
||||
modes.add_argument('--collect', action='store_true', help='Root only; fresh native collection')
|
||||
modes.add_argument('--prepare-only', action='store_true')
|
||||
seen = set()
|
||||
i = 0
|
||||
while i < len(argv):
|
||||
flag = argv[i]
|
||||
require(flag in ('--output', '--collect', '--prepare-only', '--help')
|
||||
and flag not in seen, 'unknown, duplicate or malformed flag')
|
||||
seen.add(flag)
|
||||
if flag == '--output':
|
||||
i += 1
|
||||
require(i < len(argv) and argv[i] and not argv[i].startswith('--'), 'output value required')
|
||||
i += 1
|
||||
args = parser.parse_args(argv)
|
||||
args.timeout = 1200
|
||||
root = shared.HERE.parent
|
||||
out = plain_path(args.output)
|
||||
refs = shared.source_refs(root)
|
||||
require(set(ROSTER).issubset(shared.roster(root)), 'normal discovery includes narrow roster')
|
||||
markers = shared.module('p18_exact_markers', shared.HERE / 'strict_test_markers.py')
|
||||
contract_path = root / 'docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json'
|
||||
contract_sha = shared.sha(contract_path)
|
||||
contracts = markers.load_contracts(contract_path)
|
||||
require(all(name in contracts for name in ROSTER), 'complete marker roster')
|
||||
policy = shared.read(shared.SUPPORT / 'suite-policy.json')
|
||||
shared.policy_coverage(ROSTER, refs, policy)
|
||||
for test in ROSTER:
|
||||
shared.phase_policy(test, Path(refs[test]['path']), policy['suite_policies'])
|
||||
for test in ROSTER[:2]:
|
||||
require(contracts[test]['source_sha256_at_schema_audit'] == refs[test]['sha256'],
|
||||
'new strict source-hashed marker')
|
||||
parse_paths = ['res://' + name for name in sorted(refs) if name.endswith('.gd')]
|
||||
require(len(parse_paths) == 308, 'exact expected parse count')
|
||||
if args.prepare_only:
|
||||
ancestor = out.parent
|
||||
while not ancestor.exists():
|
||||
ancestor = ancestor.parent
|
||||
free = shutil.disk_usage(ancestor).free
|
||||
size = sum(p['bytes'] for p in refs.values())
|
||||
print(json.dumps({'roster': ROSTER, 'source_files': len(refs), 'source_bytes': size,
|
||||
'free_bytes': free, 'conservative_required_bytes': size + shared.MIN_SPACE,
|
||||
'capacity_available': free >= size + shared.MIN_SPACE, 'parse_paths': 308,
|
||||
'future_native_phases': 9, 'actual_checks': None, 'engines': 0, 'stages': 0,
|
||||
'formal_acceptance': False}))
|
||||
return 0
|
||||
if args.collect:
|
||||
require(not out.exists() and out.parent.is_dir(), 'fresh output with existing parent required')
|
||||
require(not out.is_relative_to(root), 'private collection outside source tree')
|
||||
return collect(args, root, out, refs, markers, contracts, policy,
|
||||
contract_path, contract_sha, parse_paths)
|
||||
return verify(out, refs, markers, contracts, policy, contract_sha, parse_paths)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
raise SystemExit(main())
|
||||
except (AssertionError, OSError, ValueError, KeyError, TypeError) as error:
|
||||
print(type(error).__name__ + ': ' + str(error), file=sys.stderr)
|
||||
raise SystemExit(1)
|
||||
Reference in New Issue
Block a user