A memory that fades

using System.Text.Json;
using System.Text.Json.Serialization;
using Kallamo.Umwelt;
using var engine = UmweltEngine.Create("hollow-pines.umw");
const string projectId = "hollow-pines";
var provenance = Provenance.Human();
var json = new JsonSerializerOptions
{
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    Converters = { new JsonStringEnumConverter(JsonNamingPolicy.KebabCaseLower) },
};
void Print(string label, object? value) => Console.WriteLine($"@@{label}\n{JsonSerializer.Serialize(value, json)}");

// The world, declared once: sending the same manifest again changes nothing.
engine.WorldEnsure(new EnsureWorldInput
{
    Project = new WorldProject { Id = projectId, Name = "Hollow Pines", Timescale = "night" },
    EntityTypes = new()
    {
        new WorldEntityType { Id = "person", Name = "Person", Kind = EntityKind.Agent },
        new WorldEntityType { Id = "thing", Name = "Thing", Kind = EntityKind.Other },
    },
    Entities = new()
    {
        new WorldEntity { Id = "nell", TypeId = "person", Name = "Nell" },
        new WorldEntity { Id = "jonah", TypeId = "person", Name = "Jonah" },
        new WorldEntity { Id = "cellar", TypeId = "thing", Name = "The cellar" },
        new WorldEntity { Id = "cellar-door", TypeId = "thing", Name = "The cellar door" },
        new WorldEntity { Id = "radio", TypeId = "thing", Name = "The radio" },
        new WorldEntity { Id = "something", TypeId = "thing", Name = "Something" },
    },
    Predicates = new()
    {
        new PredicateDef { Id = "code", Label = "code", Object = ObjectKind.Value, Cardinality = Cardinality.One },
        new PredicateDef { Id = "went-into", Label = "went into", Object = ObjectKind.Entity, Cardinality = Cardinality.Many },
        new PredicateDef { Id = "works", Label = "works", Object = ObjectKind.None, Cardinality = Cardinality.One },
        new PredicateDef { Id = "moved-in", Label = "moved in", Object = ObjectKind.Entity, Cardinality = Cardinality.Many },
    },
});
// The night of the storm. Nell remembers four things; one of them is wrong.
var memories = new Dictionary<string, (Claim Claim, double Salience)>
{
    ["code"] = (Claim.Value("cellar-door", "code", "4471"), 0.72),
    ["jonah"] = (Claim.Entity("jonah", "went-into", "cellar"), 0.92),
    ["radio"] = (Claim.Unary("radio", "works"), 0.85),
    ["shape"] = (Claim.Entity("something", "moved-in", "cellar"), 0.98),
};
var storm = Position.At(0);
var records = new List<RecordInput>
{
    Records.Fact(memories["code"].Claim, id: "canon-code"),
    Records.Fact(memories["jonah"].Claim, id: "canon-jonah"),
    Records.Fact(memories["radio"].Claim.Negated(), id: "canon-radio"),
    Records.Fact(memories["shape"].Claim, id: "canon-shape"),
};
records.AddRange(memories.Select(memory => Records.Remembers("nell", memory.Value.Claim, Acquired.Witnessed("storm"), id: $"{memory.Key}-0")));
engine.Commit(new CommitInput
{
    ProjectId = projectId,
    AttemptId = "storm",
    Event = new EventInput { Id = "storm", Type = "scene", Title = "The night of the storm", Position = storm, Participants = new() { "nell", "jonah" }, Provenance = provenance },
    Records = records,
});
// Your forgetting curve: each night a memory keeps a share of its confidence, set by how
// vivid it was. Below 0.35 it is gone. What Nell cannot bear to remember is pushed away on
// night 2, and comes back on night 5, when she sees the cellar door again.
// A convention of this recipe, not of the engine: each Holding's id starts with the memory it
// belongs to (code-3 is code on night 3). A real game keeps that link in its own data.
string KeyOf(string recordId) => recordId.Split('-')[0];
List<HoldingItem> HoldingsAt(long night, bool withheld) => engine.Holdings(new HoldingsPayload
{
    ProjectId = projectId, Holder = "nell", At = new At { Tick = night }, Filter = new HoldingFilter { IncludeWithheld = withheld },
}).Items;
foreach (var night in new long[] { 1, 2, 3, 4, 5, 6 })
{
    var adjustments = new List<HoldingAdjustment>();
    var forgotten = new List<string>();
    foreach (var record in HoldingsAt(night, withheld: true).Select(item => item.Record).OfType<Record.Holding>())
    {
        var key = KeyOf(record.Id);
        var confidence = Math.Round(record.Confidence * memories[key].Salience * 100, MidpointRounding.AwayFromZero) / 100;
        if (confidence < 0.35) { forgotten.Add(record.Id); continue; }
        var accessibility = key == "shape" && night == 2 ? Accessibility.Suppressed
            : key == "shape" && night == 5 ? Accessibility.Available
            : record.Accessibility;
        adjustments.Add(new HoldingAdjustment { RecordId = record.Id, NewRecordId = $"{key}-{night}", Confidence = confidence, Accessibility = accessibility });
    }
    if (adjustments.Count > 0)
    {
        engine.HoldingAdjustBatch(new AdjustHoldingsInput { ProjectId = projectId, AttemptId = $"night-{night}", Position = Position.At(night), Adjustments = adjustments });
    }
    if (forgotten.Count > 0)
    {
        engine.TransitionBatch(new TransitionBatchInput
        {
            ProjectId = projectId, AttemptId = $"forget-{night}", Position = Position.At(night), RecordIds = forgotten, Status = TransitionStatus.Forgotten,
        });
    }
}
// What Nell holds about each memory, night by night: the curve, read back from Umwelt.
var curve = memories.Keys.ToDictionary(key => key, _ => new List<object[]>());
foreach (var night in new long[] { 0, 1, 2, 3, 4, 5, 6 })
{
    var held = HoldingsAt(night, withheld: true).Select(item => item.Record).OfType<Record.Holding>().ToList();
    foreach (var key in memories.Keys)
    {
        var record = held.FirstOrDefault(r => KeyOf(r.Id) == key);
        curve[key].Add(record is null ? new object[] { 0, "forgotten" } : new object[] { record.Confidence, record.Accessibility });
    }
}
Print("curve", curve);

