riskrails 4.1.0 → 4.3.0

package/skills/ai-task/memory_cleanup.py

@@ -0,0 +1,213 @@
+"""Cleanup, restore, redaction (§D6, §D13) and pack (§D4, R7): the writers that remove, bring back, blank
+or archive what a package holds."""
+import json
+import os
+import re
+import shutil
+
+import memory_config as mcfg
+import memory_format as mf
+import memory_io as mio
+import memory_packages as mpkg
+import memory_verify as mver
+
+
+# ------------------------------------------------------------------ cleanup, restore, redact (§D6, §D13)
+def cleanup_ready(root, task_id, cfg, packages=None):
+    """The R22 conditions for one task, or the first that fails."""
+    packages = packages if packages is not None else mpkg.load_packages(root)
+    seals = [(n, e) for n, (_, entries, _) in packages.items() for e in entries
+             if e.get("kind") == "task" and e.get("task") == task_id]
+    if not cfg.cleanup:
+        return "cleanup is off in %s" % mio.POLICY_REL
+    if not seals:
+        return "no seal for %s in a package in the working tree" % task_id
+    findings = mver.check_packages({n: packages[n] for n, _ in seals}, cfg.package_max_bytes)
+    if findings:
+        return "its package does not verify (%s)" % findings[0].what
+    for _, seal in seals:
+        if (seal.get("counts") or {}).get("skipped"):
+            return "%s has %s torn journal line(s)" % (mf.key_of(seal), seal["counts"]["skipped"])
+    journal = mio.read_bytes(os.path.join(root, ".ai", "reports", task_id, "events.jsonl"))
+    if journal is not None:
+        found = mver.check_journals(lambda rel: journal if rel.endswith("events.jsonl") else None,
+                               [".ai/reports/%s/events.jsonl" % task_id], packages)
+        found = [f for f in found if f.check == "V5"]
+        if found:
+            return "coverage is incomplete (%s)" % found[0].what
+    return None
+
+
+def cleanup_task(root, task_id, cfg):
+    """B6: .ai/reports/<id> → .ai/state/logs/<id>/report; copy, verify,
+    remove when the two are on different filesystems."""
+    why = cleanup_ready(root, task_id, cfg)
+    if why:
+        raise mio.MemoryError_(why, 1)
+    src = os.path.join(root, ".ai", "reports", task_id)
+    dest = os.path.join(root, ".ai", "state", "logs", task_id, "report")
+    if not os.path.isdir(src):
+        return "%s already cleaned up" % task_id
+    os.makedirs(os.path.dirname(dest), exist_ok=True)
+    if os.path.exists(dest):
+        raise mio.MemoryError_("%s exists: 'state.py memory restore %s' first" % (os.path.relpath(dest, root), task_id), 3)
+    try:
+        if os.environ.get("AI_MEMORY_FORCE_EXDEV"):
+            raise OSError(18, "Invalid cross-device link (forced)")
+        os.replace(src, dest)
+    except OSError as exc:
+        if exc.errno != 18:
+            raise
+        shutil.copytree(src, dest)
+        if tree_digest(src) != tree_digest(dest):
+            shutil.rmtree(dest, ignore_errors=True)
+            raise mio.MemoryError_("the copy of %s does not match its source — nothing removed" % task_id, 3) \
+                from exc
+        shutil.rmtree(src)
+    return "%s → %s" % (os.path.relpath(src, root), os.path.relpath(dest, root))
+
+
+def tree_digest(path):
+    import hashlib  # pylint: disable=import-outside-toplevel
+    h = hashlib.sha256()
+    for dirpath, dirs, names in os.walk(path):
+        dirs.sort()
+        for name in sorted(names):
+            full = os.path.join(dirpath, name)
+            h.update(os.path.relpath(full, path).encode() + b"\0" + (mio.read_bytes(full) or b"") + b"\0")
+    return h.hexdigest()
+
+
+def cleanup(root, ids):
+    cfg = mcfg.load_config(root)
+    if not cfg.packages:
+        raise mio.MemoryError_("files mode: cleanup needs packages mode", 2)
+    if not cfg.cleanup:
+        raise mio.MemoryError_("cleanup is off: set \"cleanup\": true in %s once 'memory verify --all' and "
+                           "'--fresh-clone' are green (§D6)" % mio.POLICY_REL, 2)
+    findings = [f for f in mver.verify(root) if not f.check.endswith("-warn")]
+    if findings:
+        raise mio.MemoryError_("'memory verify --all' is not green: %s" % mver.format_finding(findings[0]), 1)
+    packages = mpkg.load_packages(root)
+    if ids == "all":
+        ids = sorted(mpkg.sealed_task_ids(packages) & set(os.listdir(os.path.join(root, ".ai", "reports"))))
+    out = []
+    for task_id in ids:
+        try:
+            out.append(cleanup_task(root, task_id, cfg))
+        except mio.MemoryError_ as exc:
+            out.append("%s kept: %s" % (task_id, exc))
+    return out
+
+
+def restore(root, ids):
+    import memory_store  # pylint: disable=import-outside-toplevel
+    logs = os.path.join(root, ".ai", "state", "logs")
+    if ids == "all":
+        ids = sorted(n for n in os.listdir(logs) if os.path.isdir(os.path.join(logs, n, "report"))) \
+            if os.path.isdir(logs) else []
+        history = memory_store.FileHistory(root, mcfg.load_config(root))
+        ids = sorted(set(ids) | {s.get("task") for s in history.seals().values()
+                                 if not os.path.isdir(os.path.join(root, ".ai", "reports", s.get("task") or "-"))
+                                 and mf.NEW_ID_RE.match(s.get("task") or "")})
+    out = []
+    history = None
+    for task_id in ids:
+        dest = os.path.join(root, ".ai", "reports", task_id)
+        raw = os.path.join(logs, task_id, "report")
+        if os.path.isdir(dest):
+            out.append("%s is in .ai/reports/ already" % task_id)
+            continue
+        if os.path.isdir(raw):
+            os.replace(raw, dest)
+            out.append("%s restored from %s" % (task_id, os.path.relpath(raw, root)))
+            continue
+        history = history or memory_store.FileHistory(root, mcfg.load_config(root))
+        entries = history.entries(task_id)
+        if not entries:
+            out.append("%s: nothing recorded" % task_id)
+            continue
+        os.makedirs(dest)
+        md = ["<!-- restored from record %s — a reconstruction, not the original task.md -->" % mio.now()]
+        md += mf.render_task_md(entries)
+        mio.atomic_write(os.path.join(dest, "task.md"), "\n".join(md) + "\n")
+        lines = []
+        for e in entries:
+            data = {k: v for k, v in e.items() if k not in mf.ENVELOPE}
+            data["restored"] = True
+            data["rid"] = e["rid"]
+            lines.append(json.dumps({"ts": e["ts"], "task": task_id, "event": "restored_%s" % e["kind"],
+                                     "actor": e["actor"], "runtime": e["runtime"], "stage": "",
+                                     "detail": "restored from record", "data": data}, ensure_ascii=False))
+        mio.atomic_write(os.path.join(dest, "events.jsonl"), "\n".join(lines) + "\n")
+        out.append("%s restored from record (task.md marked, events.jsonl with data.restored)" % task_id)
+    return out
+
+
+def redact(root, rid, field, why, by=None):
+    """The one exception to append-only (R8): the field becomes "[redacted]",
+    the line gets a new rid, a redaction entry names the old one."""
+    cfg = mcfg.load_config(root)
+    with mio.locked(root):
+        packages = mpkg.load_packages(root)
+        for name, (header, entries, _) in packages.items():
+            hit = [e for e in entries if e["rid"] == rid]
+            if not hit:
+                continue
+            entry = mf.strip_private(hit[0])
+            if field in mf.ENVELOPE or field not in entry:
+                raise mio.MemoryError_("%s has no redactable field %r" % (rid, field), 2)
+            new = dict(entry, **{field: "[redacted]"})
+            new = mf.with_rid(new)
+            note = mf.with_rid({"v": mf.FORMAT, "task": entry.get("task"), "inst": entry.get("inst") or 1,
+                                "seq": entry.get("seq") or 0, "kind": "redaction", "ts": mio.now(), "actor": "human",
+                                "by": by, "runtime": "unknown", "src": ["state.py memory redact"],
+                                "target": rid, "field": field, "why": why, "replacement": new["rid"]})
+            rest = [mf.strip_private(e) for e in entries if e["rid"] != rid]
+            mio.atomic_write(os.path.join(mio.memory_dir(root), name), mf.render_package(header, rest + [new, note]))
+            del cfg
+            return new["rid"], name
+    raise mio.MemoryError_("no entry %s in .ai/memory/" % rid, 1)
+
+
+# ------------------------------------------------------------------ pack (§D4, R7)
+def pack(root, period):
+    cfg = mcfg.load_config(root)
+    if not re.match(r"^\d{4}(?:-\d{2}|-Q[1-4])?$", period or ""):
+        raise mio.MemoryError_("--period takes YYYY-MM, YYYY-Qn or YYYY", 2)
+    grain = "quarter" if "-Q" in period else ("month" if "-" in period else "year")
+    current = mf.period_of(mio.now(), grain)
+    if period >= current:
+        raise mio.MemoryError_("period %s has not ended (now %s)" % (period, current), 2)
+    with mio.locked(root):
+        packages = mpkg.load_packages(root)
+        mine = [n for n in packages if (mf.parse_package_name(n) or {}).get("period") == period
+                and (mf.parse_package_name(n) or {}).get("author") == cfg.author]
+        if not mine:
+            raise mio.MemoryError_("no package of %s for %s" % (cfg.author, period), 1)
+        target = mf.package_name(period, cfg.author)
+        before = set()
+        entries = {}
+        for name in mine:
+            for e in packages[name][1]:
+                before.add(e["rid"])
+                entries[e["rid"]] = mf.strip_private(e)
+        seals = {mf.key_of(e): e for e in entries.values() if e.get("kind") == "task"}
+
+        def order(e):
+            seal = seals.get(mf.key_of(e)) or {}
+            return (seal.get("closed_at") or e.get("ts") or "", mf.key_of(e), e.get("seq") or 0, e["rid"])
+        ordered = sorted(entries.values(), key=order)
+        header = mf.package_header(period, cfg.author, None, mio.now())
+        data = b"\n".join([mf.canonical(header)] + [mf.canonical(e) for e in ordered]) + b"\n"
+        mio.atomic_write(os.path.join(mio.memory_dir(root), target), data)
+        _, check, errors = mf.parse_package(data, target)
+        if errors or {e["rid"] for e in check} != before:
+            raise mio.MemoryError_("the pack does not hold the batches' rid set — batches kept", 3)
+        removed = [n for n in mine if n != target]
+        for name in removed:
+            os.remove(os.path.join(mio.memory_dir(root), name))
+        books = mpkg.read_batches(root)
+        books["open"] = {b: n for b, n in books["open"].items() if n not in removed}
+        mpkg.write_batches(root, books)
+    return target, removed, len(before)

