riskrails 4.0.1 → 4.2.0

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" % (

package/skills/ai-task/memory_hook.py

@@ -0,0 +1,172 @@
+"""The git hook (R17, §D10): the installed shim and where it points, the policy file, and the enable and
+disable commands that write and remove them."""
+import json
+import os
+import re
+
+import memory_config as mcfg
+import memory_format as mf
+import memory_io as mio
+
+
+# ------------------------------------------------------------------ status, show
+def hook_state(root):
+    code, out, _ = mio.git(root, "config", "--get", "core.hooksPath")
+    if code == 0 and out.strip():
+        return "hookspath"
+    path = hooks_path(root)
+    if not path:
+        return "absent"
+    hook = os.path.join(path, "pre-push")
+    text = mio.read_bytes(hook)
+    if text is None:
+        return "absent"
+    if mio.HOOK_MARKER.encode() in text:
+        decoded = text.decode("utf-8", "replace")
+        if not any(os.path.isfile(p) for p in shim_paths(decoded)):
+            return "installed, validator missing — pushes are NOT checked ('state.py memory enable' rewrites it)"
+        return "current" if decoded == shim_text() else "installed (stale)"
+    return "foreign"
+
+
+# ------------------------------------------------------------------ the git hook (R17, §D10)
+def hooks_path(root):
+    code, out, _ = mio.git(root, "rev-parse", "--git-path", "hooks")
+    if code != 0 or not out.strip():
+        return None
+    path = out.strip()
+    return path if os.path.isabs(path) else os.path.join(root, path)
+
+
+def shim_candidates(validator=None):
+    """Where the shim looks for the validator, in order: the hook beside this
+    module, the hook in either runtime home, then this module itself — a Codex
+    install copies skills/ai-task/ but not every hook."""
+    return [validator or mio.VALIDATOR, "$HOME/.claude/hooks/memory-pre-push.py",
+            "${CODEX_HOME:-$HOME/.codex}/hooks/memory-pre-push.py", mio.SELF,
+            "$HOME/.claude/skills/ai-task/memory_sync.py",
+            "${CODEX_HOME:-$HOME/.codex}/skills/ai-task/memory_sync.py"]
+
+
+def shim_text(validator=None):
+    return ("#!/bin/sh\n%s — written by 'state.py memory enable'; 'state.py memory disable' removes it\n"
+            "for v in %s; do\n"
+            "  [ -f \"$v\" ] && exec python3 -I \"$v\" \"$@\"\n"
+            "done\n"
+            "echo \"riskrails memory: validator not found — this push is not checked\" >&2; exit 0\n"
+            % (mio.HOOK_MARKER, " ".join('"%s"' % c for c in shim_candidates(validator))))
+
+
+def shim_paths(text):
+    """The shim's candidates as paths on this machine."""
+    match = re.search(r"^for v in (.+); do$", text, re.M)
+    home = os.path.expanduser("~")
+    codex = os.environ.get("CODEX_HOME") or os.path.join(home, ".codex")
+    return [c.replace("${CODEX_HOME:-$HOME/.codex}", codex).replace("$HOME", home)
+            for c in re.findall(r'"([^"]+)"', match.group(1) if match else "")]
+
+
+def snippet_text(validator=None):
+    validator = validator or mio.VALIDATOR
+    return ("# riskrails memory: add to your own pre-push hook (stdin can be read only once)\n"
+            "rr_in=$(mktemp) && cat > \"$rr_in\"\n"
+            "python3 -I \"%s\" \"$@\" < \"$rr_in\" || { rr=$?; rm -f \"$rr_in\"; exit $rr; }\n"
+            "# … then your hook, reading \"$rr_in\" where it read stdin …\n"
+            "rm -f \"$rr_in\"\n" % validator)
+
+
+def install_hook(root):
+    """installed | current | foreign | hookspath (R17)."""
+    code, out, _ = mio.git(root, "config", "--get", "core.hooksPath")
+    if code == 0 and out.strip():
+        return "hookspath"
+    path = hooks_path(root)
+    if not path:
+        raise mio.MemoryError_("not a git repository: no hooks path", 2)
+    hook = os.path.join(path, "pre-push")
+    text = mio.read_bytes(hook)
+    if text is not None and mio.HOOK_MARKER.encode() not in text:
+        return "foreign"
+    if text is not None and text.decode("utf-8", "replace") == shim_text():
+        return "current"
+    os.makedirs(path, exist_ok=True)
+    mio.atomic_write(hook, shim_text())
+    os.chmod(hook, 0o755)
+    return "installed"
+
+
+def remove_hook(root):
+    path = hooks_path(root)
+    hook = os.path.join(path, "pre-push") if path else None
+    text = mio.read_bytes(hook) if hook else None
+    if text is not None and mio.HOOK_MARKER.encode() in text:
+        os.remove(hook)
+        return "removed"
+    return "foreign" if text is not None else "absent"
+
+
+def write_policy(root, policy):
+    mio.atomic_write(os.path.join(root, mio.POLICY_REL), json.dumps(policy, indent=2, ensure_ascii=False) + "\n")
+
+
+GITIGNORE_LOCAL = (".ai/memory/", ".ai/reports/")
+GITIGNORE_SHARED = ("!.ai/memory/", "!.ai/reports/")
+
+
+def append_gitignore(root, lines):
+    """Append `lines` to .gitignore (created when absent), after a newline if the file lacks one; never rewrites."""
+    path = os.path.join(root, ".gitignore")
+    current = mio.read_bytes(path) or b""
+    sep = b"\n" if current and not current.endswith(b"\n") else b""
+    with open(path, "ab") as fh:
+        fh.write(sep + "".join(line + "\n" for line in lines).encode())
+
+
+def apply_share(root, share):
+    """--share git: the negations (the record is shared through git); --share local: the ignore lines. Append only."""
+    if share == "git":
+        have = (mio.read_bytes(os.path.join(root, ".gitignore")) or b"").decode("utf-8", "replace").splitlines()
+        add = [line for line in GITIGNORE_SHARED if line not in have]
+        if not add and not mio.shared(root):
+            add = list(GITIGNORE_SHARED)
+        if add:
+            append_gitignore(root, add)
+    elif share == "local" and mio.shared(root):
+        append_gitignore(root, GITIGNORE_LOCAL)
+
+
+def enable(root, author=None, period=None, index=None, share=None):
+    """Packages mode on. The hook is installed only while the record is shared (.ai/memory/ not git-ignored);
+    a local record has no hook of ours and the state is reported as `local`."""
+    cfg = mcfg.load_config(root)
+    policy = dict(mcfg.DEFAULTS)
+    policy.update(cfg.policy if cfg.present else {})
+    policy["mode"] = "packages"
+    if period:
+        if period not in mf.PERIODS:
+            raise mio.MemoryError_("--period takes one of %s" % ", ".join(mf.PERIODS))
+        policy["period"] = period
+    write_policy(root, policy)
+    local = dict(cfg.local)
+    local["schema"] = 1
+    local["author"] = mcfg.author_slug(author) if author else cfg.author
+    if index:
+        if index not in ("none", "sqlite"):
+            raise mio.MemoryError_("--index takes none or sqlite")
+        local["index"] = index
+    local.setdefault("index", "none")
+    mio.atomic_write(mio.local_path(root, "config.json"), json.dumps(local, sort_keys=True) + "\n")
+    if share:
+        apply_share(root, share)
+    if not mio.shared(root):
+        remove_hook(root)
+        return "local"
+    return install_hook(root)
+
+
+def disable(root):
+    cfg = mcfg.load_config(root)
+    policy = dict(cfg.policy)
+    policy["mode"] = "files"
+    write_policy(root, policy)
+    return remove_hook(root)