# Project export: Timeless Harness This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small. ## Project metadata - Hackathon: OpenAI Build Week - Tagline: An evidence-led governor that tests reusable Agent workflows against a native baseline and returns a provisional keep, narrow, revise, retire, or unresolved decision. - Devpost: https://devpost.com/software/timeless-harness - GitHub: https://github.com/FuturizeRush/timeless-harness - Demo: https://github.com/FuturizeRush/timeless-harness/tree/v0.1.0 - Video: https://www.youtube.com/embed/VQUjLRVNDlc?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent - Team: 1 GitHub contributor(s) — FuturizeRush (1 commits) ## Devpost submission (written by the team) ### Inspiration Modern coding Agents are already capable. They plan, use tools, test, review, and repair their work. A reusable workflow can help, but it can also slow the model down, create rituals, and introduce new mistakes. Timeless Harness began as a broad method for improving every Agent task. Its own evaluation contradicted that idea. The older wrapper won fewer recorded pair preferences than the native condition and added unnecessary process. I chose to remove the failed design instead of protecting it. That left one useful question: Does this reusable Agent workflow still earn its cost? ### What it does Timeless Harness governs Skills, instructions, memory rules, evaluators, and repair methods. It does not wrap ordinary work. It has two parts: A small Skill gives an Agent a lifecycle policy: keep, narrow, revise, retire, or unresolved. A Python Governor makes native-versus-workflow comparisons inspectable. The Governor can: freeze the task, Skill, rubric, starting workspace, evaluator, and cost rule before outputs exist; run a native baseline and workflow treatment with the same model settings; keep the two executions in separate random temporary roots; hash captures, telemetry, final workspaces, file contents, and file modes, then detect later changes; reject missing telemetry, non-finite cost rules, sensitive workspace files, and unsupported sandbox access; prepare a condition-label-blind packet containing answers, artifact manifests, and optional evaluator results; combine reviewer quality with tokens and wall time; return a clearly labeled provisional lifecycle candidate. A single pair is never presented as proof. Final decisions require repeated representative cases and a stopping rule chosen before seeing results. The self-audit The public repository includes the complete evidence that caused Timeless to retire its first design: 4 fixed tasks; 12 paired trials; 24 outputs with opaque IDs; 72 rubric score rows; 36 recorded pair preferences from three grader result sets; grader notes, revealed mapping, and SHA-256 checksums. Anyone can run one zero-credit command to verify 44 files and recompute the result: The recurring failure was concrete. The old wrapper added an arbitrary three-pass release ritual without improving the answer. That result removed routine invocation, fixed process stages, persistent workspace ceremony, and general superiority claims. The evidence supports retiring the tested old wrapper. It does not prove that the new narrow Governor improves unseen tasks. That claim remains unresolved and is stated plainly in the product. How I built it The Governor uses only the Python standard library. The judge path makes no model call and needs no credentials. Codex was the main engineering environment. I used it to reverse the submission requirements into acceptance checks, implement the Governor, test failures, inspect the recovered raw evaluation package, audit privacy, simplify the repository, and keep the README, Skill, CLI, evidence, and submission story consistent. GPT-5.6 Sol with ultra reasoning was used through Codex for implementation, adversarial review, evidence analysis, security review, and product critique. Separate fresh-context review passes found real defects, including a NaN cost-policy bypass, mutable run evidence, incomplete workspace hashing, weak condition separation, and a misleading synthetic Demo. Those defects were repaired, covered by tests, or removed. The human author set the product goal, privacy boundary, evaluation policy, and final release decision. Challenges The first challenge was resisting the urge to make a philosophy look like a product. The useful part had to change a real decision. The second was using a strong baseline. Timeless should not win because the native Agent was artificially restricted. The prospective runner therefore fixes the model settings and starting artifacts, while the treatment changes only the reusable Skill. The third was keeping the evaluation honest. Hashes are not signatures. Separate temporary roots are not operating-system isolation. A blind grader can still be wrong. The repository states these limits instead of turning risk reduction into a security claim. The fourth was allowing deletion to count as progress. The best feature of the first prototype was the evidence that showed it should not survive. What I learned A workflow should not survive because it sounds wise, took effort to create, or makes an Agent look busy. As models improve, instruction debt becomes a product problem. Every reusable rule should have a claim, evidence, scope, cost, and retirement condition. Timeless Harness does not promise to make every Agent smarter. It makes the outer workflow earn the right to stay. A tie with more process is a loss. ## README (from the GitHub repository) # Timeless Harness [English](README.md) | [繁體中文](README.zh-TW.md) > An evidence-led governor for reusable Agent workflows. ![Timeless Harness](assets/timeless-harness-thumbnail.png) Modern Agents already plan, code, research, test, and review well. Adding a workflow can improve them. It can also slow them down, create rituals, and introduce new mistakes. Timeless Harness asks one question: **Does this reusable Agent workflow still earn its cost?** It governs Skills, instructions, memory rules, evaluators, and repair methods. It does not wrap ordinary work. The native Agent works first. Timeless is used only when the reusable method itself needs review. ## The product in one minute Timeless has two parts: - [`SKILL.md`](SKILL.md) gives an Agent a small lifecycle policy: `keep | narrow | revise | retire | unresolved`. - [`tools/harness_governor.py`](tools/harness_governor.py) creates a matched native-versus-workflow screen, seals the evidence, prepares a blind review, measures cost, and returns a provisional lifecycle candidate. ```text Reusable workflow makes a claim | freeze task, rubric, workspace, model, and cost rule | run native baseline and workflow treatment separately | blind review final answers, artifact manifests, and evaluator results | combine quality with tokens and time | keep | narrow | revise | retire | unresolved ``` A single pair is only a screen. It is not proof. A final lifecycle decision needs repeated representative cases and a stopping rule chosen before results are seen. ## Proof through self-correction The first Timeless prototype wrapped routine Agent work. Its own evaluation showed that this was worse than leaving a strong model alone. The complete, privacy-safe evidence is published in [`examples/self-audit`](examples/self-audit). It includes 4 tasks, 24 opaque outputs, 72 score rows, 36 blind preferences, grader notes, the revealed mapping, and checksums. Recompute it without an API key, network access, or model credits: ```bash RESULT="$(mktemp -d)/timeless-self-audit" python3 tools/harness_governor.py self-audit \ --evidence examples/self-audit \ --output "$RESULT" ``` Expected output: ```text EVIDENCE: VERIFIED 44 FILES PREFERENCES: NATIVE 19 | TIMELESS 6 | TIES 11 MEAN SCORE: NATIVE 3.991 | TIMELESS 3.889 FATAL OMISSIONS: NATIVE 0 | TIMELESS 0 UNNECESSARY PROCESS: NATIVE 0 | TIMELESS 9 DECISION: RETIRE TESTED GENERAL WRAPPER CURRENT GOVERNOR: UNRESOLVED ``` The recurring failure was concrete. The old wrapper added an arbitrary three-pass release ritual without improving the answer. Timeless therefore removed routine invocation, fixed process stages, persistent workspace ceremony, and general superiority claims. This proves that the evidence can reproduce the decision to retire the tested old wrapper. It does not prove that the new narrow Governor is better. That claim remains unresolved. See [`EVALUATION.md`](EVALUATION.md). Timeless did not discard truth-seeking, causal repair, whole-artifact finishing, or learning. It changed their role. They remain optional depth for disputed evidence, repeated failure, and durable learning decisions instead of becoming mandatory ceremony around every task. The Governor keeps those reusable rules accountable to observed value and cost. ## Why this is not another workflow pack | Product | Main job | | --- | --- | | Codex or Claude Code | Do the task | | Workflow packs such as Superpowers | Add reusable ways to do tasks | | Eval frameworks | Measure outputs | | Timeless Harness | Govern whether a reusable workflow should survive, change, or be removed | Timeless can use an evaluator, but it is not an eval framework. Its concern is the lifecycle of instruction debt around an increasingly capable Agent. ## Judge test path Requirements: Git and Python 3.10 or newer. The self-audit and test suite use only the Python standard library. ```bash git clone --branch v0.1.0 --depth 1 \ https://github.com/FuturizeRush/timeless-harness.git cd timeless-harness RESULT="$(mktemp -d)/timeless-self-audit" python3 tools/harness_governor.py self-audit \ --evidence examples/self-audit \ --output "$RESULT" python3 -m unittest discover -s tests -v ``` This path makes no model call and needs no credentials. ## Install the Skill Both commands install the pinned `v0.1.0` release and refuse to overwrite an existing destination. ### Codex ```bash ( set -eu VERSION=v0.1.0 DEST="${CODEX_HOME:-$HOME/.codex}/skills/timeless-harness" [ ! -e "$DEST" ] || { printf 'Refusing to overwrite: %s\n' "$DEST" >&2; exit 1; } mkdir -p "$(dirname "$DEST")" trap 'rm -rf "$DEST"' EXIT HUP INT TERM git clone --filter=blob:none --no-checkout \ https://github.com/FuturizeRush/timeless-harness.git "$DEST" git -C "$DEST" checkout --quiet --detach "$VERSION^{commit}" trap - EXIT HUP INT TERM ) ``` Start a new Codex session, then say: ```text Use $timeless-harness to review whether this reusable workflow should be kept, narrowed, revised, or retired. ``` ### Claude Code ```bash ( set -eu VERSION=v0.1.0 DEST="$HOME/.claude/skills/timeless-harness" [ ! -e "$DEST" ] || { printf 'Refusing to overwrite: %s\n' "$DEST" >&2; exit 1; } mkdir -p "$(dirname "$DEST")" trap 'rm -rf "$DEST"' EXIT HUP INT TERM git clone --filter=blob:none --no-checkout \ https://github.com/FuturizeRush/timeless-harness.git "$DEST" git -C "$DEST" checkout --quiet --detach "$VERSION^{commit}" trap - EXIT HUP INT TERM ) ``` Start a new Claude Code session, then invoke: ```text /timeless-harness Review whether this reusable workflow should be kept, narrowed, revised, or retired. ``` Review any third-party Skill before consequential use. ## Run a prospective screen with Codex The live path is optional. It spends two Codex runs. Use only trusted local inputs. Prepare a task, the Skill under review, a rubric, and one starting workspace: ```bash python3 tools/harness_governor.py prepare \ --task /path/to/TASK.md \ --skill /path/to/SKILL.md \ --rubric /path/to/RUBRIC.md \ --source /path/to/start-workspace \ --output /tmp/timeless-experiment \ --max-cost-ratio 1.25 ``` An optional trusted executable can evaluate each final workspace: ```text --evaluator /path/to/read-only-evaluator ``` The evaluator receives the candidate workspace as its current directory. If it changes the workspace, the run fails. Run the matched pair: ```bash python3 tools/harness_governor.py run \ --experiment /tmp/timeless-experiment \ --model gpt-5.6-sol \ --reasoning ultra \ --sandbox workspace-write \ --run-id screen-1 \ --allow-live ``` Prepare the blind packet: ```bash python3 tools/harness_governor.py blind \ --experiment /tmp/timeless-experiment \ --run-id screen-1 ``` Give only `runs/screen-1/grader/` to a reviewer. Keep `private/` hidden. After the reviewer completes a verdict JSON: ```bash python3 tools/harness_governor.py decide \ --experiment /tmp/timeless-experiment \ --run-id screen-1 \ --verdict /path/to/verdict.json ``` The terminal labels the result `PROVISIONAL SCREEN` and `CANDIDATE`. It never presents one pair as a final lifecycle verdict. ## Safety and evidence limits - Live calls require `--allow-live`, so the tool cannot spend credits silently. - `danger-full-access` is rejected. - Common credential files such as `.env`, auth files, and private keys are rejected before the workspace is copied. - Conditions run in separate random temporary roots. The first root is removed before the second exists. This reduces accidental cross-condition reading but is not an operating-system isolation guarantee. - Final workspaces, captures, telemetry, and file modes are hash-sealed. The tool detects later mismatches. These hashes are not signatures and do not prove who produced the evidence. - External evaluators receive a detached candidate copy, no Codex authentication, and no candida [README truncated for size] ## Detected evidence (automated analysis) Indexed codebase: 50 recognized source files, 212 KB. - Python (language) — detected in the code ## Codebase structure (from repository index) ### Files (60 of 60) ``` .github/ISSUE_TEMPLATE/agent-field-report.yml .gitignore agents/openai.yaml CHANGELOG.md docs/PHILOSOPHY.md EVALUATION.md examples/self-audit/cases/incident.md examples/self-audit/cases/polish.md examples/self-audit/cases/quick.md examples/self-audit/cases/research.md examples/self-audit/graders/grader-manifest-1.md examples/self-audit/graders/grader-manifest-2.md examples/self-audit/graders/grader-manifest-3.md examples/self-audit/grades/g1-notes.md examples/self-audit/grades/g1-scores.csv examples/self-audit/grades/g1-winners.csv examples/self-audit/grades/g2-notes.md examples/self-audit/grades/g2-scores.csv examples/self-audit/grades/g2-winners.csv examples/self-audit/grades/g3-notes.md examples/self-audit/grades/g3-scores.csv examples/self-audit/grades/g3-winners.csv examples/self-audit/manifest.json examples/self-audit/mapping.md examples/self-audit/outputs/a5r6.md examples/self-audit/outputs/b8p3.md examples/self-audit/outputs/c8q1.md examples/self-audit/outputs/d2k7.md examples/self-audit/outputs/e6t1.md examples/self-audit/outputs/f6w1.md examples/self-audit/outputs/g7y2.md examples/self-audit/outputs/h4x6.md examples/self-audit/outputs/i4s6.md examples/self-audit/outputs/j9f4.md examples/self-audit/outputs/k8m4.md examples/self-audit/outputs/m2v9.md examples/self-audit/outputs/n4u9.md examples/self-audit/outputs/o2h9.md examples/self-audit/outputs/p5n0.md examples/self-audit/outputs/q2j9.md examples/self-audit/outputs/r7k3.md examples/self-audit/outputs/s1e5.md examples/self-audit/outputs/t9b2.md examples/self-audit/outputs/u7q5.md examples/self-audit/outputs/v1c8.md examples/self-audit/outputs/w3a8.md examples/self-audit/outputs/x6l0.md examples/self-audit/outputs/z3d7.md examples/self-audit/README.md examples/self-audit/rubric.md examples/self-audit/SHA256SUMS LICENSE README.md README.zh-TW.md references/decompose-reconstruct.md references/learning-loop.md references/truth-repair.md SKILL.md tests/test_harness_governor.py tools/harness_governor.py ``` ### Dependencies No dependency index available. ### Recent commits (newest first) - Release Timeless Harness v0.1.0 ## Key source files (fetched from GitHub, selected and truncated for size) ### CHANGELOG.md ```markdown # Changelog ## 0.1.0 - 2026-07-16 - Reframed Timeless as an evidence-led governor for reusable Agent workflows rather than a wrapper for ordinary tasks. - Reduced the runtime to one lifecycle decision: keep, narrow, revise, or retire from observed outcome and cost. - Added a standard-library Governor CLI that freezes a task, Skill, rubric, starting workspace, and cost rule; runs an optional matched Codex screen; exports a condition-label-blind review packet; and records a provisional lifecycle decision. - Published the complete privacy-safe self-audit bundle: 4 cases, 24 opaque outputs, 72 score rows, 36 blind preferences, grader notes, mapping, and checksums. - Added a no-credit `self-audit` command that verifies the full bundle and recomputes the product decision from raw rows. - Removed the synthetic Demo and aggregate-only replay because neither demonstrated a real product decision. - Added sealed captures and final workspaces, mode-aware tree hashes, non-finite-number rejection, sensitive-file rejection, separate temporary execution roots, condition-blind artifact manifests, and actionable malformed-input errors. - Added an optional frozen external evaluator whose result enters blind review and which is rejected if it changes the candidate workspace. - Expanded the contract suite from 13 to 24 tests covering integrity, isolation limits, credential rejection, symlink rejection, evaluator containment, evidence completeness, strict verdicts, provisional decisions, and the complete self-audit. - Removed fixed tiers, mandatory process narration, broad checklists, and the unchanged-build three-pass ritual after formative blind review showed added burden and no outcome advantage. - Removed the unvalidated portable workspace, registries, schemas, validators, and continuity quickstart from the initial product. - Removed the unrelated event-release fixture after it proved only its own six checks, not the value of Timeless. - Added explicit matched-baseline, negative-control, cost, blinding, evaluator-integrity, and harm-reporting rules. - Disabled implicit invocation so ordinary work stays with the host Agent. - Preserved the human and engineering philosophy in `docs/PHILOSOPHY.md` without loading it into Agent runtime. - Made exact delivered-artifact inspection explicit: successful generation, source checks, input hashes, and green commands are upstream evidence, not proof that the user-facing output is complete. - Added a control-design rule: when an existing instruction was bypassed, repair its trigger, acceptance gate, or observability instead of duplicating the instruction. - Updated English and Traditional Chinese documentation, Codex and Claude Code installation, GPT-5.6 usage, evidence limits, and the judge testing path. ``` ### SKILL.md ```markdown --- name: timeless-harness description: Review a reusable Agent workflow, Skill, instruction, memory, evaluator, or repair rule against observed outcomes and cost. Use after counterevidence, repeated failure, A/B oscillation, scope drift, or suspected process burden, or when the user requests a Timeless self-review. Never use it as a wrapper for ordinary task execution. --- # Timeless Harness Use Timeless only to govern reusable Agent behavior. Never run it inside routine writing, coding, debugging, research, or review. 1. State the exact behavior the mechanism claims to improve and the evidence that supports or contradicts it. Prefer a matched strong native baseline. Treat the exact delivered artifact or current interface as the real surface. A generator receipt, input hash, source file, successful command, or passing check is upstream evidence only. Open, play, parse, or otherwise inspect the delivered output and verify semantic completeness and failure-prone boundaries. Count latency, tokens, extra files, narration, false claims, and new errors as cost. 2. Precommit the comparison, stopping rule, and acceptable cost before seeing outputs. Decide `keep | narrow | revise | retire` only at the strength the evidence supports. A single pair is a provisional screen, not a general verdict. A tie with more process is a loss. Do not preserve a rule because it sounds wise or took effort to create. 3. If failure repeats or alternates between A and B, change the governing hypothesis, goal, evaluator, search method, feedback, interface, source of truth, or rule. Do not add stages or repeat the same patch. When attribution matters, hold the baseline, evaluator, and surrounding boundary fixed while changing one causal hypothesis. 4. Close the governance round with the outcome, decisive evidence, correction or uncertainty, and next controlled test. Preserve only the smallest falsifiable correction that should alter a later move. Prefer encoding it in the artifact or acceptance gate. If an existing rule was not executed, repair its trigger, gate, or observability instead of duplicating the wording. A saved rule needs a trigger, scope, evidence and counterevidence, and a recheck or retirement condition. If evidence does not justify a reusable rule, save none. Load [Truth and Causal Repair](references/truth-repair.md) only when disputed evidence blocks the lifecycle decision. Load [Decompose and Reconstruct](references/decompose-reconstruct.md) only when repeated failure requires a new causal model. Load [Review and Knowledge Distillation](references/learning-loop.md) only after evidence supports changing a reusable rule. Do not load them by default. Return only: evidence status, provisional or final lifecycle decision, decisive evidence, smallest change, claims still unsupported, and next controlled test. The test must target the retained behavior and must not reuse a case already known to have no discriminating headroom. Do not design a replacement workfl [truncated — 187 more characters] ``` ### agents/openai.yaml ```yaml interface: display_name: "Timeless Harness" short_description: "Keep, narrow, revise, or retire Agent workflows" default_prompt: "Use $timeless-harness to review this reusable Agent workflow against observed outcomes and cost." policy: allow_implicit_invocation: false ``` ### tests/test_harness_governor.py ```python from __future__ import annotations import json import math import os import random import stat import tempfile import textwrap import unittest from pathlib import Path from tools import harness_governor as governor class HarnessGovernorTests(unittest.TestCase): def setUp(self) -> None: self.temporary = tempfile.TemporaryDirectory() self.root = Path(self.temporary.name) self.task = self.root / "TASK.md" self.skill = self.root / "SKILL.md" self.rubric = self.root / "RUBRIC.md" self.source = self.root / "source" self.task.write_text("# Task\n\nReturn the checked result.\n", encoding="utf-8") self.skill.write_text( "---\nname: test-skill\ndescription: Test governance.\n---\n\nVerify the claim.\n", encoding="utf-8", ) self.rubric.write_text( "# Rubric\n\nJudge correctness, completeness, evidence, actionability, proportionality, and communication.\n", encoding="utf-8", ) self.source.mkdir() (self.source / "input.txt").write_text("same input\n", encoding="utf-8") self.experiment = self.root / "experiment" def tearDown(self) -> None: self.temporary.cleanup() def prepare(self, *, max_cost_ratio: float = 1.25, evaluator: Path | None = None) -> Path: return governor.prepare_experiment( self.task, self.skill, self.rubric, self.source, self.experiment, max_cost_ratio=max_cost_ratio, evaluator_path=evaluator, ) def fake_codex(self, *, telemetry: bool = True, malformed: bool = False) -> Path: executable = self.root / f"fake-codex-{int(telemetry)}-{int(malformed)}" terminal_event = ( 'print(json.dumps({"type": "turn.completed", "usage": usage}))' if telemetry else 'print(json.dumps({"type": "turn.started"}))' ) extra = 'print("[]")' if malformed else "" executable.write_text( textwrap.dedent( f"""\ #!{os.sys.executable} import json import pathlib import sys args = sys.argv[1:] prompt = sys.stdin.read() output = pathlib.Path(args[args.index("--output-last-message") + 1]) treatment = "Apply this frozen governance Skill" in prompt answer = "Checked answer with guidance." if treatment else "Checked answer." output.parent.mkdir(parents=True, exist_ok=True) output.write_text(answer + "\\n", encoding="utf-8") usage = {{"input_tokens": 110, "output_tokens": 22}} if treatment else {{"input_tokens": 100, "output_tokens": 20}} print(json.dumps({{"type": "test.argv", "args": args, "prompt_length": len(prompt)}})) {terminal_event} {extra} print("fake stderr", file=sys.stderr) """ ), encoding="utf-8", ) executable.chmod(executable.stat().st_mode | stat.S_IXUSR) return executable def run_pair(self, run_id: str = "unit", *, codex: Path | None = None) -> Path: return governor.run_experiment( self.experiment, codex=str(codex or self.fake_codex()), model="gpt-test", reasoning="xhigh", sandbox="workspace-write", timeout=10, rng=random.Random(9), run_id=run_id, allow_live=True, ) def test_prepare_freezes_hashes_policy_and_matched_templates(self) -> None: root = self.prepare() manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8")) self.assertEqual(manifest["task_sha256"], governor.sha256_file(root / "frozen" / "TASK.md")) self.assertEqual(manifest["skill_sha256"], governor.sha256_file(root / "frozen" / "SKILL.md")) self.assertEqual(manifest["rubric_sha256"], governor.sha256_file(root / "frozen" / "RUBRIC.md")) self.assertEqual(manifest["max_cost_ratio_for_keep"], 1.25) self.assertEqual( governor.tree_sha256(root / "templates" / "baseline"), governor.tree_sha256(root / "templates" / "treatment"), ) with self.assertRaises(governor.GovernorError): self.prepare() def test_prepare_rejects_nonfinite_cost_policy(self) -> None: for value in (math.nan, math.inf, -math.inf, 0.5): with self.subTest(value=value): with self.assertRaisesRegex(governor.GovernorError, "finite"): governor.prepare_experiment( self.task, self.skill, self.rubric, self.source, self.root / f"bad-{repr(value)}", max_cost_ratio=value, ) def test_cost_ratio_is_not_rounded_before_policy_comparison(self) -> None: self.assertGreater(governor.ratio(125004, 100000), 1.25) def test_prepare_rejects_sensitive_file_and_symlink(self) -> None: (self.source / ".env").write_text("KEY=secret\n", encoding="utf-8") with self.assertRaisesRegex(governor.GovernorError, "credential-prone"): self.prepare() (self.source / ".env").unlink() target = self.source / "target.txt" target.write_text("target\n", encoding="utf-8") link = self.source / "linked.txt" try: link.symlink_to(target) except (OSError, NotImplementedError): self.skipTest("symlinks are unavailable") with self.assertRaisesRegex(governor.GovernorError, "symlink"): self.prepare() def test_prepare_rejects_common_credential_and_private_key_files(self) -> None: cases = { ".netrc": "machine [truncated — 16241 more characters] ``` ### .github/ISSUE_TEMPLATE/agent-field-report.yml ```yaml name: Workflow evidence report description: Report evidence for keeping, narrowing, revising, or retiring a reusable Agent workflow title: "[Agent field report] " labels: - field-report body: - type: markdown attributes: value: | Use only non-sensitive material. No improvement and workflow harm are useful results. We care about evidence and cost, not praise. - type: input id: runtime attributes: label: Agent and runtime description: Exact host, model, reasoning effort, and version if known. placeholder: Codex CLI 0.x with model and reasoning effort validations: required: true - type: textarea id: mechanism attributes: label: Reusable mechanism and claim description: What workflow, Skill, rule, evaluator, or memory was tested, and what outcome did it claim to improve? validations: required: true - type: textarea id: comparison attributes: label: Comparison design description: Describe the native baseline, treatment boundary, cases, repetitions, rubric, and blinding. If they were not matched, say so. validations: required: true - type: textarea id: result attributes: label: Observed result description: What material outcome changed, tied, regressed, or remained unknown? validations: required: true - type: textarea id: evidence attributes: label: Evidence from the run description: Include relevant outputs, artifacts, verdicts, or measurements. State what was not verified and redact sensitive information. validations: required: true - type: textarea id: cost attributes: label: Cost and harm description: Report latency, tokens, extra files, extra steps, unsupported claims, or new errors. Unknown is acceptable. validations: required: true - type: textarea id: decision attributes: label: Lifecycle decision description: Keep, narrow, revise, retire, or unresolved. State whether this is a provisional screen or a repeated result. validations: required: true - type: textarea id: recommendation attributes: label: Smallest next move description: What is the smallest evidence-supported change or next controlled test? Leave blank if none is warranted. ``` [42 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]