#!/usr/bin/env python3 """Offline capture of one explicitly selected UTF-8 deliverable, unchanged. Development tooling: no discovery, filtering, model calls, or endpoint inference. """ import argparse from datetime import datetime, timezone import os from pathlib import Path import sys import tempfile BASE = Path(__file__).resolve().parent sys.path.insert(0, str(BASE.parent/"run-sealing")) import seal_runs as archive NOTICE = "Development text-capture tooling; byte validation does not establish semantic purity or task completion." def identity_text(value, label): archive.require(isinstance(value, str) and bool(value) and value == value.strip(), label+": expected nonempty identity without surrounding whitespace") archive.require(not any(ord(c) < 32 or ord(c) == 127 or c in "\u2028\u2029" for c in value), label+": control characters/line separators are invalid") value.encode("utf-8") return value def new_directory(path): path = Path(path).absolute() archive.require(not os.path.lexists(path), "refusing existing output destination: "+str(path)) archive.require(path.parent.is_dir(), "output parent must already exist") return path.resolve() def publish_record(directory, content): """Publish only a complete verified record, atomically and without overwrite.""" pending = None try: with tempfile.NamedTemporaryFile(prefix=".pending-text-capture-", dir=directory, delete=False) as handle: pending = Path(handle.name) handle.write(content) handle.flush() os.fsync(handle.fileno()) archive.require(pending.read_bytes() == content, "capture record staging validation failed") os.link(pending, directory/"capture-record.json") finally: if pending is not None: try: pending.unlink() except OSError: pass # A leftover pending file is not a published success record. def capture(source, artifact_dir, record_dir, *, run_id, condition_id, task_id, repetition_id, turn, artifact_id, expected_source_sha256=None): identity = {key: identity_text(value, key) for key, value in dict( run_id=run_id, condition_id=condition_id, task_id=task_id, repetition_id=repetition_id, artifact_id=artifact_id).items()} archive.require(type(turn) is int and turn >= 1, "turn must be a positive integer, not a boolean") identity["turn"] = turn artifact_dir, record_dir = new_directory(artifact_dir), new_directory(record_dir) archive.require(artifact_dir != record_dir and artifact_dir not in record_dir.parents and record_dir not in artifact_dir.parents, "artifact and coordinator-record directories must be disjoint") source = Path(source).resolve() content = archive.read_source(source, expected_source_sha256) content.decode("utf-8") # Validate only; never re-encode/normalize the file. source_hash = archive.sha(content) artifact_dir.mkdir() record_dir.mkdir() artifact_path = artifact_dir/"artifact.txt" archive.write_bytes(artifact_path, content) captured = artifact_path.read_bytes() captured_hash = archive.sha(captured) archive.require(captured == content and captured_hash == source_hash, "captured bytes/hash validation failed") record = dict(capture_record_version="1.0", notice=NOTICE, coordinator_only=True, defaults_unfrozen=True, capture_complete=True, captured_at_utc=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), identity=identity, source=dict(path=str(source), sha256=source_hash, bytes=len(content)), captured_artifact=dict(path=str(artifact_path), sha256=captured_hash, bytes=len(captured)), selection_policy="explicit caller-designated deliverable; no stripping or discovery", semantic_purity_verified=False, final_endpoint_selected=False, observation_artifact=dict(artifact_id=artifact_id, sequence=turn, path=str(artifact_path), sha256=captured_hash), sealing_record=dict(record_id=artifact_id, kind="artifact", path=str(artifact_path), sha256=captured_hash)) publish_record(record_dir, archive.json_bytes(record)) return dict(capture_tool_version="1.0", notice=NOTICE, artifact=str(artifact_path), coordinator_record=str(record_dir/"capture-record.json"), captured_sha256=captured_hash, capture_complete=True, semantic_purity_verified=False, final_endpoint_selected=False) def main(argv=None): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--source", type=Path, required=True) parser.add_argument("--artifact-dir", type=Path, required=True) parser.add_argument("--record-dir", type=Path, required=True) for name in ("run-id", "condition-id", "task-id", "repetition-id", "artifact-id"): parser.add_argument("--"+name, required=True) parser.add_argument("--turn", type=int, required=True) parser.add_argument("--expected-source-sha256") args = parser.parse_args(argv) try: result = capture(args.source, args.artifact_dir, args.record_dir, run_id=args.run_id, condition_id=args.condition_id, task_id=args.task_id, repetition_id=args.repetition_id, turn=args.turn, artifact_id=args.artifact_id, expected_source_sha256=args.expected_source_sha256) except KeyboardInterrupt: print(archive.json_bytes(dict(error="interrupted; require a complete capture-record.json before use", notice=NOTICE)).decode(), file=sys.stderr, end="") return 130 except (archive.ValidationError, OSError, KeyError, TypeError, ValueError) as exc: print(archive.json_bytes(dict(error=str(exc), notice=NOTICE)).decode(), file=sys.stderr, end="") return 2 print(archive.json_bytes(result).decode(), end="") return 0 if __name__ == "__main__": sys.exit(main())