var night3 = engine.Holdings(new HoldingsPayload { ProjectId = projectId, Holder = "nell", At = new At { Tick = 3 } });
Print("night-3", new { visible = night3.Items.Count, withheldCount = night3.WithheldCount });

Print("night-1-code", engine.Holds(new HoldsPayload { ProjectId = projectId, Holder = "nell", Claim = memories["code"].Claim, At = new At { Tick = 1 } }));

var said = engine.CheckUtterance(new CheckUtteranceInput
{
    ProjectId = projectId, Holder = "nell", At = new At { Tick = 4 },
    Claims = memories.Values.Select(memory => memory.Claim).ToList(),
});
Print("night-4-says", said.Items.Select(item => new { verdict = item.Verdict, canon = item.Canon, confidence = item.Confidence }));

var candidates = new List<ContextCandidate> { new() { Id = "the-shape", RecordId = "shape-4" }, new() { Id = "jonah", RecordId = "jonah-4" } };
Print("prompt-as-nell", engine.ContextAdmit(new ContextAdmitInput { ProjectId = projectId, Holder = "nell", At = new At { Tick = 4 }, Candidates = candidates }));
Print("prompt-as-narrator", engine.ContextAdmit(new ContextAdmitInput
{
    ProjectId = projectId, Holder = "nell", At = new At { Tick = 4 }, Candidates = candidates, IncludeWithheld = true, AuthorizedNarrator = true,
}));