Skip to content

AFFIRMATION.adoc

Latest commit

 

History

History
235 lines (177 loc) · 8.77 KB

AFFIRMATION.adoc

File metadata and controls

235 lines (177 loc) · 8.77 KB
Raw

AFFIRMATION — Dicta-Task, as of <YYYY-MM-DD>

the No-Bullshit file: what we affirm was true and checkable at this moment.

Note

This file is a template. Replace the {{…}} placeholders and the <…> anchor fields, then re-run your project’s own checks in the same session before signing. It conforms to profile A (evidential) of the AFFIRMATION authoring standard. A policy-surface repo should use profile B (MUST / INTEND / WISH) instead — see that standard for the profile B skeleton.

An affirmation is a solemn declaration of the truth of a statement, made by someone who declines to swear an oath — our truth-as-best-believed at a stamped instant, binding on our honesty, not a claim of infallibility. It is the third of the README / EXPLAINME / AFFIRMATION trio:

File Answers Tense

README.adoc

Where is this going, and why? — steering, intent, vision

future / aspirational

EXPLAINME.adoc

How is it built, and what’s the evidence? — engineering

descriptive / mechanism

AFFIRMATION.adoc (this file)

What can we honestly affirm was true and checkable at a stamped moment?

a frozen instant, falsifiable

This file is optional. Delete it rather than carry an affirmation you have not re-verified — a stale affirmation is worse than none.
Table of Contents

What this is, and how it works

What it is. A short, dated, signed snapshot of what hyperpolymath can honestly and verifiably claim about Dicta-Task at one exact commit. Nothing here is marketing and nothing is a promise about the future — those live in the README. This file is the receipt.

What the project is. Speech-to-do pipeline: portable recorder to transcription to NLP parsing to prioritised task list

How it stays trustworthy. Three moving parts:

  1. Ground truth, not memory. Every claim below must be produced by running the project’s own checks in the session that writes this file (build, tests, typecheck, just audit). Where a status doc, the Justfile, or memory says otherwise, the live run wins and the contradiction is flagged here.

  2. A frozen anchor. The file names the exact commit SHA, branch, UTC timestamp, working-tree delta and toolchain (see Verifiable anchor), so "true" always means "true at this point". Move the SHA and this file is a draft until it is re-run.

  3. A real signature. It is landed by a signed git commit; that signature over this content at the anchored SHA is what makes the affirmation tamper-evident and attributable — not the prose alone.

We are fallible. This is our best honest belief, not a proof of its own correctness. Treat it as a falsifiable claim, not gospel.

The epistemic contract (read this before you trust or attack)

This document records hyperpolymath’s best belief at the timestamp below. It is not a guarantee of correctness. The only guarantee is no intentional overclaim: where something is proven we say "proven"; where it is a documented trust boundary, an experiment, or an unwired module, we say so; where a claim is the README’s aspiration rather than a checked result, we say so. An honest claim that later turns out false is an error to be fixed — not a lie.

What you may conclude from this file:

  • Every claim below was produced by running the tool in the session that wrote this file — not from memory, not copied forward from a previous affirmation, and not read off a status document.

  • Where a live run and a status document disagreed, the live run won and the status document is named as stale in Outstanding / weak / refuted (no spin).

What you may not conclude:

  • That anything is true now. This file describes the commit in Verifiable anchor and nothing else.

  • That unlisted things pass. Silence is not a claim.

Standing invitation to refute. You are invited to bulldoze any claim in this file. Bring a counter-example, a failing run, or a contradicting source.

Verifiable anchor

Field Value

Project

Dicta-Task

Repo

hyperpolymath/dicta-task

Branch

main

Commit (HEAD)

<full 40-character SHA — never abbreviated, never a tag>

Permalink

https://github.com/hyperpolymath/dicta-task/tree/<full 40-character SHA>

Verified (UTC)

<ISO-8601 with the Z suffix, e.g. 2026-09-09T00:52:11Z>

Working-tree delta at verification

clean, or every modified and untracked file present when the checks ran, with an explicit statement of whether it affects the results below.

Toolchain

<every compiler, prover and runtime version the claims depend on>

Affirmed by

Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
Important

Never anchor to a tag. Tags move, and a moved tag silently invalidates every claim in this file.

If you are reading this at a later commit, the claims may have drifted. Re-run Reproduce it yourself and write a fresh affirmation; do not trust a stale one.

Companion documents and repo metadata (cross-check)

The files a sceptic should read against this one — including any that contradict it. A contradiction named here is honest; one the reader finds for themselves is not.

  • README.adoc — the aspirational claims this file is measured against.

  • docs/EXPLAINME.adoc — the mechanism.

  • docs/AUDIT.adoc — the standing conformance audit.

  • *_chora.deed (repo deed) — machine-readable repo metadata (AI allocation + ply tree).

  • <any status document, dashboard or percentage that disagrees with the state below — name it and say which one wins>

The honest state (one breath)

<One paragraph. If it needs two, the repo is not ready for an affirmation.>

What is solid (and how we checked)

Claim Status Evidence (command, and what it printed)

e.g. The library builds clean

affirmed

just build at the anchor SHA — exit 0

e.g. The ABI seam typechecks

affirmed

idris2 --typecheck src/interface/abi.ipkg — 0 errors

e.g. Feature X is complete

aspiration

README §… — not checked, do not read as affirmed

The honest nuance you must not lose

Where a true claim above is easily over-read. This section is what separates an affirmation from marketing.

  • <e.g. "the tests pass" — 55 static assertion sites, not the 1,282 assertion EXECUTIONS a loop-amplified counter reports>

Known-incomplete but honestly fenced

Gaps that fail loudly rather than silently. Name the guard that makes the failure loud — a gap with no guard belongs in Outstanding / weak / refuted (no spin) instead.

  • <gap> — fenced by <the check, postulate or fail-closed stub that catches it>

Outstanding / weak / refuted (no spin)

Known gaps, trust boundaries, postulates, unwired modules and stale docs. Silence is not affirmation — name what you have not verified, and name anything this session refuted.

Important

Never delete a refuted claim. Deleting it is exactly the spin this genre exists to prevent — mark it refuted and say what refuted it.

Reproduce it yourself

git clone https://github.com/hyperpolymath/dicta-task
cd dicta-task
git checkout <full 40-character SHA>
# <the exact commands, in order, with their expected output>

One-line characterisation (quote this)

<the one sentence Jonathan D.A. Jewell is willing to be quoted on>

Joint attestation

We, the undersigned, assert that to the best of our joint belief at the timestamp above, every claim in this file is true and was checked as described — with no intentional overclaim, and with the open gaps stated rather than hidden.

  • Engineering party (AI): <exact model identifier> — ran the checks recorded here at <ISO-8601 UTC> and stands behind the wording above as a faithful report of those runs.

  • Owner / maintainer: Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk> — signs by committing this file with -S; the git commit signature over this content, at the commit SHA recorded above, is the cryptographic form of this affirmation.

git commit -S -s docs/AFFIRMATION.adoc -m "docs: affirm state at <sha>"
git log --show-signature -1
Warning

Do not use --no-verify. The pre-commit hook enforces the SPDX header, and an affirmation landed past its own repo’s gates is self-refuting.

Landed by a signed git commit. Verify with git log --show-signature that the anchor SHA above matches the parent of the commit that introduced this affirmation. If they do not match, this file is a draft and must be read as one.