package/skills/ai-task/memory_compact.py

@@ -872,9 +872,34 @@ def _seal(ctx, entries, inst, last, state, started, closed, seal_src, summary, d
     if truncated:
         seal["truncated"] = truncated
     seal["unrecorded"] = sorted(set(unrecorded))
+    _fit_changes(seal)
     return mf.with_rid(seal)
 
 
+def _fit_changes(seal):
+    """GitHub #74: a seal line over mf.LINE_MAX_BYTES (a task that changed ~1200 files) is unreadable to
+    parse_package. Keep the longest prefix of `changes` whose line fits, say so in `truncated` and
+    `changes_truncated`. A seal that fits is untouched; the result depends only on the seal's own fields."""
+    rows = seal.get("changes")
+    if not isinstance(rows, list) or not rows or len(mf.canonical(mf.with_rid(seal))) <= mf.LINE_MAX_BYTES:
+        return
+    total = {k: sum(r[k] for r in rows if isinstance(r, dict) and isinstance(r.get(k), int)
+                    and not isinstance(r.get(k), bool)) for k in ("added", "deleted")}
+    seal["changes_truncated"] = {"rows": len(rows), "added": total["added"], "deleted": total["deleted"]}
+    seal["truncated"] = sorted(set(seal.get("truncated") or []) | {"changes"})
+    seal["changes"] = []
+    room = mf.LINE_MAX_BYTES - len(mf.canonical(mf.with_rid(seal)))
+    keep = 0
+    for row in rows:
+        room -= len(mf.canonical(row)) + (1 if keep else 0)
+        if room < 0:
+            break
+        keep += 1
+    seal["changes"] = rows[:keep]
+    while seal["changes"] and len(mf.canonical(mf.with_rid(seal))) > mf.LINE_MAX_BYTES:
+        seal["changes"] = seal["changes"][:-1]
+
+
 # ------------------------------------------------------------------ known-risks.md (§D9, R24)
 RISK_HEAD_RE = re.compile(r"^## (.+)$")
 RISK_FIELD_RE = re.compile(r"^- \*\*([^*]+)\*\*:\s?(.*)$")

package/skills/ai-task/memory_config.py

@@ -0,0 +1,120 @@
+"""The configuration of packages mode: the policy file's schema and defaults, MemoryConfig, loading and
+checking .ai/policies/memory.json, and the mode a project runs in."""
+import contextlib
+import os
+import re
+
+import memory_format as mf
+import memory_io as mio
+
+
+SCHEMA = 1
+DEFAULTS = {"schema": 1, "mode": "files", "period": "quarter", "package_max_bytes": 1048576, "cleanup": False,
+            "excerpt_max_bytes": 1024, "keep_rules": 1, "recall": {"budget_tokens": 1500, "max_items": 40}}
+
+
+# ------------------------------------------------------------------ configuration (§D11, §I6)
+def author_slug(name):
+    slug = re.sub(r"[^a-z0-9-]+", "-", (name or "").casefold()).strip("-")[:32].strip("-")
+    return slug if slug and mf.AUTHOR_RE.match(slug) else "unknown"
+
+
+class MemoryConfig:
+    """The project policy (.ai/policies/memory.json) and the developer's own
+    choices (.ai/local/memory/config.json)."""
+
+    def __init__(self, root, policy, local, present):
+        self.root, self.policy, self.local, self.present = root, policy, local, present
+
+    def __getattr__(self, name):
+        if name in ("mode", "period", "package_max_bytes", "cleanup", "excerpt_max_bytes", "keep_rules"):
+            return self.policy.get(name, DEFAULTS[name])
+        raise AttributeError(name)
+
+    @property
+    def recall_budget(self):
+        return int((self.policy.get("recall") or {}).get("budget_tokens", 1500))
+
+    @property
+    def recall_max_items(self):
+        return int((self.policy.get("recall") or {}).get("max_items", 40))
+
+    @property
+    def author(self):
+        return self.local.get("author") or author_slug(os.environ.get("USER") or os.environ.get("USERNAME"))
+
+    @property
+    def index(self):
+        return self.local.get("index") or "none"
+
+    @property
+    def packages(self):
+        return self.mode == "packages"
+
+
+def load_config(root):
+    path = os.path.join(root, mio.POLICY_REL)
+    present = os.path.exists(path)
+    policy = dict(DEFAULTS)
+    if present:
+        try:
+            loaded = mio.read_json(path)
+        except (OSError, ValueError) as exc:
+            raise mio.MemoryError_("%s is not valid JSON (%s): fix it, or 'state.py memory disable'"
+                               % (mio.POLICY_REL, exc)) from exc
+        if not isinstance(loaded, dict):
+            raise mio.MemoryError_("%s must be a JSON object" % mio.POLICY_REL)
+        schema = loaded.get("schema", 1)
+        if isinstance(schema, int) and not isinstance(schema, bool) and schema > SCHEMA:
+            raise mio.MemoryError_("%s has schema %s; this state.py knows %d — update the plugin"
+                               % (mio.POLICY_REL, schema, SCHEMA))
+        policy.update(loaded)
+        check_policy(policy)
+    local = {}
+    with contextlib.suppress(OSError, ValueError):
+        found = mio.read_json(os.path.join(root, mio.LOCAL_REL, "config.json"))
+        if isinstance(found, dict):
+            local = found
+    where = os.path.join(mio.LOCAL_REL, "config.json")
+    if local.get("author") is not None and not (isinstance(local["author"], str)
+                                                and mf.AUTHOR_RE.match(local["author"])):
+        raise mio.MemoryError_("%s: author %r is not a slug of [a-z0-9-]" % (where, local["author"]))
+    if local.get("index", "none") not in ("none", "sqlite"):
+        raise mio.MemoryError_("%s: index takes none or sqlite" % where)
+    return MemoryConfig(root, policy, local, present)
+
+
+def check_policy(policy):
+    """Every key of memory.json with its type (§I6): a wrong one is a refusal
+    naming the key, never a traceback inside close."""
+    def is_int(value, low):
+        return isinstance(value, int) and not isinstance(value, bool) and value >= low
+    problems = []
+    if not is_int(policy.get("schema"), 1):
+        problems.append("schema must be an integer (1)")
+    if policy.get("mode") not in ("files", "packages"):
+        problems.append('mode must be "files" or "packages"')
+    if policy.get("period") not in mf.PERIODS:
+        problems.append("period must be month, quarter or year")
+    if not is_int(policy.get("package_max_bytes"), 1024):
+        problems.append("package_max_bytes must be an integer of at least 1024")
+    if not isinstance(policy.get("cleanup"), bool):
+        problems.append("cleanup must be true or false")
+    if not is_int(policy.get("excerpt_max_bytes"), 0):
+        problems.append("excerpt_max_bytes must be an integer >= 0")
+    if policy.get("keep_rules") != 1:
+        problems.append("keep_rules must be 1")
+    recall = policy.get("recall")
+    if not (isinstance(recall, dict) and is_int(recall.get("budget_tokens", 1500), 1)
+            and is_int(recall.get("max_items", 40), 1)):
+        problems.append('recall must be {"budget_tokens": N, "max_items": N}')
+    if problems:
+        raise mio.MemoryError_("%s: %s" % (mio.POLICY_REL, "; ".join(problems)))
+
+
+def mode_of(root):
+    """'files' or 'packages' without raising: close must archive whatever happens."""
+    try:
+        return load_config(root).mode
+    except mio.MemoryError_:
+        return "files"

package/skills/ai-task/memory_export.py

@@ -0,0 +1,246 @@
+"""Export at close (§D5): the outbox, the compaction of a task into a package, the export itself, the
+lines it reports, the pending ids and the close hook."""
+import collections
+import contextlib
+import json
+import os
+
+import memory_cleanup as mclean
+import memory_compact as mc
+import memory_config as mcfg
+import memory_format as mf
+import memory_io as mio
+import memory_packages as mpkg
+
+
+# ------------------------------------------------------------------ export (§D5)
+def outbox_path(root, key):
+    task, inst = key.rsplit("#", 1)
+    return mio.local_path(root, "outbox", "%s~%s.jsonl" % (task, inst))
+
+
+def exportable(compactions):
+    return [c for c in compactions if c.seal and c.seal["result"] in ("closed", "abandoned", "restarted")]
+
+
+ExportResult = collections.namedtuple("ExportResult",
+                                      "package added sealed coverage failures conflicts already added_by_key")
+
+
+def compact_for_export(root, task_id, cfg):
+    found = mc.compact_instances(mc.FsReader(root), task_id, "close", cfg.excerpt_max_bytes)
+    problems = [p for c in found for p in c.problems if "torn journal" not in p]
+    if problems:
+        raise mio.MemoryError_(problems[0], 3)
+    ready = exportable(found)
+    if not ready:
+        raise mio.MemoryError_("%s has no closed instance to export" % task_id, 3)
+    return ready
+
+
+def write_outbox(root, compaction):
+    key = mf.key_of(compaction.seal)
+    lines = [mf.canonical(e) for e in compaction.entries + [compaction.seal]]
+    mio.atomic_write(outbox_path(root, key), b"\n".join(lines) + b"\n")
+    return key
+
+
+def read_outbox(root):
+    base = mio.local_path(root, "outbox")
+    out = {}
+    for name in sorted(os.listdir(base)) if os.path.isdir(base) else []:
+        if not name.endswith(".jsonl"):
+            continue
+        entries = []
+        for raw in (mio.read_bytes(os.path.join(base, name)) or b"").split(b"\n"):
+            if raw.strip():
+                with contextlib.suppress(ValueError, UnicodeDecodeError):
+                    entries.append(json.loads(raw.decode("utf-8")))
+        seals = [e for e in entries if e.get("kind") == "task"]
+        if seals:
+            out[mf.key_of(seals[-1])] = entries
+    return out
+
+
+def export(root, ids, cfg=None, stamp=None):
+    """B2–B4 for every id (or the pending ones); returns ExportResult. A
+    failure of one task keeps its outbox and is reported, never raised."""
+    cfg = cfg or mcfg.load_config(root)
+    if not cfg.packages:
+        raise mio.MemoryError_("files mode: nothing is exported ('state.py memory enable' turns packages on)")
+    failures, coverage, sealed, already, added_by_key = [], {}, [], [], {}
+    if ids == "pending":
+        ids = pending_ids(root, cfg)
+    ids = list(ids)
+    # A key with a seal in the tree is never sealed again from other sources: a
+    # second compaction of changed local sources (a restarted id, a cleaned-up
+    # directory) would add a degraded seal to an append-only record (R8, R9).
+    # The same seal is a repair: the rids it lacks come back, nothing else (V4, V5).
+    sealed_here = mpkg.seals_by_key(mpkg.load_packages(root))
+    for task_id in ids:
+        try:
+            for compaction in compact_for_export(root, task_id, cfg):
+                key = mf.key_of(compaction.seal)
+                coverage[key] = compaction.coverage
+                stored = {s["rid"] for _, s in sealed_here.get(key, [])}
+                if stored and compaction.seal["rid"] not in stored:
+                    already.append(key)
+                    continue
+                write_outbox(root, compaction)
+        except mio.MemoryError_ as exc:
+            failures.append((task_id, str(exc)))
+        except OSError as exc:
+            failures.append((task_id, "the outbox could not be written (%s)" % exc))
+    mio.crash("B2")
+    added, conflicts, name = 0, [], None
+    try:
+        with mio.locked(root):
+            outbox = read_outbox(root)    # under the lock: another close may have taken it
+            packages = mpkg.load_packages(root)
+            have = mpkg.all_rids(packages)
+            seals = mpkg.seals_by_key(packages)
+            recorded = {e.get("key"): set(e.get("rids") or []) for _, entries, _ in packages.values()
+                        for e in entries if e.get("kind") == "conflict"}
+            new, keep = [], {}
+            for key, entries in outbox.items():
+                seal_rid = [e for e in entries if e.get("kind") == "task"][-1]["rid"]
+                stored = {s["rid"] for _, s in seals.get(key, [])}
+                missing = [e for e in entries if e["rid"] not in have]
+                if (stored and seal_rid not in stored) or not missing:
+                    # Sealed meanwhile from other sources, or nothing lacking (a re-run, B4).
+                    os.remove(outbox_path(root, key))
+                    if key not in already:
+                        already.append(key)
+                    continue
+                new += missing
+                added_by_key[key] = len(missing)
+                keep[key] = entries
+            for key in coverage:
+                if key in seals and key not in keep and key not in already:
+                    already.append(key)   # another close took this outbox and sealed it (review L3)
+            for key, found in sorted(seals.items()):
+                # Two seals that arrived by a merge (one id closed in two clones):
+                # recorded side by side, never merged (R9).
+                rids = sorted({s["rid"] for _, s in found} - {s.get("supersedes") for _, s in found})
+                if len(rids) < 2 or key.rsplit("#", 1)[0] not in ids or set(rids) <= recorded.get(key, set()):
+                    continue
+                seal = found[-1][1]
+                conflict = mf.with_rid({
+                    "v": mf.FORMAT, "task": seal["task"], "inst": seal["inst"], "seq": seal["seq"] + 1,
+                    "kind": "conflict", "ts": max(s["ts"] for _, s in found), "actor": "agent", "by": None,
+                    "runtime": seal["runtime"], "src": ["export"], "key": key, "rids": rids,
+                    "reason": "two different seals for one key — kept side by side, never merged"})
+                if conflict["rid"] not in have:
+                    new.append(conflict)
+                conflicts.append(key)
+            if not new:
+                return ExportResult(None, 0, sealed, coverage, failures, conflicts, already, added_by_key)
+            name, branch, books = mpkg.open_batch(root, cfg, stamp)
+            path = os.path.join(mio.memory_dir(root), name)
+            header, current, _ = packages.get(name, (None, [], []))
+            parts = mf.parse_package_name(name)
+            header = header or mf.package_header(parts["period"], cfg.author, parts["batch"], stamp or mio.now())
+            current = [mf.strip_private(e) for e in current]
+            outbox = keep
+            if new:
+                data = mf.render_package(header, current + new)
+                mio.crash("B3")
+                mio.atomic_write(path, data)
+                added = len(new)
+                books["open"][branch] = name
+                mpkg.write_batches(root, books)
+            mio.crash("B4")
+            check = mpkg.load_packages(root)
+            present = mpkg.all_rids(check)
+            for key, entries in outbox.items():
+                seal = [e for e in entries if e.get("kind") == "task"][-1]
+                if all(e["rid"] in present for e in entries):
+                    os.remove(outbox_path(root, key))
+                    sealed.append(key)
+                else:
+                    failures.append((seal["task"], "read-back found %d of %d entries" % (
+                        sum(e["rid"] in present for e in entries), len(entries))))
+    except OSError as exc:
+        failures.append((",".join(sorted(coverage)) or "the outbox",
+                         "%s (%s)" % (exc.strerror or exc, getattr(exc, "filename", ""))))
+    if added and cfg.index == "sqlite":
+        mio.crash("B5")
+        index_import(root, cfg)
+    return ExportResult(name, added, sealed, coverage, failures, conflicts, already, added_by_key)
+
+
+def record_lines(result):
+    """What close and `memory export` print: each key newly sealed with what it
+    added, each key that was already sealed, each conflict recorded (review L5)."""
+    out = []
+    for key in result.sealed:
+        cov = result.coverage.get(key) or {}
+        out.append("record: %s (+%d entries, %s sealed, coverage %s/%s lines)" % (
+            os.path.join(mio.MEMORY_REL, result.package or "-"), result.added_by_key.get(key, 0),
+            key.rsplit("#", 1)[0], cov.get("accounted", "?"), cov.get("lines", "?")))
+    for key in result.already:
+        out.append("record: %s already sealed in %s — nothing added" % (key, mio.MEMORY_REL))
+    for key in result.conflicts:
+        out.append("conflict: %s has two different seals — recorded side by side, never merged "
+                   "('state.py memory show %s')" % (key, key.rsplit("#", 1)[0]))
+    return out
+
+
+def index_import(root, cfg):
+    """B5: the index learns the new package; any failure marks it stale."""
+    try:
+        import memory_store  # pylint: disable=import-outside-toplevel
+        memory_store.SqliteHistory(root, cfg).refresh()
+    except Exception:  # pylint: disable=broad-except  # a stale index is rebuilt by the next read
+        with contextlib.suppress(Exception):
+            import memory_store  # pylint: disable=import-outside-toplevel
+            memory_store.mark_stale(root)
+
+
+def pending_ids(root, cfg=None):
+    """Closed new-shape tasks (and anything in the outbox) without a seal:
+    B1 left them closed but not exported. Legacy ids wait for the migration."""
+    sealed = mpkg.sealed_task_ids(mpkg.load_packages(root))
+    found = set(k.rsplit("#", 1)[0] for k in read_outbox(root))
+    logs = os.path.join(root, ".ai", "state", "logs")
+    for name in os.listdir(logs) if os.path.isdir(logs) else []:
+        if not mf.NEW_ID_RE.match(name) or name in sealed:
+            continue
+        with contextlib.suppress(OSError, ValueError):
+            state = mio.read_json(os.path.join(logs, name, "state.json"))
+            if state.get("result") in ("closed", "abandoned"):
+                found.add(name)
+    del cfg
+    return sorted(found - sealed)
+
+
+def after_close(root, task_id, out=print):
+    """The one call close makes after archive_v7. Packages mode only; every
+    failure is one printed line and close still exits 0 (B4)."""
+    try:
+        cfg = mcfg.load_config(root)
+    except mio.MemoryError_ as exc:
+        out("memory: %s — the task is closed in files mode" % exc)
+        return None
+    if not cfg.packages:
+        return None
+    try:
+        pending = [t for t in pending_ids(root, cfg) if t != task_id][:mio.PENDING_MAX]
+        result = export(root, [task_id] + pending, cfg)
+    except (mio.MemoryError_, ValueError, OSError) as exc:
+        out("memory: export of %s failed (%s) — the task is closed; 'state.py memory export %s' retries"
+            % (task_id, exc, task_id))
+        return None
+    for failed, why in result.failures:
+        out("memory: export of %s failed (%s) — the task is closed; 'state.py memory export %s' retries"
+            % (failed, why, failed))
+    for line in record_lines(result):
+        out(line)
+    if cfg.cleanup and any(k.rsplit("#", 1)[0] == task_id for k in result.sealed + result.already):
+        mio.crash("B6")
+        try:
+            done = mclean.cleanup_task(root, task_id, cfg)
+            out("cleanup: %s" % done)
+        except mio.MemoryError_ as exc:
+            out("cleanup: %s kept in .ai/reports/ (%s)" % (task_id, exc))
+    return result

package/skills/ai-task/memory_format.py

@@ -275,7 +275,9 @@ def sort_entries(entries):
 
 def parse_package(data, name=None):
     """(header, entries, errors): errors are (line, what) pairs; a line that
-    fails is left out of entries, so a reader still sees the rest."""
+    fails is left out of entries, so a reader still sees the rest. A line over
+    LINE_MAX_BYTES is an error, and a valid entry on it is still kept, with its
+    byte length in `_over` (GitHub #74)."""
     errors, entries, header = [], [], None
     if isinstance(data, str):
         data = data.encode("utf-8")
@@ -293,7 +295,6 @@ def parse_package(data, name=None):
             raw = raw[:-1]
         if len(raw) > LINE_MAX_BYTES:
             errors.append((number, "line is %d bytes, over %d" % (len(raw), LINE_MAX_BYTES)))
-            continue
         try:
             obj = json.loads(raw.decode("utf-8"))
         except (UnicodeDecodeError, ValueError) as exc:
@@ -318,6 +319,8 @@ def parse_package(data, name=None):
             errors.append((number, "; ".join(problems)))
             continue
         obj["_line"] = number
+        if len(raw) > LINE_MAX_BYTES:
+            obj["_over"] = len(raw)
         entries.append(obj)
     if header is None and not errors:
         errors.append((1, "empty package"))
@@ -688,7 +691,8 @@ def render_task_md(entries):
         facts = seal.get("facts") or {}
         if facts:
             out += ["facts: (a) %s · (b) %s" % tuple(_fact(facts.get(k)) for k in ("a", "b")), ""]
-        files = seal.get("changes") or []
+        files = seal.get("changes")
+        files = files if isinstance(files, list) else []
         out += ["## Files", ""]
         if files:
             out += ["- %s (%s, %s)" % (c.get("path"), "binary" if c.get("binary") else "+%s −%s" % (