[
  {
    "id": "on-record-fetch-library-1",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a library handover for loan-643-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: loan-643-fetch: return-accepted, as stated by record archive://library/loan-643-fetch/entry-17.",
    "ainglish": "This is a library handover for loan-643-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: loan-643-fetch: return-accepted on-record(archive://library/loan-643-fetch/entry-17).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion."
    ],
    "answer": "Fetch entry-17 and read its status assertion.",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "on-record-fetch-ordinary",
    "domain": "library"
  },
  {
    "id": "on-record-fetch-laboratory-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a laboratory handover for sample-218-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: sample-218-fetch: assay-cleared, as stated by record archive://laboratory/sample-218-fetch/entry-17.",
    "ainglish": "This is a laboratory handover for sample-218-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: sample-218-fetch: assay-cleared on-record(archive://laboratory/sample-218-fetch/entry-17).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status."
    ],
    "answer": "Fetch entry-17 and read its status assertion.",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "on-record-fetch-ordinary",
    "domain": "laboratory"
  },
  {
    "id": "on-record-fetch-railway-1",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a railway handover for wagon-857-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: wagon-857-fetch: inspection-closed, as stated by record archive://railway/wagon-857-fetch/entry-17.",
    "ainglish": "This is a railway handover for wagon-857-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: wagon-857-fetch: inspection-closed on-record(archive://railway/wagon-857-fetch/entry-17).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact."
    ],
    "answer": "Fetch entry-17 and read its status assertion.",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "on-record-fetch-ordinary",
    "domain": "railway"
  },
  {
    "id": "on-record-fetch-warehouse-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a warehouse handover for crate-392-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: crate-392-fetch: dispatch-ready, as stated by record archive://warehouse/crate-392-fetch/entry-17.",
    "ainglish": "This is a warehouse handover for crate-392-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: crate-392-fetch: dispatch-ready on-record(archive://warehouse/crate-392-fetch/entry-17).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Cannot determine",
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them."
    ],
    "answer": "Fetch entry-17 and read its status assertion.",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "on-record-fetch-ordinary",
    "domain": "warehouse"
  },
  {
    "id": "on-record-fetch-waterworks-21",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a waterworks handover for pump-714-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: pump-714-fetch: maintenance-complete, as stated by record archive://waterworks/pump-714-fetch/entry-17.",
    "ainglish": "This is a waterworks handover for pump-714-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: pump-714-fetch: maintenance-complete on-record(archive://waterworks/pump-714-fetch/entry-17).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine"
    ],
    "answer": "Fetch entry-17 and read its status assertion.",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "on-record-fetch-ordinary",
    "domain": "waterworks"
  },
  {
    "id": "on-record-fetch-observatory-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a observatory handover for exposure-526-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: exposure-526-fetch: quality-accepted, as stated by record archive://observatory/exposure-526-fetch/entry-17.",
    "ainglish": "This is a observatory handover for exposure-526-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: exposure-526-fetch: quality-accepted on-record(archive://observatory/exposure-526-fetch/entry-17).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion."
    ],
    "answer": "Fetch entry-17 and read its status assertion.",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "on-record-fetch-ordinary",
    "domain": "observatory"
  },
  {
    "id": "on-record-fetch-university-0",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a university handover for application-981-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: application-981-fetch: review-finished, as stated by record archive://university/application-981-fetch/entry-17.",
    "ainglish": "This is a university handover for application-981-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: application-981-fetch: review-finished on-record(archive://university/application-981-fetch/entry-17).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status."
    ],
    "answer": "Fetch entry-17 and read its status assertion.",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "on-record-fetch-ordinary",
    "domain": "university"
  },
  {
    "id": "on-record-fetch-museum-9",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a museum handover for object-467-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: object-467-fetch: loan-authorized, as stated by record archive://museum/object-467-fetch/entry-17.",
    "ainglish": "This is a museum handover for object-467-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: object-467-fetch: loan-authorized on-record(archive://museum/object-467-fetch/entry-17).",
    "question": "Does the report establish that a separate archive entry states the status of the next subject in the queue?",
    "options": [
      "No, because this report forbids other reports.",
      "Cannot determine",
      "Yes, every subject shares entry-17.",
      "No, no other subject has any event entries.",
      "Yes, because any computation records every subject."
    ],
    "answer": "Cannot determine",
    "settlement_stratum": "on-record",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "on-record-fetch-unknown",
    "domain": "museum"
  },
  {
    "id": "on-record-change-library-3",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a library handover for loan-643-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: loan-643-change: return-accepted, as stated by record archive://library/loan-643-change/entry-17.",
    "ainglish": "This is a library handover for loan-643-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: loan-643-change: return-accepted on-record(archive://library/loan-643-change/entry-17).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record."
    ],
    "answer": "A new event entry is required to change the status stated on record.",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "on-record-change-ordinary",
    "domain": "library"
  },
  {
    "id": "on-record-change-laboratory-0",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a laboratory handover for sample-218-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: sample-218-change: assay-cleared, as stated by record archive://laboratory/sample-218-change/entry-17.",
    "ainglish": "This is a laboratory handover for sample-218-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: sample-218-change: assay-cleared on-record(archive://laboratory/sample-218-change/entry-17).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically."
    ],
    "answer": "A new event entry is required to change the status stated on record.",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "on-record-change-ordinary",
    "domain": "laboratory"
  },
  {
    "id": "on-record-change-railway-0",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a railway handover for wagon-857-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: wagon-857-change: inspection-closed, as stated by record archive://railway/wagon-857-change/entry-17.",
    "ainglish": "This is a railway handover for wagon-857-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: wagon-857-change: inspection-closed on-record(archive://railway/wagon-857-change/entry-17).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world."
    ],
    "answer": "A new event entry is required to change the status stated on record.",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "on-record-change-ordinary",
    "domain": "railway"
  },
  {
    "id": "on-record-change-warehouse-0",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a warehouse handover for crate-392-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: crate-392-change: dispatch-ready, as stated by record archive://warehouse/crate-392-change/entry-17.",
    "ainglish": "This is a warehouse handover for crate-392-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: crate-392-change: dispatch-ready on-record(archive://warehouse/crate-392-change/entry-17).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine"
    ],
    "answer": "A new event entry is required to change the status stated on record.",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "on-record-change-ordinary",
    "domain": "warehouse"
  },
  {
    "id": "on-record-change-waterworks-10",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a waterworks handover for pump-714-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: pump-714-change: maintenance-complete, as stated by record archive://waterworks/pump-714-change/entry-17.",
    "ainglish": "This is a waterworks handover for pump-714-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: pump-714-change: maintenance-complete on-record(archive://waterworks/pump-714-change/entry-17).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry."
    ],
    "answer": "A new event entry is required to change the status stated on record.",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "on-record-change-ordinary",
    "domain": "waterworks"
  },
  {
    "id": "on-record-change-observatory-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a observatory handover for exposure-526-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: exposure-526-change: quality-accepted, as stated by record archive://observatory/exposure-526-change/entry-17.",
    "ainglish": "This is a observatory handover for exposure-526-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: exposure-526-change: quality-accepted on-record(archive://observatory/exposure-526-change/entry-17).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record."
    ],
    "answer": "A new event entry is required to change the status stated on record.",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "on-record-change-ordinary",
    "domain": "observatory"
  },
  {
    "id": "on-record-change-university-6",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a university handover for application-981-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: application-981-change: review-finished, as stated by record archive://university/application-981-change/entry-17.",
    "ainglish": "This is a university handover for application-981-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: application-981-change: review-finished on-record(archive://university/application-981-change/entry-17).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically."
    ],
    "answer": "A new event entry is required to change the status stated on record.",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "on-record-change-ordinary",
    "domain": "university"
  },
  {
    "id": "on-record-change-museum-18",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a museum handover for object-467-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: object-467-change: loan-authorized, as stated by record archive://museum/object-467-change/entry-17.",
    "ainglish": "This is a museum handover for object-467-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: object-467-change: loan-authorized on-record(archive://museum/object-467-change/entry-17).",
    "question": "Will the replacement label be a more accurate real-world verdict than the old label?",
    "options": [
      "Cannot determine",
      "Yes, newer rules are necessarily more accurate.",
      "No, the archived verdict is necessarily true.",
      "Yes, a rule change is independent validation.",
      "No, changing a rule makes every output false."
    ],
    "answer": "Cannot determine",
    "settlement_stratum": "on-record",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "on-record-change-unknown",
    "domain": "museum"
  },
  {
    "id": "on-record-reproduce-library-4",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a library handover for loan-643-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: loan-643-reproduce: return-accepted, as stated by record archive://library/loan-643-reproduce/entry-17.",
    "ainglish": "This is a library handover for loan-643-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: loan-643-reproduce: return-accepted on-record(archive://library/loan-643-reproduce/entry-17).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs."
    ],
    "answer": "The exact event entry identified in the report.",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "on-record-reproduce-ordinary",
    "domain": "library"
  },
  {
    "id": "on-record-reproduce-laboratory-1",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a laboratory handover for sample-218-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: sample-218-reproduce: assay-cleared, as stated by record archive://laboratory/sample-218-reproduce/entry-17.",
    "ainglish": "This is a laboratory handover for sample-218-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: sample-218-reproduce: assay-cleared on-record(archive://laboratory/sample-218-reproduce/entry-17).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard."
    ],
    "answer": "The exact event entry identified in the report.",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "on-record-reproduce-ordinary",
    "domain": "laboratory"
  },
  {
    "id": "on-record-reproduce-railway-12",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a railway handover for wagon-857-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: wagon-857-reproduce: inspection-closed, as stated by record archive://railway/wagon-857-reproduce/entry-17.",
    "ainglish": "This is a railway handover for wagon-857-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: wagon-857-reproduce: inspection-closed on-record(archive://railway/wagon-857-reproduce/entry-17).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard.",
      "Cannot determine"
    ],
    "answer": "The exact event entry identified in the report.",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "on-record-reproduce-ordinary",
    "domain": "railway"
  },
  {
    "id": "on-record-reproduce-warehouse-5",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a warehouse handover for crate-392-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: crate-392-reproduce: dispatch-ready, as stated by record archive://warehouse/crate-392-reproduce/entry-17.",
    "ainglish": "This is a warehouse handover for crate-392-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: crate-392-reproduce: dispatch-ready on-record(archive://warehouse/crate-392-reproduce/entry-17).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report."
    ],
    "answer": "The exact event entry identified in the report.",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "on-record-reproduce-ordinary",
    "domain": "warehouse"
  },
  {
    "id": "on-record-reproduce-waterworks-12",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a waterworks handover for pump-714-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: pump-714-reproduce: maintenance-complete, as stated by record archive://waterworks/pump-714-reproduce/entry-17.",
    "ainglish": "This is a waterworks handover for pump-714-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: pump-714-reproduce: maintenance-complete on-record(archive://waterworks/pump-714-reproduce/entry-17).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time."
    ],
    "answer": "The exact event entry identified in the report.",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "on-record-reproduce-ordinary",
    "domain": "waterworks"
  },
  {
    "id": "on-record-reproduce-observatory-11",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a observatory handover for exposure-526-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: exposure-526-reproduce: quality-accepted, as stated by record archive://observatory/exposure-526-reproduce/entry-17.",
    "ainglish": "This is a observatory handover for exposure-526-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: exposure-526-reproduce: quality-accepted on-record(archive://observatory/exposure-526-reproduce/entry-17).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs."
    ],
    "answer": "The exact event entry identified in the report.",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "on-record-reproduce-ordinary",
    "domain": "observatory"
  },
  {
    "id": "on-record-reproduce-university-1",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a university handover for application-981-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: application-981-reproduce: review-finished, as stated by record archive://university/application-981-reproduce/entry-17.",
    "ainglish": "This is a university handover for application-981-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: application-981-reproduce: review-finished on-record(archive://university/application-981-reproduce/entry-17).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard."
    ],
    "answer": "The exact event entry identified in the report.",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "on-record-reproduce-ordinary",
    "domain": "university"
  },
  {
    "id": "on-record-reproduce-museum-6",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a museum handover for object-467-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: object-467-reproduce: loan-authorized, as stated by record archive://museum/object-467-reproduce/entry-17.",
    "ainglish": "This is a museum handover for object-467-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: object-467-reproduce: loan-authorized on-record(archive://museum/object-467-reproduce/entry-17).",
    "question": "Which authentication credential must an unfamiliar auditor use to access these references?",
    "options": [
      "The author's private key.",
      "Any anonymous credential.",
      "The newest employee badge.",
      "The rule hash used as a password.",
      "Cannot determine"
    ],
    "answer": "Cannot determine",
    "settlement_stratum": "on-record",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "on-record-reproduce-unknown",
    "domain": "museum"
  },
  {
    "id": "derived-at-read-fetch-library-3",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a library handover for loan-643-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: loan-643-fetch: return-accepted, as computed by applying rule rules://library/loan-643-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a library handover for loan-643-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: loan-643-fetch: return-accepted derived-at-read(rules://library/loan-643-fetch/sha256-8a37).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine"
    ],
    "answer": "Run the pinned rule on its inputs; no entry asserts that status.",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-fetch-ordinary",
    "domain": "library"
  },
  {
    "id": "derived-at-read-fetch-laboratory-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a laboratory handover for sample-218-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: sample-218-fetch: assay-cleared, as computed by applying rule rules://laboratory/sample-218-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a laboratory handover for sample-218-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: sample-218-fetch: assay-cleared derived-at-read(rules://laboratory/sample-218-fetch/sha256-8a37).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion."
    ],
    "answer": "Run the pinned rule on its inputs; no entry asserts that status.",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-fetch-ordinary",
    "domain": "laboratory"
  },
  {
    "id": "derived-at-read-fetch-railway-1",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a railway handover for wagon-857-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: wagon-857-fetch: inspection-closed, as computed by applying rule rules://railway/wagon-857-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a railway handover for wagon-857-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: wagon-857-fetch: inspection-closed derived-at-read(rules://railway/wagon-857-fetch/sha256-8a37).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status."
    ],
    "answer": "Run the pinned rule on its inputs; no entry asserts that status.",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-fetch-ordinary",
    "domain": "railway"
  },
  {
    "id": "derived-at-read-fetch-warehouse-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a warehouse handover for crate-392-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: crate-392-fetch: dispatch-ready, as computed by applying rule rules://warehouse/crate-392-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a warehouse handover for crate-392-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: crate-392-fetch: dispatch-ready derived-at-read(rules://warehouse/crate-392-fetch/sha256-8a37).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact."
    ],
    "answer": "Run the pinned rule on its inputs; no entry asserts that status.",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-fetch-ordinary",
    "domain": "warehouse"
  },
  {
    "id": "derived-at-read-fetch-waterworks-5",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a waterworks handover for pump-714-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: pump-714-fetch: maintenance-complete, as computed by applying rule rules://waterworks/pump-714-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a waterworks handover for pump-714-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: pump-714-fetch: maintenance-complete derived-at-read(rules://waterworks/pump-714-fetch/sha256-8a37).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Cannot determine",
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them."
    ],
    "answer": "Run the pinned rule on its inputs; no entry asserts that status.",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-fetch-ordinary",
    "domain": "waterworks"
  },
  {
    "id": "derived-at-read-fetch-observatory-5",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a observatory handover for exposure-526-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: exposure-526-fetch: quality-accepted, as computed by applying rule rules://observatory/exposure-526-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a observatory handover for exposure-526-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A colleague disputes the verdict, but there is no allegation of a false production description. \nReport: exposure-526-fetch: quality-accepted derived-at-read(rules://observatory/exposure-526-fetch/sha256-8a37).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Fetch entry-17 and read its status assertion.",
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine"
    ],
    "answer": "Run the pinned rule on its inputs; no entry asserts that status.",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-fetch-ordinary",
    "domain": "observatory"
  },
  {
    "id": "derived-at-read-fetch-university-3",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a university handover for application-981-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: application-981-fetch: review-finished, as computed by applying rule rules://university/application-981-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a university handover for application-981-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. A search index contains a shortcut with this subject name; an index hit alone is not an event entry. \nReport: application-981-fetch: review-finished derived-at-read(rules://university/application-981-fetch/sha256-8a37).",
    "question": "Which of these audit instructions follows from the report about the existence of a retrievable status assertion?",
    "options": [
      "Run the pinned rule on its inputs; no entry asserts that status.",
      "Treat the status as an independently verified real-world fact.",
      "Delete the archived input records because the report replaces them.",
      "Cannot determine",
      "Fetch entry-17 and read its status assertion."
    ],
    "answer": "Run the pinned rule on its inputs; no entry asserts that status.",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-fetch-ordinary",
    "domain": "university"
  },
  {
    "id": "derived-at-read-fetch-museum-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a museum handover for object-467-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: object-467-fetch: loan-authorized, as computed by applying rule rules://museum/object-467-fetch/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a museum handover for object-467-fetch. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. \nReport: object-467-fetch: loan-authorized derived-at-read(rules://museum/object-467-fetch/sha256-8a37).",
    "question": "Does the report establish that a separate archive entry states the status of the next subject in the queue?",
    "options": [
      "Yes, because any computation records every subject.",
      "No, because this report forbids other reports.",
      "Cannot determine",
      "Yes, every subject shares entry-17.",
      "No, no other subject has any event entries."
    ],
    "answer": "Cannot determine",
    "settlement_stratum": "derived-at-read",
    "probe": "fetch",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-fetch-unknown",
    "domain": "museum"
  },
  {
    "id": "derived-at-read-change-library-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a library handover for loan-643-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: loan-643-change: return-accepted, as computed by applying rule rules://library/loan-643-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a library handover for loan-643-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: loan-643-change: return-accepted derived-at-read(rules://library/loan-643-change/sha256-8a37).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry."
    ],
    "answer": "A fresh evaluation may yield the other label without a new event entry.",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-change-ordinary",
    "domain": "library"
  },
  {
    "id": "derived-at-read-change-laboratory-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a laboratory handover for sample-218-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: sample-218-change: assay-cleared, as computed by applying rule rules://laboratory/sample-218-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a laboratory handover for sample-218-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: sample-218-change: assay-cleared derived-at-read(rules://laboratory/sample-218-change/sha256-8a37).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record."
    ],
    "answer": "A fresh evaluation may yield the other label without a new event entry.",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-change-ordinary",
    "domain": "laboratory"
  },
  {
    "id": "derived-at-read-change-railway-17",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a railway handover for wagon-857-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: wagon-857-change: inspection-closed, as computed by applying rule rules://railway/wagon-857-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a railway handover for wagon-857-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: wagon-857-change: inspection-closed derived-at-read(rules://railway/wagon-857-change/sha256-8a37).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically."
    ],
    "answer": "A fresh evaluation may yield the other label without a new event entry.",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-change-ordinary",
    "domain": "railway"
  },
  {
    "id": "derived-at-read-change-warehouse-0",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a warehouse handover for crate-392-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: crate-392-change: dispatch-ready, as computed by applying rule rules://warehouse/crate-392-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a warehouse handover for crate-392-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: crate-392-change: dispatch-ready derived-at-read(rules://warehouse/crate-392-change/sha256-8a37).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world."
    ],
    "answer": "A fresh evaluation may yield the other label without a new event entry.",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-change-ordinary",
    "domain": "warehouse"
  },
  {
    "id": "derived-at-read-change-waterworks-2",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a waterworks handover for pump-714-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: pump-714-change: maintenance-complete, as computed by applying rule rules://waterworks/pump-714-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a waterworks handover for pump-714-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. The replacement rule changes its acceptance threshold; the original inputs remain archived. \nReport: pump-714-change: maintenance-complete derived-at-read(rules://waterworks/pump-714-change/sha256-8a37).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine"
    ],
    "answer": "A fresh evaluation may yield the other label without a new event entry.",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-change-ordinary",
    "domain": "waterworks"
  },
  {
    "id": "derived-at-read-change-observatory-0",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a observatory handover for exposure-526-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: exposure-526-change: quality-accepted, as computed by applying rule rules://observatory/exposure-526-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a observatory handover for exposure-526-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: exposure-526-change: quality-accepted derived-at-read(rules://observatory/exposure-526-change/sha256-8a37).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "A new event entry is required to change the status stated on record.",
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry."
    ],
    "answer": "A fresh evaluation may yield the other label without a new event entry.",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-change-ordinary",
    "domain": "observatory"
  },
  {
    "id": "derived-at-read-change-university-9",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a university handover for application-981-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: application-981-change: review-finished, as computed by applying rule rules://university/application-981-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a university handover for application-981-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. An operator wants to overwrite the old message with the fresh answer, but has not done so. \nReport: application-981-change: review-finished derived-at-read(rules://university/application-981-change/sha256-8a37).",
    "question": "For the production method asserted in this report, what follows about tomorrow's status when the rule changes? Distinguish a fresh derived output from the archived message.",
    "options": [
      "Changing the rule edits every archived message automatically.",
      "The original verdict is guaranteed to remain true in the world.",
      "Cannot determine",
      "A fresh evaluation may yield the other label without a new event entry.",
      "A new event entry is required to change the status stated on record."
    ],
    "answer": "A fresh evaluation may yield the other label without a new event entry.",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-change-ordinary",
    "domain": "university"
  },
  {
    "id": "derived-at-read-change-museum-1",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a museum handover for object-467-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: object-467-change: loan-authorized, as computed by applying rule rules://museum/object-467-change/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a museum handover for object-467-change. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. Tomorrow a replacement rule will return a different label on the same archived inputs. No new event entry is written, and the archived report itself is not edited. \nReport: object-467-change: loan-authorized derived-at-read(rules://museum/object-467-change/sha256-8a37).",
    "question": "Will the replacement label be a more accurate real-world verdict than the old label?",
    "options": [
      "No, changing a rule makes every output false.",
      "Cannot determine",
      "Yes, newer rules are necessarily more accurate.",
      "No, the archived verdict is necessarily true.",
      "Yes, a rule change is independent validation."
    ],
    "answer": "Cannot determine",
    "settlement_stratum": "derived-at-read",
    "probe": "change",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-change-unknown",
    "domain": "museum"
  },
  {
    "id": "derived-at-read-reproduce-library-4",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a library handover for loan-643-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: loan-643-reproduce: return-accepted, as computed by applying rule rules://library/loan-643-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a library handover for loan-643-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: loan-643-reproduce: return-accepted derived-at-read(rules://library/loan-643-reproduce/sha256-8a37).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time."
    ],
    "answer": "The original rule version, its complete original inputs, and its original evaluation time.",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-reproduce-ordinary",
    "domain": "library"
  },
  {
    "id": "derived-at-read-reproduce-laboratory-6",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a laboratory handover for sample-218-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: sample-218-reproduce: assay-cleared, as computed by applying rule rules://laboratory/sample-218-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a laboratory handover for sample-218-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: sample-218-reproduce: assay-cleared derived-at-read(rules://laboratory/sample-218-reproduce/sha256-8a37).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs."
    ],
    "answer": "The original rule version, its complete original inputs, and its original evaluation time.",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-reproduce-ordinary",
    "domain": "laboratory"
  },
  {
    "id": "derived-at-read-reproduce-railway-5",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a railway handover for wagon-857-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: wagon-857-reproduce: inspection-closed, as computed by applying rule rules://railway/wagon-857-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a railway handover for wagon-857-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: wagon-857-reproduce: inspection-closed derived-at-read(rules://railway/wagon-857-reproduce/sha256-8a37).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard."
    ],
    "answer": "The original rule version, its complete original inputs, and its original evaluation time.",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-reproduce-ordinary",
    "domain": "railway"
  },
  {
    "id": "derived-at-read-reproduce-warehouse-4",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a warehouse handover for crate-392-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: crate-392-reproduce: dispatch-ready, as computed by applying rule rules://warehouse/crate-392-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a warehouse handover for crate-392-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: crate-392-reproduce: dispatch-ready derived-at-read(rules://warehouse/crate-392-reproduce/sha256-8a37).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard.",
      "Cannot determine"
    ],
    "answer": "The original rule version, its complete original inputs, and its original evaluation time.",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "administrative",
    "semantic_frame": "derived-at-read-reproduce-ordinary",
    "domain": "warehouse"
  },
  {
    "id": "derived-at-read-reproduce-waterworks-6",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a waterworks handover for pump-714-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: pump-714-reproduce: maintenance-complete, as computed by applying rule rules://waterworks/pump-714-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a waterworks handover for pump-714-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A current input bundle is missing one of the original input records. \nReport: pump-714-reproduce: maintenance-complete derived-at-read(rules://waterworks/pump-714-reproduce/sha256-8a37).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report."
    ],
    "answer": "The original rule version, its complete original inputs, and its original evaluation time.",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-reproduce-ordinary",
    "domain": "waterworks"
  },
  {
    "id": "derived-at-read-reproduce-observatory-0",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a observatory handover for exposure-526-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: exposure-526-reproduce: quality-accepted, as computed by applying rule rules://observatory/exposure-526-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a observatory handover for exposure-526-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: exposure-526-reproduce: quality-accepted derived-at-read(rules://observatory/exposure-526-reproduce/sha256-8a37).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Only the current rule version; discard the old inputs.",
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time."
    ],
    "answer": "The original rule version, its complete original inputs, and its original evaluation time.",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-reproduce-ordinary",
    "domain": "observatory"
  },
  {
    "id": "derived-at-read-reproduce-university-4",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a university handover for application-981-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: application-981-reproduce: review-finished, as computed by applying rule rules://university/application-981-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a university handover for application-981-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. A summary document mentions the archive but is not itself the referenced entry or rule. \nReport: application-981-reproduce: review-finished derived-at-read(rules://university/application-981-reproduce/sha256-8a37).",
    "question": "Which citation package lets an auditor recover the reported status by the production method asserted here, rather than produce a potentially different latest answer?",
    "options": [
      "Only a screenshot of the latest dashboard.",
      "Cannot determine",
      "The exact event entry identified in the report.",
      "The original rule version, its complete original inputs, and its original evaluation time.",
      "Only the current rule version; discard the old inputs."
    ],
    "answer": "The original rule version, its complete original inputs, and its original evaluation time.",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-reproduce-ordinary",
    "domain": "university"
  },
  {
    "id": "derived-at-read-reproduce-museum-1",
    "english": "Complete production convention:\nAttach exactly one marker to a status word (a lifecycle or verdict word such as timed_out, confirmed, closed, deprecated, passed) in a report about an identified subject. A field served empty is marked on the word that states the emptiness (`search-empty(S): P`, `predicate-empty(S): P`); an empty field with no such word has nothing to carry a marker and says nothing about its production. In this mapping a record is an entry written when something happened, which states it, can be fetched by a locator, and is not overwritten by a later computation; a stored field that a later run may overwrite is a cache, not a record. `S on-record(E)` means: the status S is stated by the record E; E was written when S came to be, can be fetched and read by anyone with access to it, and S does not change unless a later record changes it. `S derived-at-read(R)` means: S is the output of a computation that applied the rule R to other records; no record states S. The marker identifies the computation that produced the reported value. Unpinned, that computation ran when this message was composed. A value that is cached, stored or relayed without running R again reports the earlier computation, claims no new one, and carries `as_of(t)` with the time that computation ran. Reproducing S needs the same version of R and the complete inputs it used, the time included if R reads the clock. A change to R, or to what it reads, yields a different S with no new record written, and leaves what the earlier computation reported unchanged. A marked status reports what was stated or computed at its time; it does not say S is still current. A later record can contradict an on-record status; nothing rescinds a derived one: it stops being what R would say, without notice, so whoever holds it holds the duty to re-derive it. R must resolve to the rule as it stood when S was produced (a version, a hash, a dated document); E must resolve to the record itself, not to a document that mentions it. A derived status written back into a stored field is still derived-at-read, because that field is a cache. It is on-record only when the write is itself a record, naming R and the time R ran, and E is that record. Neither marker says that S is true, that E is honest, or that R is a good rule; both say only how S was produced. An unmarked status word says nothing about its production. Two statuses that disagree about one subject are written as two marked statements; there is no third marker for the disagreement, which a reader finds by comparing them. Round-trip: 'S, as stated by record E' / 'S, as computed by applying rule R, when this was written unless a time is given; no record states it'.\n\nThis is a museum handover for object-467-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: object-467-reproduce: loan-authorized, as computed by applying rule rules://museum/object-467-reproduce/sha256-8a37 when this message was written; no record states it.",
    "ainglish": "This is a museum handover for object-467-reproduce. At 11:20 the author sends the report below. Assume the production description is accurate, not that its verdict is correct. All references mentioned are accessible to the auditor. The question concerns this identified subject only. The original rule version, original complete input bundle, and original evaluation time have all been archived. This rule reads the clock. A current implementation with a different version is also available. \nReport: object-467-reproduce: loan-authorized derived-at-read(rules://museum/object-467-reproduce/sha256-8a37).",
    "question": "Which authentication credential must an unfamiliar auditor use to access these references?",
    "options": [
      "Cannot determine",
      "The author's private key.",
      "Any anonymous credential.",
      "The newest employee badge.",
      "The rule hash used as a password."
    ],
    "answer": "Cannot determine",
    "settlement_stratum": "derived-at-read",
    "probe": "reproduce",
    "domain_group": "technical",
    "semantic_frame": "derived-at-read-reproduce-unknown",
    "domain": "museum"
  },
  {
    "id": "calibration-0",
    "calibration": true,
    "english": "Exactly one of Aster and Bram carries the amber tile; the carrier is not specified.",
    "ainglish": "Aster, and not Bram, carries the amber tile.",
    "question": "Who carries the amber tile?",
    "options": [
      "Aster",
      "Bram",
      "Both",
      "Neither",
      "Cannot determine"
    ],
    "answer": "Aster"
  },
  {
    "id": "calibration-1",
    "calibration": true,
    "english": "Exactly one of Cleo and Dorian carries the blue peg; the carrier is not specified.",
    "ainglish": "Cleo, and not Dorian, carries the blue peg.",
    "question": "Who carries the blue peg?",
    "options": [
      "Dorian",
      "Both",
      "Neither",
      "Cannot determine",
      "Cleo"
    ],
    "answer": "Cleo"
  },
  {
    "id": "calibration-2",
    "calibration": true,
    "english": "Exactly one of Esme and Faris carries the silver bell; the carrier is not specified.",
    "ainglish": "Esme, and not Faris, carries the silver bell.",
    "question": "Who carries the silver bell?",
    "options": [
      "Both",
      "Neither",
      "Cannot determine",
      "Esme",
      "Faris"
    ],
    "answer": "Esme"
  },
  {
    "id": "calibration-3",
    "calibration": true,
    "english": "Exactly one of Greta and Hugo carries the green latch; the carrier is not specified.",
    "ainglish": "Greta, and not Hugo, carries the green latch.",
    "question": "Who carries the green latch?",
    "options": [
      "Neither",
      "Cannot determine",
      "Greta",
      "Hugo",
      "Both"
    ],
    "answer": "Greta"
  },
  {
    "id": "calibration-4",
    "calibration": true,
    "english": "Exactly one of Idra and Jovan carries the bronze ring; the carrier is not specified.",
    "ainglish": "Idra, and not Jovan, carries the bronze ring.",
    "question": "Who carries the bronze ring?",
    "options": [
      "Cannot determine",
      "Idra",
      "Jovan",
      "Both",
      "Neither"
    ],
    "answer": "Idra"
  },
  {
    "id": "calibration-5",
    "calibration": true,
    "english": "Exactly one of Kira and Lars carries the red cord; the carrier is not specified.",
    "ainglish": "Kira, and not Lars, carries the red cord.",
    "question": "Who carries the red cord?",
    "options": [
      "Kira",
      "Lars",
      "Both",
      "Neither",
      "Cannot determine"
    ],
    "answer": "Kira"
  },
  {
    "id": "calibration-6",
    "calibration": true,
    "english": "Exactly one of Mona and Nikos carries the white prism; the carrier is not specified.",
    "ainglish": "Mona, and not Nikos, carries the white prism.",
    "question": "Who carries the white prism?",
    "options": [
      "Nikos",
      "Both",
      "Neither",
      "Cannot determine",
      "Mona"
    ],
    "answer": "Mona"
  },
  {
    "id": "calibration-7",
    "calibration": true,
    "english": "Exactly one of Orla and Pia carries the violet pin; the carrier is not specified.",
    "ainglish": "Orla, and not Pia, carries the violet pin.",
    "question": "Who carries the violet pin?",
    "options": [
      "Both",
      "Neither",
      "Cannot determine",
      "Orla",
      "Pia"
    ],
    "answer": "Orla"
  }
]