cnagent 2.1.19 → 2.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cnagent",
-  "version": "2.1.19",
+  "version": "2.1.22",
   "description": "Coherent Network agent CLI — everything runs through cn",
   "keywords": [
     "cn-agent",

package/tools/dist/cn.js

@@ -11879,6 +11879,7 @@ var require_cn_lib = __commonJS({
   "_build/default/tools/src/cn/output/tools/src/cn/cn_lib.js"(exports2, module2) {
     "use strict";
     var Caml_obj = require_caml_obj();
+    var Caml_option2 = require_caml_option();
     var Stdlib__List2 = require_list();
     var Stdlib__Option2 = require_option();
     var Stdlib__String2 = require_string();
@@ -11914,6 +11915,7 @@ var require_cn_lib = __commonJS({
     var Queue = {};
     var Mca = {};
     var Gtd = {};
+    var Out = {};
     function string_of_agent_op(id) {
       switch (id.TAG) {
         case /* Ack */
@@ -12231,8 +12233,42 @@ var require_cn_lib = __commonJS({
               4:
                 return "done " + t$1._0;
             }
-          case /* Commit */
+          case /* Out */
           10:
+            const match2 = t._0;
+            switch (match2.TAG) {
+              case /* Do */
+              0:
+                const match$1 = match2._0;
+                switch (match$1.TAG) {
+                  case /* Reply */
+                  0:
+                    return "out do reply";
+                  case /* Send */
+                  1:
+                    return "out do send " + match$1.to_;
+                  case /* Surface */
+                  2:
+                    return "out do surface";
+                  case /* Noop */
+                  3:
+                    return "out do noop";
+                  case /* Commit */
+                  4:
+                    return "out do commit " + match$1.artifact;
+                }
+              case /* Defer */
+              1:
+                return "out defer";
+              case /* Delegate */
+              2:
+                return "out delegate " + match2.to_;
+              case /* Delete */
+              3:
+                return "out delete";
+            }
+          case /* Commit */
+          11:
             const m = t._0;
             if (m !== void 0) {
               return "commit " + m;
@@ -12240,7 +12276,7 @@ var require_cn_lib = __commonJS({
               return "commit";
             }
           case /* Save */
-          11:
+          12:
             const m$1 = t._0;
             if (m$1 !== void 0) {
               return "save " + m$1;
@@ -12544,6 +12580,287 @@ var require_cn_lib = __commonJS({
           return;
       }
     }
+    function parse_flags_from_args(_acc, _param) {
+      while (true) {
+        const param = _param;
+        const acc = _acc;
+        if (!param) {
+          return acc;
+        }
+        switch (param.hd) {
+          case "--artifact":
+            const match2 = param.tl;
+            if (match2) {
+              _param = match2.tl;
+              _acc = {
+                hd: [
+                  "artifact",
+                  match2.hd
+                ],
+                tl: acc
+              };
+              continue;
+            }
+            _param = param.tl;
+            continue;
+          case "--desc":
+            const match$1 = param.tl;
+            if (match$1) {
+              _param = match$1.tl;
+              _acc = {
+                hd: [
+                  "desc",
+                  match$1.hd
+                ],
+                tl: acc
+              };
+              continue;
+            }
+            _param = param.tl;
+            continue;
+          case "--id":
+            const match$2 = param.tl;
+            if (match$2) {
+              _param = match$2.tl;
+              _acc = {
+                hd: [
+                  "id",
+                  match$2.hd
+                ],
+                tl: acc
+              };
+              continue;
+            }
+            _param = param.tl;
+            continue;
+          case "--message":
+            const match$3 = param.tl;
+            if (match$3) {
+              _param = match$3.tl;
+              _acc = {
+                hd: [
+                  "message",
+                  match$3.hd
+                ],
+                tl: acc
+              };
+              continue;
+            }
+            _param = param.tl;
+            continue;
+          case "--reason":
+            const match$4 = param.tl;
+            if (match$4) {
+              _param = match$4.tl;
+              _acc = {
+                hd: [
+                  "reason",
+                  match$4.hd
+                ],
+                tl: acc
+              };
+              continue;
+            }
+            _param = param.tl;
+            continue;
+          case "--to":
+            const match$5 = param.tl;
+            if (match$5) {
+              _param = match$5.tl;
+              _acc = {
+                hd: [
+                  "to",
+                  match$5.hd
+                ],
+                tl: acc
+              };
+              continue;
+            }
+            _param = param.tl;
+            continue;
+          default:
+            _param = param.tl;
+            continue;
+        }
+      }
+      ;
+    }
+    function get_flag(key, flags) {
+      return Stdlib__List2.find_map((function(param) {
+        if (Caml_obj.caml_equal(param[0], key)) {
+          return Caml_option2.some(param[1]);
+        }
+      }), flags);
+    }
+    function parse_out_cmd(args2) {
+      const flags = parse_flags_from_args(
+        /* [] */
+        0,
+        args2
+      );
+      if (!args2) {
+        return;
+      }
+      switch (args2.hd) {
+        case "defer":
+          return Stdlib__Option2.map((function(r) {
+            return {
+              TAG: (
+                /* Defer */
+                1
+              ),
+              reason: r
+            };
+          }), get_flag("reason", flags));
+        case "delegate":
+          return Stdlib__Option2.map((function(t) {
+            return {
+              TAG: (
+                /* Delegate */
+                2
+              ),
+              to_: t
+            };
+          }), get_flag("to", flags));
+        case "delete":
+          return Stdlib__Option2.map((function(r) {
+            return {
+              TAG: (
+                /* Delete */
+                3
+              ),
+              reason: r
+            };
+          }), get_flag("reason", flags));
+        case "do":
+          const match2 = args2.tl;
+          if (!match2) {
+            return;
+          }
+          switch (match2.hd) {
+            case "commit":
+              return Stdlib__Option2.map((function(a) {
+                return {
+                  TAG: (
+                    /* Do */
+                    0
+                  ),
+                  _0: {
+                    TAG: (
+                      /* Commit */
+                      4
+                    ),
+                    artifact: a
+                  }
+                };
+              }), get_flag("artifact", flags));
+            case "noop":
+              const r = get_flag("reason", flags);
+              if (r === void 0) {
+                return;
+              }
+              const r_lower = Stdlib__String2.lowercase_ascii(r);
+              if (Stdlib__List2.mem(r_lower, {
+                hd: "ack",
+                tl: {
+                  hd: "ok",
+                  tl: {
+                    hd: "done",
+                    tl: {
+                      hd: "yes",
+                      tl: {
+                        hd: "no",
+                        tl: {
+                          hd: "acknowledged",
+                          tl: {
+                            hd: "noted",
+                            tl: (
+                              /* [] */
+                              0
+                            )
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }) || r.length < 10) {
+                return;
+              } else {
+                return {
+                  TAG: (
+                    /* Do */
+                    0
+                  ),
+                  _0: {
+                    TAG: (
+                      /* Noop */
+                      3
+                    ),
+                    reason: r
+                  }
+                };
+              }
+            case "reply":
+              return Stdlib__Option2.map((function(m) {
+                return {
+                  TAG: (
+                    /* Do */
+                    0
+                  ),
+                  _0: {
+                    TAG: (
+                      /* Reply */
+                      0
+                    ),
+                    message: m
+                  }
+                };
+              }), get_flag("message", flags));
+            case "send":
+              const match$1 = get_flag("to", flags);
+              const match$2 = get_flag("message", flags);
+              if (match$1 !== void 0 && match$2 !== void 0) {
+                return {
+                  TAG: (
+                    /* Do */
+                    0
+                  ),
+                  _0: {
+                    TAG: (
+                      /* Send */
+                      1
+                    ),
+                    to_: match$1,
+                    message: match$2
+                  }
+                };
+              } else {
+                return;
+              }
+            case "surface":
+              return Stdlib__Option2.map((function(d) {
+                return {
+                  TAG: (
+                    /* Do */
+                    0
+                  ),
+                  _0: {
+                    TAG: (
+                      /* Surface */
+                      2
+                    ),
+                    desc: d
+                  }
+                };
+              }), get_flag("desc", flags));
+            default:
+              return;
+          }
+        default:
+          return;
+      }
+    }
     function join_rest(rest) {
       if (rest) {
         return Stdlib__String2.concat(" ", rest);
@@ -12575,7 +12892,7 @@ var require_cn_lib = __commonJS({
             return {
               TAG: (
                 /* Commit */
-                10
+                11
               ),
               _0: join_rest(param.tl)
             };
@@ -12710,6 +13027,16 @@ var require_cn_lib = __commonJS({
                 5
               );
             }
+          case "out":
+            return Stdlib__Option2.map((function(c) {
+              return {
+                TAG: (
+                  /* Out */
+                  10
+                ),
+                _0: c
+              };
+            }), parse_out_cmd(param.tl));
           case "outbox":
             return Stdlib__Option2.map((function(c) {
               return {
@@ -12793,7 +13120,7 @@ var require_cn_lib = __commonJS({
             return {
               TAG: (
                 /* Save */
-                11
+                12
               ),
               _0: join_rest(param.tl)
             };
@@ -13266,7 +13593,7 @@ var require_cn_lib = __commonJS({
       );
     }
     var help_text = "cn - Coherent Network agent CLI\n\nUsage: cn <command> [options]\n\nCommands:\n  # Agent decisions (output)\n  delete <thread>     GTD: discard\n  defer <thread>      GTD: postpone\n  delegate <t> <peer> GTD: forward\n  do <thread>         GTD: claim/start\n  done <thread>       GTD: complete \xE2\x86\x92 archive\n  reply <thread> <msg> Append to thread\n  send <peer> <msg>   Message to peer (or self)\n  \n  # cn operations (orchestrator)\n  sync                Fetch inbound + send outbound\n  process             Queue inbox \xE2\x86\x92 input.md \xE2\x86\x92 wake agent\n  queue [list|clear]  View or clear the task queue\n  mca [list|add <desc>] Surface MCAs for community pickup\n  inbox               List inbox threads\n  outbox              List outbox threads\n  next                Get next inbox item (with cadence)\n  read <thread>       Read thread with cadence\n  \n  # Hub management\n  init [name]         Create new hub\n  status              Show hub state\n  commit [msg]        Stage + commit\n  push                Push to origin\n  save [msg]          Commit + push\n  peer                Manage peers\n  doctor              Health check\n  update              Update cn to latest version\n\nAliases:\n  i = inbox, o = outbox, s = status, d = doctor\n\nFlags:\n  --help, -h          Show help\n  --version, -V       Show version\n  --json              Machine-readable output\n  --quiet, -q         Minimal output\n  --dry-run           Show what would happen\n\nActor Model:\n  cn runs on cron (every 5 min). It:\n  1. Syncs peers \xE2\x86\x92 queues new inbox items to state/queue/\n  2. If input.md empty \xE2\x86\x92 pops from queue \xE2\x86\x92 writes input.md \xE2\x86\x92 wakes agent\n  Agent reads input.md, processes, deletes when done.\n";
-    var version = "2.1.19";
+    var version = "2.1.21";
     module2.exports = {
       starts_with,
       strip_prefix,
@@ -13278,6 +13605,7 @@ var require_cn_lib = __commonJS({
       Queue,
       Mca,
       Gtd,
+      Out,
       string_of_agent_op,
       parse_agent_op,
       extract_ops,
@@ -13289,6 +13617,9 @@ var require_cn_lib = __commonJS({
       parse_queue_cmd,
       parse_mca_cmd,
       parse_gtd_cmd,
+      parse_flags_from_args,
+      get_flag,
+      parse_out_cmd,
       join_rest,
       parse_command,
       default_flags,
@@ -26522,7 +26853,8 @@ function materialize_branch(hub_path, inbox_dir, peer_name, branch) {
       _1: "%s-%s.md"
     }), peer_name, branch_slug);
     const inbox_path = Path.join(inbox_dir, inbox_file);
-    if (Fs.existsSync(inbox_path)) {
+    const archived_path = Path.join(Path.join(inbox_dir, "_archived"), inbox_file);
+    if (Fs.existsSync(inbox_path) || Fs.existsSync(archived_path)) {
       return;
     }
     const meta_0 = [
@@ -32154,68 +32486,842 @@ function run_mca_list(hub_path) {
   }
   console.log("(no MCAs)");
 }
-function mca_cycle_path(hub_path) {
-  return Path.join(hub_path, "state/.mca-cycle");
-}
-function get_mca_cycle(hub_path) {
-  const path = Path.join(hub_path, "state/.mca-cycle");
-  if (Fs.existsSync(path)) {
-    return Stdlib__Option.value(Stdlib.int_of_string_opt(Stdlib__String.trim(Fs.readFileSync(path, "utf8"))), 0);
-  } else {
-    return 0;
-  }
-}
-function increment_mca_cycle(hub_path) {
-  const current = get_mca_cycle(hub_path);
-  const next = current + 1 | 0;
-  const prim1 = String(next);
-  const prim0 = Path.join(hub_path, "state/.mca-cycle");
-  Fs.writeFileSync(prim0, prim1);
-  return next;
-}
-function mca_count(hub_path) {
-  const dir = Path.join(hub_path, "state/mca");
-  if (Fs.existsSync(dir)) {
-    return Stdlib__List.length(Stdlib__List.filter(is_md_file, Stdlib__Array.to_list(Fs.readdirSync(dir))));
-  } else {
-    return 0;
-  }
-}
-function queue_mca_review(hub_path) {
-  const dir = Path.join(hub_path, "state/mca");
-  const mcas = Stdlib__List.sort(Stdlib__String.compare, Stdlib__List.filter(is_md_file, Stdlib__Array.to_list(Fs.readdirSync(dir))));
-  const mca_list = Stdlib__String.concat("\n", Stdlib__List.map((function(file) {
-    const content = Fs.readFileSync(Path.join(dir, file), "utf8");
-    const meta = Cn_lib.parse_frontmatter(content);
-    const id = Stdlib__Option.value(Stdlib__List.find_map((function(param) {
-      if (param[0] === "id") {
-        return param[1];
-      }
-    }), meta), "?");
-    const by = Stdlib__Option.value(Stdlib__List.find_map((function(param) {
-      if (param[0] === "surfaced-by") {
-        return param[1];
-      }
-    }), meta), "?");
-    const lines = Stdlib__String.split_on_char(
-      /* '\n' */
-      10,
-      content
-    );
-    const skip_fm = function(_in_fm, _rest) {
-      while (true) {
-        const rest = _rest;
-        const in_fm = _in_fm;
-        if (!rest) {
-          return (
-            /* [] */
-            0
-          );
-        }
-        if (rest.hd === "---") {
-          const rest$1 = rest.tl;
-          if (in_fm) {
-            if (in_fm) {
+function run_out(hub_path, name, gtd) {
+  const inp = Path.join(hub_path, "state/input.md");
+  const input_meta = Fs.existsSync(inp) ? Cn_lib.parse_frontmatter(Fs.readFileSync(inp, "utf8")) : void 0;
+  const input_id = input_meta !== void 0 ? Stdlib__List.find_map((function(param) {
+    if (param[0] === "id") {
+      return param[1];
+    }
+  }), input_meta) : void 0;
+  const input_from = input_meta !== void 0 ? Stdlib__List.find_map((function(param) {
+    if (param[0] === "from") {
+      return param[1];
+    }
+  }), input_meta) : void 0;
+  const outp = Path.join(hub_path, "state/output.md");
+  const id = Stdlib__Option.value(input_id, "unknown");
+  let match2;
+  switch (gtd.TAG) {
+    case /* Do */
+    0:
+      const match$1 = gtd._0;
+      switch (match$1.TAG) {
+        case /* Reply */
+        0:
+          match2 = [
+            "do",
+            Curry._1(Stdlib__Printf.sprintf({
+              TAG: (
+                /* Format */
+                0
+              ),
+              _0: {
+                TAG: (
+                  /* String_literal */
+                  11
+                ),
+                _0: "reply: ",
+                _1: {
+                  TAG: (
+                    /* String */
+                    2
+                  ),
+                  _0: (
+                    /* No_padding */
+                    0
+                  ),
+                  _1: (
+                    /* End_of_format */
+                    0
+                  )
+                }
+              },
+              _1: "reply: %s"
+            }), match$1.message)
+          ];
+          break;
+        case /* Send */
+        1:
+          match2 = [
+            "do",
+            Curry._2(Stdlib__Printf.sprintf({
+              TAG: (
+                /* Format */
+                0
+              ),
+              _0: {
+                TAG: (
+                  /* String_literal */
+                  11
+                ),
+                _0: "send: ",
+                _1: {
+                  TAG: (
+                    /* String */
+                    2
+                  ),
+                  _0: (
+                    /* No_padding */
+                    0
+                  ),
+                  _1: {
+                    TAG: (
+                      /* Char_literal */
+                      12
+                    ),
+                    _0: (
+                      /* '|' */
+                      124
+                    ),
+                    _1: {
+                      TAG: (
+                        /* String */
+                        2
+                      ),
+                      _0: (
+                        /* No_padding */
+                        0
+                      ),
+                      _1: (
+                        /* End_of_format */
+                        0
+                      )
+                    }
+                  }
+                }
+              },
+              _1: "send: %s|%s"
+            }), match$1.to_, match$1.message)
+          ];
+          break;
+        case /* Surface */
+        2:
+          match2 = [
+            "do",
+            Curry._1(Stdlib__Printf.sprintf({
+              TAG: (
+                /* Format */
+                0
+              ),
+              _0: {
+                TAG: (
+                  /* String_literal */
+                  11
+                ),
+                _0: "surface: ",
+                _1: {
+                  TAG: (
+                    /* String */
+                    2
+                  ),
+                  _0: (
+                    /* No_padding */
+                    0
+                  ),
+                  _1: (
+                    /* End_of_format */
+                    0
+                  )
+                }
+              },
+              _1: "surface: %s"
+            }), match$1.desc)
+          ];
+          break;
+        case /* Noop */
+        3:
+          match2 = [
+            "do",
+            Curry._1(Stdlib__Printf.sprintf({
+              TAG: (
+                /* Format */
+                0
+              ),
+              _0: {
+                TAG: (
+                  /* String_literal */
+                  11
+                ),
+                _0: "noop: ",
+                _1: {
+                  TAG: (
+                    /* String */
+                    2
+                  ),
+                  _0: (
+                    /* No_padding */
+                    0
+                  ),
+                  _1: (
+                    /* End_of_format */
+                    0
+                  )
+                }
+              },
+              _1: "noop: %s"
+            }), match$1.reason)
+          ];
+          break;
+        case /* Commit */
+        4:
+          match2 = [
+            "do",
+            Curry._1(Stdlib__Printf.sprintf({
+              TAG: (
+                /* Format */
+                0
+              ),
+              _0: {
+                TAG: (
+                  /* String_literal */
+                  11
+                ),
+                _0: "commit: ",
+                _1: {
+                  TAG: (
+                    /* String */
+                    2
+                  ),
+                  _0: (
+                    /* No_padding */
+                    0
+                  ),
+                  _1: (
+                    /* End_of_format */
+                    0
+                  )
+                }
+              },
+              _1: "commit: %s"
+            }), match$1.artifact)
+          ];
+          break;
+      }
+      break;
+    case /* Defer */
+    1:
+      match2 = [
+        "defer",
+        Curry._1(Stdlib__Printf.sprintf({
+          TAG: (
+            /* Format */
+            0
+          ),
+          _0: {
+            TAG: (
+              /* String_literal */
+              11
+            ),
+            _0: "reason: ",
+            _1: {
+              TAG: (
+                /* String */
+                2
+              ),
+              _0: (
+                /* No_padding */
+                0
+              ),
+              _1: (
+                /* End_of_format */
+                0
+              )
+            }
+          },
+          _1: "reason: %s"
+        }), gtd.reason)
+      ];
+      break;
+    case /* Delegate */
+    2:
+      match2 = [
+        "delegate",
+        Curry._1(Stdlib__Printf.sprintf({
+          TAG: (
+            /* Format */
+            0
+          ),
+          _0: {
+            TAG: (
+              /* String_literal */
+              11
+            ),
+            _0: "to: ",
+            _1: {
+              TAG: (
+                /* String */
+                2
+              ),
+              _0: (
+                /* No_padding */
+                0
+              ),
+              _1: (
+                /* End_of_format */
+                0
+              )
+            }
+          },
+          _1: "to: %s"
+        }), gtd.to_)
+      ];
+      break;
+    case /* Delete */
+    3:
+      match2 = [
+        "delete",
+        Curry._1(Stdlib__Printf.sprintf({
+          TAG: (
+            /* Format */
+            0
+          ),
+          _0: {
+            TAG: (
+              /* String_literal */
+              11
+            ),
+            _0: "reason: ",
+            _1: {
+              TAG: (
+                /* String */
+                2
+              ),
+              _0: (
+                /* No_padding */
+                0
+              ),
+              _1: (
+                /* End_of_format */
+                0
+              )
+            }
+          },
+          _1: "reason: %s"
+        }), gtd.reason)
+      ];
+      break;
+  }
+  const gtd_type = match2[0];
+  const content = Curry._4(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String_literal */
+        11
+      ),
+      _0: "---\nid: ",
+      _1: {
+        TAG: (
+          /* String */
+          2
+        ),
+        _0: (
+          /* No_padding */
+          0
+        ),
+        _1: {
+          TAG: (
+            /* String_literal */
+            11
+          ),
+          _0: "\ngtd: ",
+          _1: {
+            TAG: (
+              /* String */
+              2
+            ),
+            _0: (
+              /* No_padding */
+              0
+            ),
+            _1: {
+              TAG: (
+                /* Char_literal */
+                12
+              ),
+              _0: (
+                /* '\n' */
+                10
+              ),
+              _1: {
+                TAG: (
+                  /* String */
+                  2
+                ),
+                _0: (
+                  /* No_padding */
+                  0
+                ),
+                _1: {
+                  TAG: (
+                    /* String_literal */
+                    11
+                  ),
+                  _0: "\ncreated: ",
+                  _1: {
+                    TAG: (
+                      /* String */
+                      2
+                    ),
+                    _0: (
+                      /* No_padding */
+                      0
+                    ),
+                    _1: {
+                      TAG: (
+                        /* String_literal */
+                        11
+                      ),
+                      _0: "\n---\n",
+                      _1: (
+                        /* End_of_format */
+                        0
+                      )
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    _1: "---\nid: %s\ngtd: %s\n%s\ncreated: %s\n---\n"
+  }), id, gtd_type, match2[1], (/* @__PURE__ */ new Date()).toISOString());
+  Fs.writeFileSync(outp, content);
+  log_action(hub_path, "out", Curry._2(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String_literal */
+        11
+      ),
+      _0: "id:",
+      _1: {
+        TAG: (
+          /* String */
+          2
+        ),
+        _0: (
+          /* No_padding */
+          0
+        ),
+        _1: {
+          TAG: (
+            /* String_literal */
+            11
+          ),
+          _0: " gtd:",
+          _1: {
+            TAG: (
+              /* String */
+              2
+            ),
+            _0: (
+              /* No_padding */
+              0
+            ),
+            _1: (
+              /* End_of_format */
+              0
+            )
+          }
+        }
+      }
+    },
+    _1: "id:%s gtd:%s"
+  }), id, gtd_type));
+  const msg = Curry._2(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String_literal */
+        11
+      ),
+      _0: "Output: ",
+      _1: {
+        TAG: (
+          /* String */
+          2
+        ),
+        _0: (
+          /* No_padding */
+          0
+        ),
+        _1: {
+          TAG: (
+            /* String_literal */
+            11
+          ),
+          _0: " (",
+          _1: {
+            TAG: (
+              /* String */
+              2
+            ),
+            _0: (
+              /* No_padding */
+              0
+            ),
+            _1: {
+              TAG: (
+                /* Char_literal */
+                12
+              ),
+              _0: (
+                /* ')' */
+                41
+              ),
+              _1: (
+                /* End_of_format */
+                0
+              )
+            }
+          }
+        }
+      }
+    },
+    _1: "Output: %s (%s)"
+  }), gtd_type, id);
+  console.log(color("32", "\xE2\x9C\x93 ") + msg);
+  if (input_from === void 0) {
+    return;
+  }
+  if (!(input_from !== name && input_from !== "system")) {
+    return;
+  }
+  const notify_msg = Curry._3(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String_literal */
+        11
+      ),
+      _0: "[auto] ",
+      _1: {
+        TAG: (
+          /* String */
+          2
+        ),
+        _0: (
+          /* No_padding */
+          0
+        ),
+        _1: {
+          TAG: (
+            /* String_literal */
+            11
+          ),
+          _0: ": ",
+          _1: {
+            TAG: (
+              /* String */
+              2
+            ),
+            _0: (
+              /* No_padding */
+              0
+            ),
+            _1: {
+              TAG: (
+                /* String_literal */
+                11
+              ),
+              _0: " on ",
+              _1: {
+                TAG: (
+                  /* String */
+                  2
+                ),
+                _0: (
+                  /* No_padding */
+                  0
+                ),
+                _1: (
+                  /* End_of_format */
+                  0
+                )
+              }
+            }
+          }
+        }
+      }
+    },
+    _1: "[auto] %s: %s on %s"
+  }), name, gtd_type, id);
+  const outbox_dir = Path.join(hub_path, "threads/outbox");
+  ensure_dir(outbox_dir);
+  const notify_file = Curry._2(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String */
+        2
+      ),
+      _0: (
+        /* No_padding */
+        0
+      ),
+      _1: {
+        TAG: (
+          /* String_literal */
+          11
+        ),
+        _0: "-auto-notify-",
+        _1: {
+          TAG: (
+            /* String */
+            2
+          ),
+          _0: (
+            /* No_padding */
+            0
+          ),
+          _1: {
+            TAG: (
+              /* String_literal */
+              11
+            ),
+            _0: ".md",
+            _1: (
+              /* End_of_format */
+              0
+            )
+          }
+        }
+      }
+    },
+    _1: "%s-auto-notify-%s.md"
+  }), input_from, id);
+  const notify_content = Curry._3(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String_literal */
+        11
+      ),
+      _0: "---\nto: ",
+      _1: {
+        TAG: (
+          /* String */
+          2
+        ),
+        _0: (
+          /* No_padding */
+          0
+        ),
+        _1: {
+          TAG: (
+            /* String_literal */
+            11
+          ),
+          _0: "\ncreated: ",
+          _1: {
+            TAG: (
+              /* String */
+              2
+            ),
+            _0: (
+              /* No_padding */
+              0
+            ),
+            _1: {
+              TAG: (
+                /* String_literal */
+                11
+              ),
+              _0: "\nauto: true\n---\n\n",
+              _1: {
+                TAG: (
+                  /* String */
+                  2
+                ),
+                _0: (
+                  /* No_padding */
+                  0
+                ),
+                _1: {
+                  TAG: (
+                    /* Char_literal */
+                    12
+                  ),
+                  _0: (
+                    /* '\n' */
+                    10
+                  ),
+                  _1: (
+                    /* End_of_format */
+                    0
+                  )
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    _1: "---\nto: %s\ncreated: %s\nauto: true\n---\n\n%s\n"
+  }), input_from, (/* @__PURE__ */ new Date()).toISOString(), notify_msg);
+  const prim0 = Path.join(outbox_dir, notify_file);
+  Fs.writeFileSync(prim0, notify_content);
+  log_action(hub_path, "out.notify", Curry._2(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String_literal */
+        11
+      ),
+      _0: "to:",
+      _1: {
+        TAG: (
+          /* String */
+          2
+        ),
+        _0: (
+          /* No_padding */
+          0
+        ),
+        _1: {
+          TAG: (
+            /* String_literal */
+            11
+          ),
+          _0: " id:",
+          _1: {
+            TAG: (
+              /* String */
+              2
+            ),
+            _0: (
+              /* No_padding */
+              0
+            ),
+            _1: (
+              /* End_of_format */
+              0
+            )
+          }
+        }
+      }
+    },
+    _1: "to:%s id:%s"
+  }), input_from, id));
+  const msg$1 = Curry._1(Stdlib__Printf.sprintf({
+    TAG: (
+      /* Format */
+      0
+    ),
+    _0: {
+      TAG: (
+        /* String_literal */
+        11
+      ),
+      _0: "Notified ",
+      _1: {
+        TAG: (
+          /* String */
+          2
+        ),
+        _0: (
+          /* No_padding */
+          0
+        ),
+        _1: (
+          /* End_of_format */
+          0
+        )
+      }
+    },
+    _1: "Notified %s"
+  }), input_from);
+  console.log(color("32", "\xE2\x9C\x93 ") + msg$1);
+  exec_in(hub_path, "git add -A && git commit -m '[auto] notify' && git push");
+  console.log(color("32", "\xE2\x9C\x93 ") + "Pushed notification");
+}
+function mca_cycle_path(hub_path) {
+  return Path.join(hub_path, "state/.mca-cycle");
+}
+function get_mca_cycle(hub_path) {
+  const path = Path.join(hub_path, "state/.mca-cycle");
+  if (Fs.existsSync(path)) {
+    return Stdlib__Option.value(Stdlib.int_of_string_opt(Stdlib__String.trim(Fs.readFileSync(path, "utf8"))), 0);
+  } else {
+    return 0;
+  }
+}
+function increment_mca_cycle(hub_path) {
+  const current = get_mca_cycle(hub_path);
+  const next = current + 1 | 0;
+  const prim1 = String(next);
+  const prim0 = Path.join(hub_path, "state/.mca-cycle");
+  Fs.writeFileSync(prim0, prim1);
+  return next;
+}
+function mca_count(hub_path) {
+  const dir = Path.join(hub_path, "state/mca");
+  if (Fs.existsSync(dir)) {
+    return Stdlib__List.length(Stdlib__List.filter(is_md_file, Stdlib__Array.to_list(Fs.readdirSync(dir))));
+  } else {
+    return 0;
+  }
+}
+function queue_mca_review(hub_path) {
+  const dir = Path.join(hub_path, "state/mca");
+  const mcas = Stdlib__List.sort(Stdlib__String.compare, Stdlib__List.filter(is_md_file, Stdlib__Array.to_list(Fs.readdirSync(dir))));
+  const mca_list = Stdlib__String.concat("\n", Stdlib__List.map((function(file) {
+    const content = Fs.readFileSync(Path.join(dir, file), "utf8");
+    const meta = Cn_lib.parse_frontmatter(content);
+    const id = Stdlib__Option.value(Stdlib__List.find_map((function(param) {
+      if (param[0] === "id") {
+        return param[1];
+      }
+    }), meta), "?");
+    const by = Stdlib__Option.value(Stdlib__List.find_map((function(param) {
+      if (param[0] === "surfaced-by") {
+        return param[1];
+      }
+    }), meta), "?");
+    const lines = Stdlib__String.split_on_char(
+      /* '\n' */
+      10,
+      content
+    );
+    const skip_fm = function(_in_fm, _rest) {
+      while (true) {
+        const rest = _rest;
+        const in_fm = _in_fm;
+        if (!rest) {
+          return (
+            /* [] */
+            0
+          );
+        }
+        if (rest.hd === "---") {
+          const rest$1 = rest.tl;
+          if (in_fm) {
+            if (in_fm) {
               return rest$1;
             }
           } else {
@@ -33112,6 +34218,7 @@ function run_init(name) {
   const prim0$3 = Path.join(hub_dir, "state/peers.md");
   Fs.writeFileSync(prim0$3, peers);
   exec_in(hub_dir, "git init");
+  update_runtime(hub_dir);
   exec_in(hub_dir, "git add -A");
   exec_in(hub_dir, Curry._1(Stdlib__Printf.sprintf({
     TAG: (
@@ -33148,7 +34255,6 @@ function run_init(name) {
     },
     _1: "git commit -m 'Initialize %s hub'"
   }), hub_name));
-  update_runtime(hub_dir);
   const msg$1 = Curry._1(Stdlib__Printf.sprintf({
     TAG: (
       /* Format */
@@ -34251,6 +35357,26 @@ function run_update_with_cron(hub_path) {
   run_update(void 0);
   update_cron(hub_path);
   update_runtime(hub_path);
+  console.log(color("36", "Auto-committing runtime changes..."));
+  exec_in(hub_path, "git add state/runtime.md");
+  const commit_result = exec_in(hub_path, "git commit -m 'chore: cn update runtime'");
+  if (commit_result !== void 0) {
+    console.log(color("32", "\xE2\x9C\x93 ") + "Committed runtime changes");
+    const match2 = exec_in(hub_path, "git remote get-url origin 2>/dev/null");
+    if (match2 !== void 0) {
+      console.log(color("36", "Pushing to origin..."));
+      const match$1 = exec_in(hub_path, "git push origin HEAD 2>&1");
+      if (match$1 !== void 0) {
+        console.log(color("32", "\xE2\x9C\x93 ") + "Pushed to origin");
+      } else {
+        console.log(color("33", "\xE2\x9A\xA0 ") + "Push failed - push manually");
+      }
+      return;
+    }
+    console.log(color("2", "No origin remote - skipping push"));
+    return;
+  }
+  console.log(color("2", "No runtime changes to commit"));
 }
 function drop(n, lst) {
   let _n = n;
@@ -34488,12 +35614,16 @@ if (cmd !== void 0) {
                 break;
             }
             break;
-          case /* Commit */
+          case /* Out */
           10:
+            run_out(hub_path$1, name, cmd._0);
+            break;
+          case /* Commit */
+          11:
             run_commit(hub_path$1, name, cmd._0);
             break;
           case /* Save */
-          11:
+          12:
             run_commit(hub_path$1, name, cmd._0);
             run_push(hub_path$1);
             break;
@@ -34613,6 +35743,7 @@ module.exports = {
   run_queue_clear,
   run_mca_add,
   run_mca_list,
+  run_out,
   mca_cycle_path,
   mca_review_interval,
   get_mca_cycle,