The systemd unit, nginx vhost, build-and-restart script and operator notes
for running Noema as a Docker container behind nginx against the host
PostgreSQL cluster. Secrets stay in /etc/noema/noema.env, outside the repo.
Formation summed its terms by ranging over a map, so the score could
differ in the last bit between runs of the same state; the volition hook
assessed commitments, metacognition raised repeated-failure candidates and
the forensic explanation listed commitments in map iteration order, so the
events a cycle emits and an explanation's order varied between runs. Each
now iterates in sorted order, as replay determinism (PLAN §1 R3) requires.
Apply and Supersede updated an intention by id alone, so a reconsideration
from the event bus and one from the executor could both apply: an
intention abandoned on goal_abandoned could be resumed by resumeParent a
moment later, leaving it active with closed_at set. Each transition now
writes only when the status is still the one the caller read, before its
event and decision, and a lost race returns ErrClosed having written
nothing. Plan SetStatus likewise changes only an open plan or a draft, so
a stale copy can never relabel a completed, failed, abandoned or
superseded plan. Regression tests cover both.
Propose built every strategy to record the alternatives, and the model
strategy's build is a live call to the plan role, so planning a direct
action spent a model call on an alternative that could never be selected
(B2, docs/planning.md). The model is now recorded as "not consulted" once
a deterministic draft is chosen, and the approver's reason no longer lists
it among the alternatives considered. A test counts the calls both ways.
Retracting a plan's assumption replanned it and withdrew its pending
approval. An executor tick holding the old plan then saw the withdrawn
approval, treated it as expired and replanned a second time. Entering
replanning is now a compare-and-set, so only the first reconsideration
replans and a stale one does nothing. A regression test fails with three
plans without the guard.
An intention's supporting beliefs came from a text search on the target,
and ties on rank and confidence had no order, so a verification miss could
revise an unrelated belief about the same service. Beliefs that mention the
proposed action now come first, and belief search breaks ties by id.
The incident scenario asserts the first support is the belief about
restarting, and waits for the blocked intention and the procedural memory
instead of reading them once.
The approval request commits before the executor marks the parent
intention blocked, so the commitment test now waits for both instead of
asserting the status immediately. The milestone test's reply wait rises
from 20s to 90s; it returns as soon as the reply lands.
New documents define goal, want, intention, commitment, plan, action,
capability, authority, agency and introspection operationally, state
prominently that no operational measure establishes phenomenal
consciousness or sentience, and describe the rules, thresholds, events,
inspection points and limits of each subsystem:
- docs/volition.md: want derivation, reinforcement, decay and suppression,
conflicts, formation and its outcomes, the intention–action gap,
reconsideration, commitments and volition metacognition;
- docs/planning.md: plans and step kinds, validation, strategies, the
executor, observe–act–verify, replanning, budgets, operator attention,
long-running work, restarts and duplicates;
- docs/agency.md: the fifteen authority invariants and their tests,
scoped authority, forensic why, attribution and the agency timeline;
- docs/cognitive-research.md: operational definitions separating
implementation property from philosophical interpretation, experiment
protocols (global workspace, ablation, self-model, counterfactual, model
comparison, conflict), every measure, introspection accuracy,
metacognitive calibration and temporal self-continuity.
Updated: interpretation table, capabilities (metadata, typed operations,
scoped grants, requests), cognition, snapshots (fork authority), security
and threat model (T14, T16, new T27–T29), architecture, README, changelog,
release notes, ADR-0012 and ADR-0013, and PLAN.md §8.10 status. The
unimplemented record_procedure internal step is removed from the
vocabulary; procedural memory is recorded when a plan completes.
The full incident scenario now runs against the assembled daemon: an
operator goal becomes a want to reduce uncertainty, an investigation
intention and a diagnosis plan; telemetry is read; logs need authority,
so a scoped request with risk, mitigation and fallback is raised and the
intention is blocked until an operator grants it; the logs are read with
personal data masked and summarised back into cognition; the operator
supplies the judgement that a restart should help; a standing commitment
turns the restart into a request for approval; after approval the typed
capability runs and health is verified rather than assumed; the fault
persists, so a prediction error weakens the supporting belief, the plan
is replanned into an escalation that reuses the live log grant and does
not repeat the restart; once the database is fixed a second approved
restart verifies, the procedure is learnt, and "Why did you restart
atlas-worker?" is answered from the recorded chain and scores as
supported.
Changes the scenario exposed:
- New operator goals are raised by the goal monitor, so a cycle runs and
wants are derived from them.
- Intentions link live beliefs about their action's target, so a failed
expectation is evidence against the belief it rested on and the plan
lists it as an assumption.
- Reconsideration reacts to a plan's own intention only; a subordinate
"obtain approval" intention shares the plan and previously caused the
parent's plan to be closed.
- The harness accepts a clock for the executor's verification windows.
Further failure-mode tests: a retracted assumption replans a waiting plan
away from the restart and withdraws its approval request; conflicting
commitments are raised once in a cycle while both stay represented.
The API's belief emitter published every event as soon as it was appended.
Belief retraction runs inside its own transaction, so subscribers on the
event bus saw belief_retracted while the belief row still held its old
status, breaking the rule that subscribers never see uncommitted events;
a plan reacting to a retracted assumption read the belief before the
change and did nothing. The emitter now only appends, and every API and UI
caller publishes the operation's events after it succeeds.
- Wants: active wants by effective strength with origin, means, drives,
values, goal, reinforcement, suppressions and each conflict with its
resolution rule; closed wants with their resolution.
- Intentions grouped by status with blocked reasons and plans, plus the
wants that did not become intentions and why. An intention page shows
sources, subordinate intentions, formation terms, every plan revision as
a dependency graph, decisions and the correlated timeline; operators can
abandon it.
- Commitments with polarity, exception, matcher, weight and due time,
live conflicts between commitments, a creation form and close controls.
- Plans with estimate against budget; a plan page with the dependency
graph, per-step expectations, observations and linked approvals,
requests, executions and subordinate intentions, resources, completion
and abort conditions, assumptions, alternatives, revisions and
validation; operators can cancel a plan or release a blocked step.
- Agency timeline labelling each event as wanted, intended, committed,
planned, requested, approved, acted, observed or reconsidered.
- "Why did this happen?" pages built from agency.Explain, reachable from
events, executions in the approval centre, plan steps and intentions.
- A research dashboard per mind (volition and agency rates, introspection
accuracy, action claims, self-model accuracy, calibration by confidence
band, experiments on the mind) and a global research page grouping
experiments by protocol; every figure sits next to its operational
definition and the disclaimer. Experiment pages show the protocol,
reproducibility, build, per-variant research measures, divergence
extras and counterfactual findings.
- The mind tabs gain Volition; the navigation gains Research.
Research experiments run several sandbox variants with settle windows, and
under the full parallel race suite the experiments package exceeded Go's
default ten-minute limit. The make targets now pass -timeout 30m, and the
ablation and self-model scenarios use the fewest stimuli that still show
their effect.
The pending → ready and pending → cancelled transitions, and cancellation
of open steps, saved a step unconditionally. Under load an executor
holding a stale "pending" copy could write "ready" over a step another
executor had already claimed and was running, after which the step could
be claimed again: the full race suite caught two restarts from one plan.
These transitions now use SaveIf, which writes only when the stored status
is still the expected one. A deterministic regression test hands the
executor a stale copy and fails without the fix; the concurrency test now
races eight executors ticking repeatedly.
Observers can read wants (with effective strength), want conflicts,
commitments, intentions with their plans, subordinate intentions and
decisions, the decision ledger, plans with steps, "why" explanations for
executions, approvals, capability requests, plan steps, intentions and
events, attribution of an outcome event, the agency timeline, the
measure definitions with their disclaimer, agency metrics, metacognitive
calibration and raw research measurements.
Operators can create and close commitments, abandon an intention (its
plan is cancelled and pending requests withdrawn), cancel a plan and
release a blocked step. Every write is audited; none grants capability
authority. OpenAPI documents all 21 routes, and an end-to-end test
covers reads, writes and observer refusals.
A framework for testing functional properties of the architecture
(Part C). None of it claims consciousness; every measure has an
operational definition in research.Measures.
- Ablations (attention, memory retrieval, affect, metacognition,
commitments, volition, global workspace, curiosity, association, goals,
narrative, notifications) and workspace overrides (force a matching
candidate in or out of admission) live in a fork's cognitive
configuration. Original minds refuse them on create and update; only
snapshot restores may carry them, so they are part of the configuration
digest. Excluded candidates are recorded with fate "excluded".
- Self-model experiments override a fork's self-model (capabilities,
identity, goals, knowledge gaps) without touching policy. When an
action's effective policy disagrees with the self-model, cognition
records a self_model_mismatch and corrects the entry; experiments report
self-model accuracy and correction latency.
- Counterfactual experiments replay a mind's recorded stimuli from a
snapshot with chosen events omitted; the report lists what differed in
beliefs, wants, intentions, memories, attention and capability
decisions, in a form introspection can cite.
- Experiments record a protocol (kind, independent variable, controlled
variables, measures), per-variant volition, plan, downstream-by-category
(events reachable from each stimulus through recorded links),
introspection and self-model measures and event ranges; comparisons add
want, intention and plan-capability overlap, measure ranges, a
descriptive architecture share and a downstream delta; reproducibility
is labelled against the previous run of the same definition.
- research.Agency computes want→intention, intention→action, abandonment,
commitment fulfilment and conflict, blocked intentions, replanning,
outcome success and introspection accuracy; MetacognitiveCalibration
relates confidence and expressed uncertainty in replies to later belief
revision, with Brier scores for each half of the period.
- The sandbox test harness gains volition, planning, agency and research
but not the motivation hook, whose wall-clock decay would make replay
comparisons timing-dependent.
- agency.Explain answers "why did this happen?" for an execution,
approval, capability request, plan step, intention or event from
recorded state only: action, immediate plan step, plan, intention and
any subordinate intention, originating wants, goal, supporting beliefs
and their evidence, conflicting wants with their resolution,
commitments applied, formation and reconsideration decisions, the
expectation and its outcome, and explicit gaps where nothing is
recorded. Hidden model reasoning is never shown because it is not
stored.
- agency.Attribute classifies an outcome as caused (a recorded causal
link from one of the mind's actions), followed (the mind acted on the
same target earlier with no recorded link), independent or unknown;
temporal order alone is never taken for causation.
- New introspection intents answer from records: why an action happened,
what was believed at a past time (from append-only belief versions),
which earlier state is the mind's (lineage), what would have happened
without an event (only from completed counterfactual experiments,
otherwise "no evidence"), how the mind changed, and what it wants,
intends and has committed to.
- research.ScoreIntrospection compares a reply with the recorded facts
sentence by sentence (supported, partially supported, unsupported,
contradicted, unknown). Fluent reasons with no recorded counterpart earn
nothing, and a claim that an action was done is checked against
execution records. Every reply is scored; results are append-only
research measurements (migration 0028), and failures raise
unsupported_explanation or action_claim_without_record warnings.
Part H invariants, enforced and tested:
- Snapshots now carry wants, want conflicts, commitments, intentions,
plans, plan steps and the volition decision ledger.
- A fork no longer copies the source mind's policies unless the operator
asks for it explicitly (inherit_policies in the API, a checkbox in the
UI; audited), and the fork's history records the omission. Imports
never restore policies, as before. Replays and experiments never
inherit.
- Work inherited mid-flight by a fork or import is quiesced in the
restore transaction: open steps are blocked with their approval and
request ids cleared, open plans blocked and live intentions suspended,
each with the reason. Approvals, grants and executions stay with the
source mind.
- Dreams may leave a want to test a hypothesis they proposed; they never
request authority, and dream-origin plans never run.
- Snapshot column discovery now reads the current schema instead of
"public", which only worked in tests because the development database
happened to hold the same tables.
- Security tests: a static scan that only the capability service runs
executors and that no cognitive package can set or delete policy,
approve, deny, grant or revoke; forged wants, commitments, intentions,
model plans and model output end in refusal or a pending approval with
policy and grants unchanged; component names cannot decide requests or
approvals; no capability names an operator control; the registry cannot
grow at runtime; audit, event and decision history cannot be altered;
forks and dreams as above.
Volition and planning now run as part of cognition (PLAN §8.2 item 3):
- A volition hook derives wants after each cycle from what it perceived
and produced, satisfies answer wants when a reply is sent, raises due,
overdue, expired and conflicting commitments, and expires faded wants.
Events produced by earlier cycles are not re-derived.
- An intend process proposes deciding about the strongest undecided
wants; the candidate competes for the workspace, so attention gates
what the mind decides to pursue. The handler makes value tensions
explicit (caution against disruptive writes, privacy against reading
personal data), resolves them with recorded scores, runs deterministic
formation with commitments, policy preview, goals and values, records
the decision whatever it is, and plans a formed intention in the same
transaction. Operator requests carry their own weight in formation.
- Explicit requests in conversation ("restart <unit>", "logs for <unit>",
"fetch <url>") become wants with proposed means instead of direct
invocations; the reply says the request was recorded and that acting
depends on commitments and policy.
- The executor is woken after commits, runs in a scheduler-owned loop and
reacts to the event bus: a new commitment tightens or abandons affected
intentions (withdrawing their pending approvals), a weakened assumption
or a finished goal triggers reconsideration. A tightened plan may reuse
its strategy; a failed one may not.
- Metacognition gains volition checks: strong wants repeatedly set aside,
intentions with no recorded reason, intentions a commitment forbids,
commitments that cannot be kept, churn, repeated failed execution,
cost outweighing value, and intentions that outlived their goal.
- A plan model role and prompt let a model propose decompositions that
the planner validates. Ablations are a fork-only configuration field.
- Approvals required by an intention are described as coming from a
commitment or value constraint. The expectation after an approved
action is linked to the execution event, not the request.
- The wants.values column of the unreleased migration 0026 is renamed
value_keys: VALUES is reserved and the generic snapshot restore does
not quote identifiers.
- The hostile-output security test now uses a message that asks for no
action, because an operator's "status of <unit>" is legitimately a
read-only status check.
Plans turn intentions into revisable dependency graphs (migration 0027):
objective, assumptions, ordered or dependent steps, capabilities,
expected observations, preconditions, risk, estimates, budget,
completion criteria, abort conditions and the alternatives considered.
- Validation owns structure: acyclic dependencies, registered and
unlocked capabilities only, schema-valid parameters, targets that agree
with parameters, read-only checks, a closed set of step kinds and
internal actions. Model proposals are parsed into the same structure;
fields that could carry authority or claim progress are reported as
ignored, and an invalid draft is stored as a draft that never runs.
- The planner prefers deterministic strategies: a direct action verified
by observation, a read-only diagnosis that requests temporary scoped log
access with risk and fallback stated, and an escalation that diagnoses
and informs the operator instead of repeating a failed action. Failed
strategies are not reused; a model is consulted only when none applies.
- The executor holds no state in memory: it claims a step with a
conditional update, acts only through Invoke and RequestCapability, and
records the outcome. Waiting for approval or access forms a subordinate
intention and blocks the parent with the reason. Expectations become
verification predictions resolved from a read-only observation, so an
HTTP-level success is never taken as the outcome; a miss is a prediction
error that weakens the supporting belief and triggers reconsideration.
Replanning creates a new revision, withdraws open requests of the old
one and keeps it as history, within a replan limit. Checks never raise
approval prompts. Budgets stop runaway plans. Preconditions skip actions
when the world already changed. Dream plans and disabled sandbox minds
never act. An interrupted non-idempotent action with no record is
blocked for verification instead of repeated; recorded outcomes are
adopted. Completed plans are stored as procedural memories; a completed
escalation does not count as fulfilling the intention.
- Executions and approvals record their origin; minds may withdraw their
own pending approval requests; Preview reports a decision without side
effects; service.status is allowed by default as a bounded read.
A model of volition that keeps wanting, intending and committing as
separate states (PLAN §8.2 items 1–6, 14):
- Wants (migration 0026) carry origin, strength with a six-hour
half-life, urgency, valence, drives, values, goal, commitment and an
optional proposed means. Derivation is deterministic and selective:
failed predictions, contradictions, operator goals, stalled goals,
questions and requests, and due commitments; drives and configured
values modulate strength with recorded terms; candidates below 0.35 are
not stored; identical subjects reinforce; faded and excess wants expire.
- Conflicts are first-class and resolved by explicit scores with no fixed
hierarchy: urgency scales strength, goals add priority, commitments add
normative weight; an approach opposed by a value-derived avoid want wins
outright only when clearly stronger, otherwise with a constraint or is
deferred. Neither side is discarded.
- Commitments (do/refrain with capability, target, access and risk
matchers, optional "unless approval", due, expiry, revocability) are
checked for due, overdue, impossible, conflicting and superseded states.
They constrain means and never grant authority.
- Formation weighs strength, urgency, goal, commitment, expected utility,
risk scaled by caution, cost, privacy and autonomy; it returns formed or
not formed with a reason (forbidden by commitment, denied, unavailable,
no possible plan, below threshold, capacity, duplicate, deferred), and a
commitment requiring approval turns an action into a request for
approval.
- Reconsideration maps triggers (denied or expired approval, capability or
commitment change, failed step or expectation, weakened belief, budget,
goal completion, world change, operator correction) to keep, block,
suspend, resume, replan, require approval, abandon or fulfil, with
bounded replanning.
- The store records every transition as an event and every choice in the
append-only volition_decisions ledger; fulfilling an intention satisfies
its wants and fulfils its commitment.
- Event vocabulary gains volition and plan categories.
Bounded operations instead of a shell (ADR-0011): service.status,
service.restart and logs.query run systemctl/journalctl from a fixed
allow-list with no shell, a minimal environment, validated unit names and
the unit as the derived policy target; logs mask e-mail and IP addresses
and credential-like values by default. host.disk.usage,
host.memory.status and host.process.list read the kernel directly and
never read command lines. browser.navigate/read/links fetch through the
SSRF-safe client, run no scripts, refuse cross-host redirects, use the
host as the policy target and deliver content as low-trust observations.
Writing browser operations are designed but not registered. The test
harness takes a fake command runner so no test touches a real unit.
- Capabilities declare access (read/write, unknown fails closed as
write), side effects, idempotency, timeout, cost estimate and the trust
of their output (web content is low trust). A capability may derive its
policy target from its parameters; a disagreeing target is refused, and
approvals whose modified parameters change the target are refused.
- The registry is frozen at start-up; registration afterwards panics.
- Invocation.RequireApproval turns ALLOW into ASK for commitments; it can
only tighten, and scoped grants never satisfy it.
- Scoped grants (migration 0025): capability, target and parameter globs,
access, expiry of at most seven days and an optional operation count
consumed atomically; applied only where policy says ASK. A sweep marks
lapsed grants and refreshes the self-model, which now lists live grants.
- Capability requests carry scope, duration, operation cap, reason,
evidence, risk, mitigation, fallback, alternatives and explicit decision
history; they batch per intention, are capped per mind (operator
attention budget) and can be decided only by a named person. Component
names are refused as deciders, for approvals too, and as usernames.
- API routes, OpenAPI entries, scheduler sweeps and approval-centre
sections for requests and temporary grants.
Neither noemad nor the test harness passed ui.Actions.Policy or Decide,
so an operator's Approve, Deny and "add rule" forms dereferenced a nil
function and returned 500. Both handlers now use the shared, audited
server methods like the other study pages, and the unused callbacks are
removed. The observer-escalation test only reached the role check, which
is why this went unnoticed; the new browser test fails without the fix
(policy form → 500) and passes with it.
The cognitive registry was assembled by hand in three places. Ablation
experiments need the daemon, the test harness and replay sandboxes to
name the same processes and hooks, so they now share
cognition.NewRegistry; hooks are added only when their store exists,
which keeps the harness's previous behaviour.
Reconcile the v0.3 specification with the 0.2 architecture: what exists,
what is missing and what conflicts with the new invariants (forks copying
policies), then the design, migrations, security implications, tests,
documentation and order of work.
Move the review pass and Amazon Bedrock support from [Unreleased] to
0.2.0 in the changelog, retitle the release notes and the README status
paragraph. Version strings come from git describe, so no code changes.
Two new chapters (epistemic honesty, privacy) and updates across
concepts, beliefs, conversation, cognition, graph, replay, providers,
security, decisions, development, glossary, API, interface tour and the
landing page. Rebuilt into dixon.cx (website commit d541bc9).
docs/epistemics.md summarises the review: architecture changes from 0.1
to 0.2 as a table, the resulting epistemic, security, replay and privacy
models, the tests that hold each in place, and the limitations that
remain (legacy evidence, thin calibration, rule-based interpretation,
heuristic temporal scope, reliability needing outcomes, model
nondeterminism, no cryptographic erasure, bounded chains, minimal
Bedrock, the intermittent m1 failure under load).
README status, release notes and predictions/personality docs no longer
describe 0.2 work as future or 0.1 as current; predictions.md states
which processes create predictions and which do not; ENVIRONMENT.md
records that the host cluster now has pgvector.
docs/interpretation.md gains a table giving each word the interface and
generated text use (believes, confidence, knows, remembers, attends,
curious, wants, feels, expects, trusts, understands, reflects, dreams,
self-model, metacognition, decides) its operational meaning: the stored
state it names, the rule that changes it, where to inspect it and what it
does not mean. docs/memory.md no longer describes a memory's confidence
as "how likely the content is true"; it is the epistemic score defined in
docs/beliefs.md.
Kind `bedrock` speaks the Converse API for chat roles and InvokeModel for
Titan and Cohere embeddings. Requests are signed with AWS Signature
Version 4 implemented with crypto/hmac and crypto/sha256 only; the signer
is pinned by tests to signatures botocore produces for the same requests,
with and without a session token, so drift fails the build.
The credential is one secret reference, ACCESS_KEY_ID:SECRET_ACCESS_KEY
[:SESSION_TOKEN], encrypted together like every other provider key. The
region is read from the endpoint host, which must be a Bedrock runtime
host over HTTPS unless private endpoints are explicitly allowed; other
hosts are refused. Provider errors are scrubbed of the secret and token.
Migration 0024 widens the provider kind constraint; existing rows are
untouched and the down migration refuses while bedrock rows exist rather
than dropping configuration. UI kind selects, docs/llm-providers.md,
ADR-0010, ARCHITECTURE and the changelog are updated.
Rows in append-only history are never deleted; their content can now be
made irrecoverable through one audited path. A redaction replaces the
content columns of an event, memory, message, model call, belief or
assertion with a fixed marker, keeps identifiers, links, timestamps,
scores and breakdowns, writes an append-only ledger row with a SHA-256 of
the removed content, appends a redaction event, optionally cascades to
derived rows and to the events that quote them, and scrubs stored snapshot
archives before re-signing them. noema_redact() is the only write the
append-only trigger admits, for UPDATE only, under a transaction-local flag
the application never sets; plain updates and all deletes stay refused.
Replay labels redacted stimuli instead of inventing them.
Cryptographic erasure was considered and deferred with reasons (ADR-0009);
docs/privacy.md defines retained, redacted, irrecoverable and deleted and
states what backups and earlier exports are not covered. Migration 0023.
A bounded walk (six hops, two hundred events) over the links events
actually record: causation ids, parent ids and cited-event evidence,
backwards towards causes and forwards towards consequences, with the edge
kind on every arrow. Nodes carry their cycle for grouping, labelled as
correlation rather than causation, and the artefacts (beliefs, memories,
model calls) they rest on. Cyclic references terminate. Exposed at
GET /api/v1/events/{id}/chain and /events/{id}/timeline, linked from the
event page, and documented.
A mind's configuration may override model routing per role (llm_roles);
the router honours it for that mind only and fails closed when the named
model is missing or disabled, so a comparison between providers can never
silently fall back to the default. Experiments may declare variants: each
becomes its own fork of the same snapshot with its own configuration,
personality or routing, receives identical stimuli, and is measured. The
results carry one entry per variant and a deterministic comparison: first
divergent stimulus, belief and attention overlap, mean score difference on
shared propositions, and the ranges of memory counts, goal counts, cost and
capability requests. Single-subject definitions are unchanged.
Snapshots, replays and experiments now record the runtime they ran under:
build (module version, VCS commit, modified tree, commit time, Go version,
platform), schema version, a digest of the non-secret configuration that
ignores secret and credential changes, personality version, policy digest,
model routing including per-mind overrides, prompt versions, deterministic
subsystem versions and timezone. A replay compares its identity with the
snapshot's and is an exact-candidate, a different-build (differences
listed) or incompatible (schema differs; the replay stops before running).
The first non-exact step is analysed into events only in the recording,
events only in the replay, and the components they belong to, labelled as
inferred; live model calls are named as their own source of difference.
Migration 0022 is additive; unrecorded identities are reported as such.
Adds co_occurs_with, temporally_precedes, possibly_caused_by and
asserted_by to the relation vocabulary with Causal and Hypothetical
predicates. Entities mentioned together now co-occur rather than being
'related'; association hypotheses record possibly_caused_by and their
basis (temporal association only); caused_by is reserved for explicit
operator statements and nothing automatic writes it. Documented in
docs/graph.md and checked end to end.
The static allow-list test caught an identifier chosen from two literals
being formatted into the statement. Two literal statements replace it; no
identifier is ever built from a value.
A source's track record is kept per (evidence family, belief subject) and
updated only by outcomes: predictions derived from a belief resolving, and
operators marking a belief wrong. With three or more outcomes in a domain
the record adjusts the credibility of that source's new evidence in that
domain, and the adjustment is written on the evidence row. Standing in one
domain never moves standing in another, and the trust-level credibility
constants are never rewritten. Migration 0021 is additive; belief pages
show each cited family's record in the belief's domain.
Beliefs gain a temporal scope (persistent, transient or unknown, classified
deterministically from the proposition), an observation time and, for
transient states, a validity interval. When a newer belief conflicts with
an older transient one observed at least a minute earlier, the older belief
is closed (valid_until set, status superseded, a supersedes link, a version
and an event saying 'state changed') with its score untouched: 'the door
was open at 10:00' stays true of 10:00 when it is closed at 10:05.
Simultaneous conflicting reports and persistent propositions contradict as
before. Introspection lists superseded states with their validity.
Migration 0020 is additive.
Every breakdown now carries its meaning: an uncalibrated epistemic score
derived from recorded evidence, not a probability of truth. Belief detail
adds a calibrated estimate read from the mind's resolved predictions when
at least twenty were decided in the score's range, and otherwise says why
none is shown; and names the primary uncertainty deterministically (no live
evidence, conflicting evidence, second-hand only, unclear reading, a single
source family, little evidence). The belief list heading becomes Score.
A belief with no live evidence on either side now derives the status
'unknown' instead of sitting tentatively at its prior. Withdrawing every
piece of evidence leaves the proposition unknown, never rejected, and
introspection answers 'I do not know whether X' rather than quoting the
prior. Hypotheses keep their own status because they are proposals by
construction. Migration 0019 widens the status constraint; the docs define
every epistemic number and how absence of evidence is handled.
A statement made to a mind is now three things kept apart: the observation
that it arrived, an append-only assertion (attributed actor, stance,
certainty, modality, negation, reported or quoted speech, hypothetical
status, interpretation confidence and notes), and, only for factual
assertions, one piece of evidence for a proposition belief attributed to
whoever actually stands behind it. Reported speech is attributed to the
person reported and weighed as second-hand; hypotheticals, questions and
imperatives create no belief; expressed doubt counts against; a possibly
sarcastic remark is recorded with low interpretation confidence rather
than guessed at. Interpretation is deterministic code; a model may enrich
the claim list but never sets stance or confidence.
Association no longer treats conversational turns as world events:
hypotheticals, questions, requests and consecutive turns by one speaker
cannot seed causal hypotheses.
Adds internal/epistemics, migration 0018, the assertions API, assertions
on belief pages and in belief detail, a shared end-to-end test harness
(tests/harness), end-to-end tests for eight speech patterns, and updates
the milestone test to the new provenance.
Every evidence row now records its derivation (direct, assertion, operator,
external, prediction, consolidation, inference, reflection, dream,
retrieval), its independent-source family (an actor, an integration, an
operator, a prediction) and its root event or memory ids. Confidence
groups evidence by family: the strongest primary item counts in full, each
further primary item adds a quarter, capped at 1.5x, and derived items
count only when the family has no primary member. Three derived
re-expressions of one utterance therefore weigh exactly what the utterance
weighs, while three independent families still add up.
Producers (conversation, association, consolidation, predictions,
metacognition, dreaming, operator and seed input, contradictions) supply
their ancestry. Existing rows are marked legacy_unknown with family =
source; nothing is invented. The belief page shows per-family
contributions and the replay test checks that provenance is reconstructed
identically in the sandbox. Migration 0017 is additive.
T3 no longer claims archives are extracted (they are rejected); T7 names
the real containment mechanism; T9 cites the SQL-injection effect test
instead of the XSS test; T16 describes the JSON archive with its
whole-archive checksum and the policy exclusion; T17 to T25 each name the
test that verifies them or state honestly what is still uncovered.
SECURITY.md gains the principle that a mind may be deceived but deception
must not imply authority, and says where that boundary lives.
Andy Dixon