procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/agents/connector-builder/knowledge.py

@@ -0,0 +1,47 @@
+"""Load the agent's knowledge base (the markdown in this folder).
+
+The `guidance` action serves these so any session loads the methodology from ONE
+registry-discoverable place instead of re-deriving it. The docs are the source of
+truth; this module just reads them.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+KB_DIR = Path(__file__).resolve().parent
+
+# topic -> (filename, human label)
+TOPICS: dict[str, tuple[str, str]] = {
+    "playbook": ("CONNECTOR-BUILDER-PLAYBOOK.md",
+                 "Build → upload → test → improve operating procedure"),
+    "interop": ("CONNECTOR-BUILDER-PROCESIO-INTEROP.md",
+                "How this agent hands off to the procesio tool/agent"),
+    "troubleshooting": ("CONNECTOR-BUILDER-TROUBLESHOOTING.md",
+                        "Operations: tool/skill inventory, live-run realities, failure "
+                        "triage (NU1301 vs code), definition of done"),
+    "boundary": ("README.md",
+                 "Agent overview + tool-vs-agent boundary"),
+}
+
+
+def topics() -> list[str]:
+    return list(TOPICS.keys())
+
+
+def load(topic: str) -> dict:
+    if topic not in TOPICS:
+        raise KeyError(f"unknown topic: {topic}. Known: {', '.join(TOPICS)}")
+    filename, label = TOPICS[topic]
+    path = KB_DIR / filename
+    if not path.exists():
+        raise FileNotFoundError(f"knowledge file missing: {path}")
+    return {
+        "topic": topic,
+        "label": label,
+        "source": str(path),
+        "content": path.read_text(encoding="utf-8"),
+    }
+
+
+def load_all() -> list[dict]:
+    return [load(t) for t in TOPICS]

procesio_cli/agents/connector-builder/main.py

@@ -0,0 +1,93 @@
+"""connector-builder agent entrypoint — action dispatch.
+
+Orchestrates the `connector-builder` tool (the AI Connector Builder REST client)
+and the `procesio` tool to run the full loop: build a connector from API docs →
+download the .nupkg → upload it to PROCESIO → test it live → feed failures back
+to improve the connector (and, for systemic issues, the builder's own knowledge).
+
+It is the executable side of CONNECTOR-BUILDER-PLAYBOOK.md. Invoked like any
+action-dispatch tool: action name first, JSON in / JSON out.
+
+The agent dir name has a hyphen, so this agent's own modules are imported by BARE
+name with the agent root on sys.path (mirrors the hyphenated tools); the shared
+agent libs are imported as the valid package `agents._lib`.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+AGENT_ROOT = Path(__file__).resolve().parent
+FRAMEWORK_ROOT = AGENT_ROOT.parents[1]
+_VENV_PY = FRAMEWORK_ROOT / ".venv" / "Scripts" / "python.exe"
+if _VENV_PY.exists() and Path(sys.executable).resolve() != _VENV_PY.resolve():
+    import subprocess
+    sys.exit(subprocess.run([str(_VENV_PY), __file__, *sys.argv[1:]]).returncode)
+
+import argparse  # noqa: E402
+
+for _p in (str(AGENT_ROOT), str(FRAMEWORK_ROOT)):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from tools._lib.io import emit, fail  # noqa: E402
+from agents._lib import errors  # noqa: E402
+from agents._lib.actiondef import ActionDef  # noqa: E402
+
+
+class _Parser(argparse.ArgumentParser):
+    def error(self, message: str):
+        raise errors.UsageError(message)
+
+
+def collect_actions() -> dict[str, ActionDef]:
+    from handlers import status, guidance, nextstep, checklist
+    actions: dict[str, ActionDef] = {}
+    for module in (status, guidance, nextstep, checklist):
+        for name, defn in module.ACTIONS.items():
+            if name in actions:
+                raise RuntimeError(f"duplicate connector-builder agent action: {name}")
+            actions[name] = defn
+    return actions
+
+
+ACTIONS = collect_actions()
+
+
+def _build_context():
+    from context import ConnectorBuilderContext
+    return ConnectorBuilderContext.create()
+
+
+def dispatch(action: str, argv: list[str], *, context_builder=None) -> dict:
+    if action not in ACTIONS:
+        raise errors.UsageError(
+            f"unknown action: {action}. Known: {', '.join(sorted(ACTIONS))}")
+    defn = ACTIONS[action]
+    parser = _Parser(prog=f"connector-builder {action}", description=defn.description)
+    defn.add_args(parser)
+    parsed = parser.parse_args(argv)
+    if defn.context:
+        builder = context_builder or _build_context
+        return defn.func(builder(), parsed)
+    return defn.func(parsed)
+
+
+def main(argv=None) -> None:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv or argv[0] in ("-h", "--help"):
+        print("Actions:", file=sys.stderr)
+        for name in sorted(ACTIONS):
+            print(f"  {name:<14} {ACTIONS[name].description}", file=sys.stderr)
+        sys.exit(0)
+    action, rest = argv[0], argv[1:]
+    try:
+        result = dispatch(action, rest)
+    except Exception as exc:  # noqa: BLE001
+        code, message, details, exit_code = errors.classify(exc)
+        fail(code, message, details, exit_code)
+    emit(result)
+
+
+if __name__ == "__main__":
+    main()

procesio_cli/agents/connector-builder/tests/conftest.py

@@ -0,0 +1,95 @@
+"""Pytest fixtures + hyphen-safe module loading for the connector-builder agent.
+
+The agent dir name has a hyphen, so its own modules (knowledge, context,
+handlers.*, main) are imported by BARE name at runtime with the agent root on
+sys.path. Under pytest those bare names collide across hyphenated dirs, so — like
+the hyphenated tools — we load THIS agent's modules under unique ``cba_*`` aliases
+via importlib, registering the bare names only TRANSIENTLY during load, then
+restore. Shared agent libs (``agents._lib.*``) are a normal package and import
+directly.
+
+NOTE: no tests/__init__.py here; every test file has a unique ``test_cba_*``
+basename to avoid pytest rootdir import collisions.
+"""
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+AGENT_ROOT = Path(__file__).resolve().parents[1]          # agents/connector-builder
+FRAMEWORK_ROOT = Path(__file__).resolve().parents[3]      # repo root
+
+if str(FRAMEWORK_ROOT) not in sys.path:
+    sys.path.insert(0, str(FRAMEWORK_ROOT))
+
+_BARE_NAMES = (
+    "knowledge", "context",
+    "handlers", "handlers.status", "handlers.guidance",
+    "handlers.nextstep", "handlers.checklist", "main",
+)
+_MISSING = object()
+_saved_bare = {n: sys.modules.get(n, _MISSING) for n in _BARE_NAMES}
+
+
+def _load(bare_name: str, relpath: str) -> ModuleType:
+    path = AGENT_ROOT / relpath
+    spec = importlib.util.spec_from_file_location(bare_name, path)
+    assert spec and spec.loader
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[bare_name] = mod
+    spec.loader.exec_module(mod)
+    sys.modules["cba_" + bare_name.replace(".", "_")] = mod
+    return mod
+
+
+knowledge = _load("knowledge", "knowledge.py")
+context = _load("context", "context.py")
+
+_handlers_pkg = ModuleType("handlers")
+_handlers_pkg.__path__ = [str(AGENT_ROOT / "handlers")]  # type: ignore[attr-defined]
+sys.modules["handlers"] = _handlers_pkg
+sys.modules["cba_handlers"] = _handlers_pkg
+status = _load("handlers.status", "handlers/status.py")
+guidance = _load("handlers.guidance", "handlers/guidance.py")
+nextstep = _load("handlers.nextstep", "handlers/nextstep.py")
+checklist = _load("handlers.checklist", "handlers/checklist.py")
+
+main = _load("main", "main.py")
+
+sys.modules["cba_main"] = main
+sys.modules["cba_knowledge"] = knowledge
+
+_agent_root_str = str(AGENT_ROOT)
+sys.path[:] = [p for p in sys.path if p != _agent_root_str]
+for _bn, _prev in _saved_bare.items():
+    if _prev is _MISSING:
+        sys.modules.pop(_bn, None)
+    else:
+        sys.modules[_bn] = _prev
+
+
+class FakeContext:
+    """Records tool invocations and returns canned responses keyed by
+    (tool, action)."""
+
+    def __init__(self, responses=None):
+        self.calls: list[tuple] = []
+        self.responses = responses or {}
+
+    def invoke(self, tool, action, *args):
+        self.calls.append((tool, action, args))
+        return self.responses.get((tool, action), {})
+
+
+@pytest.fixture
+def cba_main():
+    return main
+
+
+@pytest.fixture
+def fake_context():
+    return FakeContext()

procesio_cli/agents/connector-builder/tests/test_cba_agent.py

@@ -0,0 +1,148 @@
+"""connector-builder agent: dispatch, manifest sync, next-step doctrine, checklist."""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import pytest
+
+import cba_main as main
+from tools._lib.manifest import load_agent
+
+
+# -- manifest sync -----------------------------------------------------------
+
+def _manifest():
+    root = Path(main.__file__).resolve().parent
+    return load_agent(root / "agent.yaml")
+
+
+def test_manifest_loads_and_names_match():
+    m = _manifest()
+    assert m.name == "connector-builder"
+    assert set(m.action_names()) == set(main.ACTIONS)
+
+
+def test_manifest_args_match_argparse():
+    m = _manifest()
+    for name, defn in main.ACTIONS.items():
+        parser = argparse.ArgumentParser()
+        defn.add_args(parser)
+        argparse_names = {opt[2:] for a in parser._actions for opt in a.option_strings
+                          if opt.startswith("--") and opt != "--help"}
+        manifest_names = {a.name for a in m.get_action(name).args}
+        assert manifest_names == argparse_names, name
+
+
+def test_drives_connector_builder_and_procesio():
+    m = _manifest()
+    assert set(m.tools) == {"connector-builder", "procesio"}
+
+
+# -- dispatch ----------------------------------------------------------------
+
+def _run(action, argv, ctx=None):
+    return main.dispatch(action, argv, context_builder=(lambda: ctx) if ctx else None)
+
+
+def test_unknown_action_raises():
+    from agents._lib import errors
+    with pytest.raises(errors.UsageError):
+        _run("nope", [])
+
+
+def test_status_runs_without_network():
+    out = _run("status", [])
+    assert out["agent"] == "connector-builder"
+
+
+def test_guidance_unknown_topic():
+    from agents._lib import errors
+    with pytest.raises(errors.AgentError):
+        _run("guidance", ["--topic", "bogus"])
+
+
+def test_guidance_playbook_loads():
+    out = _run("guidance", ["--topic", "playbook"])
+    assert "content" in out and "build" in out["content"].lower()
+
+
+def test_guidance_troubleshooting_loads():
+    out = _run("guidance", ["--topic", "troubleshooting"])
+    c = out["content"].lower()
+    # The operational knowledge from the live run must be present in the agent.
+    assert "nu1301" in c and "504" in c and "definition of done" in c
+
+
+def test_guidance_all_includes_troubleshooting():
+    out = _run("guidance", ["--topic", "all"])
+    assert "troubleshooting" in out["topics"]
+
+
+# -- next-step doctrine ------------------------------------------------------
+
+def test_next_step_pending_recommends_start_or_gather(fake_context):
+    out = _run("next-step", ["--status", "pending"], fake_context)
+    actions = {r["action"] for r in out["recommended"]}
+    assert {"start-build", "gather"} <= actions
+
+
+def test_next_step_generate_waiting_user(fake_context):
+    out = _run("next-step",
+               ["--status", "generating", "--step-status", "waiting_user"], fake_context)
+    assert out["phase"] == "generate-review"
+    assert "approve-generate" in {r["action"] for r in out["recommended"]}
+
+
+def test_next_step_completed_hands_off_to_procesio(fake_context):
+    out = _run("next-step", ["--status", "completed"], fake_context)
+    assert any(h["tool"].startswith("procesio") for h in out["handoff"])
+
+
+def test_next_step_live_build_id_invokes_tool(fake_context):
+    fake_context.responses[("connector-builder", "get-build")] = {
+        "status": "planning", "step_status": "waiting_user"}
+    out = _run("next-step", ["--build-id", "B1"], fake_context)
+    assert fake_context.calls[0] == ("connector-builder", "get-build", ("--build-id", "B1"))
+    assert out["phase"] == "plan-review"
+
+
+def test_next_step_compile_restore_is_platform_not_code(fake_context):
+    fake_context.responses[("connector-builder", "get-build")] = {
+        "status": "failed", "last_failed_step": 6,
+        "error_message": "Compilation failed due to NuGet package restore error. "
+                         "Failed to retrieve information about 'Ringhel.Procesio.Action.Core' (NU1301)."}
+    out = _run("next-step", ["--build-id", "B1"], fake_context)
+    assert out["diagnosis"]["kind"] == "platform_nuget_restore"
+    assert out["diagnosis"]["not_your_code"] is True
+
+
+def test_next_step_bad_version_is_code(fake_context):
+    fake_context.responses[("connector-builder", "get-build")] = {
+        "status": "failed", "last_failed_step": 6,
+        "error_message": "NU1102: Unable to find package Foo with version 9.9.9"}
+    out = _run("next-step", ["--build-id", "B1"], fake_context)
+    assert out["diagnosis"]["kind"] == "bad_package_version"
+    assert out["diagnosis"]["not_your_code"] is False
+
+
+def test_next_step_unknown_status_raises(fake_context):
+    from agents._lib import errors
+    with pytest.raises(errors.AgentError):
+        _run("next-step", ["--status", "weird"], fake_context)
+
+
+def test_next_step_requires_input(fake_context):
+    from agents._lib import errors
+    with pytest.raises(errors.AgentError):
+        _run("next-step", [], fake_context)
+
+
+# -- checklist ---------------------------------------------------------------
+
+def test_checklist_covers_full_loop():
+    out = _run("checklist", ["--goal", "Stripe connector"])
+    phases = [s["phase"] for s in out["steps"]]
+    for expected in ("scope", "deliver", "install", "test", "improve"):
+        assert expected in phases
+    assert out["goal"] == "Stripe connector"

procesio_cli/agents/orchestrator/bootstraplib.py

@@ -0,0 +1,166 @@
+"""First-run detection + bootstrap of the user-data folder.
+
+The wipe-safety contract: deleting context-state-knowledge/ must never break the
+framework. Every component degrades to guidance ("no data - here is how to start"),
+and this module is the guidance engine:
+
+- **Templates** live in the FRAMEWORK, beside the component that owns them, as
+  ``<name>.template.json`` (e.g. ``agents/email-classifier/accounts.template.json``).
+  They contain placeholders only - never real user data - and map to
+  ``context-state-knowledge/config/<component>/<name>.json``.
+- **freshness()** decides "fresh start": zero records in the store AND zero files
+  under config/. A brand-new (or wiped) install trips it; the orchestrator and
+  curator surface it so the driver prompts the user instead of acting blind.
+- **bootstrap()** seeds the folder: ensures the store schema (via the context-store
+  tool - never opening the DB directly), regenerates the folder README, optionally
+  copies templates (never overwriting), and returns the onboarding checklist.
+"""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from tools._lib import userdata
+
+FRAMEWORK_ROOT = Path(__file__).resolve().parents[2]
+
+_TEMPLATE_SUFFIX = ".template.json"
+# Only the top level of each component dir - deep matches would pick up fixtures.
+_TEMPLATE_GLOBS = ("tools/*/*.template.json", "agents/*/*.template.json")
+
+
+def find_templates() -> list[dict]:
+    """Discover framework config templates and their user-data targets."""
+    out: list[dict] = []
+    base = userdata.base()
+    for pattern in _TEMPLATE_GLOBS:
+        for tpl in sorted(FRAMEWORK_ROOT.glob(pattern)):
+            component = tpl.parent.name
+            target_name = tpl.name[: -len(_TEMPLATE_SUFFIX)] + ".json"
+            target = base / "config" / component / target_name
+            out.append({
+                "component": component,
+                "template": str(tpl.relative_to(FRAMEWORK_ROOT)),
+                "target": str(target),
+                "target_exists": target.exists(),
+            })
+    return out
+
+
+def freshness(store_stats: dict | None) -> dict:
+    """Fresh start = empty store AND no user config. A folder that was wiped (or
+    never existed) scans exactly like this."""
+    scan = userdata.scan()
+    records = (store_stats or {}).get("records", 0) or 0
+    fresh = records == 0 and scan["config_files"] == 0
+    return {"fresh_start": fresh, "records": records, "scan": scan}
+
+
+def onboarding_hint() -> dict:
+    """The prompt a driver surfaces to the user on a fresh start."""
+    templates = find_templates()
+    return {
+        "message": ("No user context/knowledge/state found - this is a fresh "
+                    "install (or the user-data folder was wiped). The framework "
+                    "works; it just knows nothing about you yet."),
+        "initialize": ("python scripts/run-agent.py orchestrator bootstrap "
+                       "[--with-templates]"),
+        "steps": [
+            "Run bootstrap to seed the user-data folder (add --with-templates to "
+            "copy each component's config template for you to fill in).",
+            "Fill in the copied config templates (placeholders are marked; keep "
+            "accounts disabled until real).",
+            "Store credentials: python scripts/set-credential.py <tool> <secret> "
+            "(scripts/list-tools.py shows what each tool is missing).",
+            "Log in web sessions you need: run-tool web save-session --name <site> ...",
+            "Start building context: curator remember / curator capture as facts, "
+            "files and preferences come up - the store fills itself from use.",
+        ],
+        "templates": templates,
+    }
+
+
+def _readme_text() -> str:
+    return """# context-state-knowledge/ - your data, not the framework's
+
+Everything user-specific lives here: config, runtime state, knowledge, resources,
+preferences, decisions, run history, exports. The folder is **never git-versioned**
+and is **wipeable**: delete it and the framework still runs - it will detect the
+fresh start and guide whoever uses it next through building new context. That is the
+handover story: give the repo away, wipe this folder, done.
+
+Generated by `orchestrator bootstrap` - do not keep notes here by hand; use the
+curator (`curator remember` / `curator capture`) so knowledge stays structured.
+
+## Layout
+
+```
+store.db            SQLite store (records + runs) - access ONLY via the
+                    context-store tool or the curator agent
+config/<component>/ per-component user config (seeded from each component's
+                    <name>.template.json in the framework)
+state/<component>/  per-component runtime state
+sessions/           saved web login sessions (when migrated)
+exports/            human-readable dumps (curator export)
+```
+
+## Rebuilding after a wipe
+
+```
+python scripts/run-agent.py orchestrator bootstrap --with-templates
+```
+
+Then fill in the copied templates, store credentials with
+`python scripts/set-credential.py <tool> <secret>`, and start working - the
+orchestrator/curator build the rest from use. Secrets NEVER live in this folder;
+they stay in the OS credential store.
+"""
+
+
+def bootstrap(ctx, *, with_templates: bool = False) -> dict:
+    """Seed/repair the user-data folder. Idempotent; never overwrites user files."""
+    base = userdata.base()
+    # Ensure the store schema exists - through the tool, honoring the one-code-path
+    # rule. stats also tells us whether data already exists.
+    stats = ctx.cs("stats")
+    # Measure freshness BEFORE seeding: copying templates creates config files,
+    # which would otherwise hide that this was a fresh install needing onboarding.
+    fresh = freshness(stats)
+
+    readme = base / "README.md"
+    readme.write_text(_readme_text(), encoding="utf-8", newline="\n")
+
+    # Materialize the standard areas so the layout is visible.
+    for d in ("config", "state", "sessions", "exports"):
+        (base / d).mkdir(parents=True, exist_ok=True)
+
+    # Seed the schedule skeleton (commented, empty) so recurring work has a home.
+    from agents.orchestrator import schedulelib
+    seeded_schedule = schedulelib.ensure_skeleton()
+
+    copied, skipped = [], []
+    templates = find_templates()
+    if with_templates:
+        for t in templates:
+            target = Path(t["target"])
+            if target.exists():
+                skipped.append(t["target"])
+                continue
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(FRAMEWORK_ROOT / t["template"], target)
+            copied.append(t["target"])
+
+    return {
+        "base": str(base),
+        "store": stats,
+        "readme": str(readme),
+        "schedule_seeded": str(seeded_schedule) if seeded_schedule else None,
+        "templates_found": len(templates),
+        "templates_copied": copied,
+        "templates_skipped_existing": skipped,
+        "fresh_start": fresh["fresh_start"],
+        "onboarding": onboarding_hint() if fresh["fresh_start"] else None,
+        "note": ("templates were NOT copied; pass --with-templates to copy them"
+                 if not with_templates else
+                 "fill in the copied templates before enabling anything"),
+    }

procesio_cli/agents/procesio/IMPLEMENTATION-PATTERNS/00-INDEX.md

@@ -0,0 +1,60 @@
+# Implementation patterns: how this team builds in PROCESIO
+
+These patterns were distilled from a full audit of a production workspace: 9 forms, 91 processes and a
+SQL Server database with 51 tables and 23 stored procedures. That workspace covers form-driven request
+intake, agent review, LLM document extraction, ERP integration, SFTP archiving and multi-party
+e-signing. Every client-specific value has been removed. What remains is the **house style**: the
+techniques this team actually uses, stated so a builder in any workspace can apply them.
+
+The best-practices and playbook docs say what good looks like. These docs show how we build it here.
+Where the two disagree, trust the docs and treat the entry as a proposal to reconcile. Each entry
+marks whether it is **NEW**, **REFINES** an existing rule, or **CONFIRMS** one.
+
+| topic | file | covers |
+|---|---|---|
+| `patterns-processes` | 01-PROCESSES.md | result flags for forms, HTML rendered server-side, Node idioms, subprocess utilities, versioned scripts, status machines |
+| `patterns-forms` | 02-FORMS.md | step and confirm structure, visibility driven by process flags, JS bridges into no-code conditions, validator and collector runtimes, the async-output caveat |
+| `patterns-integrations` | 03-INTEGRATIONS.md | inbound webhooks with API keys, ERP step orchestration with a run log, SFTP layout, LLM extraction with strict schemas, document generation |
+| `patterns-database` | 04-DATABASE.md | a JSON-in orchestrator SP, errors collected before writes, one fixed result shape, deploy conventions, how a process reads a result |
+
+## Every pattern file also lists the anti-patterns the audit found
+
+Treat these as the house rules going forward:
+
+- **Never paste a process variable into SQL text** (`N'{{v}}'`). Bind parameters instead (`sql-parameterize`).
+  In the audited workspace almost every SQL node pasted values. A single apostrophe broke the save, and a
+  token from a public URL reached the database unfiltered.
+- **Hiding a section is not access control.** A public form that loads data on FORM_LOAD has already sent
+  that data to the browser.
+- **Wire error ports on every integration node** (HTTP, SFTP, SQL, LLM). An integration with no error port
+  fails silently.
+- **Keep secrets in credentials, never in application tables.**
+- **When a later event in the same click chain needs a process's outputs, run that process with `syncRun`.**
+- **Fix a JS runtime at one version on every element that installs it.** If each element carries a
+  different version, every one of them installs a fresh copy and the listeners pile up.
+
+## Workspace-specific knowledge (user data, not here)
+
+An audit also produces knowledge that names the workspace's own processes, tables and findings. That goes
+in the user-data folder, never in this framework folder:
+
+```
+context-state-knowledge/resources/procesio-workspaces/<workspace-slug>/
+  raw/                  API dumps (processes/, forms/) - input to the digests
+  processes/            flow-digest output (one .md per process + INDEX.md)
+  forms/                form-digest output (+ FORM-PROCESS-MAP.md, scripts, global code)
+  db-schema/            sqlserver schema-extract mirror
+  knowledge/            the curated knowledge + audit findings (README.md = entry point)
+```
+
+Before building in a workspace, check whether it has such a folder: run `curator recall --query
+"<workspace name> procesio knowledge"` or look in the folder directly. Build the same way its
+knowledge describes.
+
+To audit a new workspace, reproduce the folder with these steps:
+1. `request GET /api/Projects/<id>` for each process, and `form-get` plus `form-get-code` for each form,
+   into `raw/`.
+2. `flow-digest --in raw/processes --out processes --names names.json`.
+3. `form-digest --in raw/forms --processes raw/processes --out forms`.
+4. `sqlserver schema-extract --profile <p> --out db-schema`.
+5. Read and curate the results into `knowledge/`.