@meffecta/agent 1.0.8 → 1.0.9

package/engine.json

@@ -1,4 +1,4 @@
 {
-  "engineTag": "1.0.8",
-  "builtFrom": "09dbb9d808cafb8b06c0282602f1ca20914e3e6d"
+  "engineTag": "1.0.9",
+  "builtFrom": "4769315eb49ce1036f888ffafb03881ec4e91131"
 }

package/lib/create-job.js

@@ -180,7 +180,7 @@ function buildPrompt(description, { timezone, existing }) {
     "",
     "Before writing anything, read what this deployment actually is:",
     "  - jobs/*.md in your working directory — the house style, and what already exists",
-    "  - systems/ (or ENVIRONMENT.md) — what this deployment can reach, and the variables for each",
+    "  - systems/ — what this deployment can reach, one file per system, and the variables for each",
     "  - worlds/ if present — the projects/products a job can be pointed at",
     "  - your own available skills — use only skills that exist; never invent a capability",
     "",

package/lib/verify-credentials.js

@@ -40,8 +40,8 @@ PART 2 — this deployment's own systems.
 
 Part 1 tests what the ENGINE knows how to test. It cannot test a system belonging to this
 deployment specifically. The register of those is \`systems/\` in your working directory —
-one file per system — or, in a deployment that has not moved to that yet, a single
-ENVIRONMENT.md table. Read whichever is present.
+one file per system. If it is not there, say so and stop: a deployment with no register has
+no systems of its own that anything can check.
 
 Each file's frontmatter says what to do:
   system:     what it is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meffecta/agent",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Set up and operate a Meffecta Agent deployment — a self-hosted Claude Code job runner.",
   "type": "module",
   "bin": {

package/scripts/verify-credentials.mjs

@@ -8,7 +8,8 @@
 // Never prints a credential value. Exits 1 if anything configured actually fails.
 
 import { execFile } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const env = process.env;
@@ -674,8 +675,8 @@ results.sort((a, b) => a.name.localeCompare(b.name));
 // because this script ships to EVERY deployment and knows every integration the engine
 // supports — which is always more than any one deployment uses. Listing them individually
 // asks the operator "why is Kleer in my report?", and the honest answer is that it is not
-// theirs and never was. The deployment's own register of what it can reach is
-// ENVIRONMENT.md in its content repo; the catalogue of what it could add is `connect`.
+// theirs and never was. The deployment's own register of what it can reach is `systems/`
+// in its content repo; the catalogue of what it could add is `connect`.
 // Credentials this script has never heard of.
 //
 // A deployment adds its own systems, and their keys are just secrets bound to the service:
@@ -685,8 +686,8 @@ results.sort((a, b) => a.name.localeCompare(b.name));
 // "everything works" while a set-but-never-exercised key sits beside it.
 //
 // So: name them, say plainly that nothing here can test them, and let the run that called
-// this reconcile them against ENVIRONMENT.md — the deployment's own register does know
-// what they are and which skill reaches them.
+// this reconcile them against `systems/` — the deployment's own register does know what
+// they are and which skill reaches them.
 //
 // Known-ness is decided from this file's own source, so the list maintains itself: if the
 // script mentions the variable, or the family it belongs to, it knows about it.
@@ -736,9 +737,39 @@ console.log(`\n${configured.length - failures.length} working, ${failures.length
 if (unknownCredentials.length) {
   // Names only. This script never prints a value, and that holds hardest for the ones it
   // does not understand.
+  //
+  // Which of them are a PROBLEM, though, is a question this script can answer without
+  // knowing anything about the systems themselves: the register travels into every run, so
+  // it is right here in the working directory. A credential named in it is deliberate, and
+  // proving it works is Part 2's job; one named nowhere is a key no skill will ever reach
+  // for, however valid it is. Printing the whole list as a to-do told the operator to
+  // register things that were already registered, which is how a real gap gets skimmed
+  // past.
+  const registered = new Set();
+  const registerDir = join(process.cwd(), "systems");
+  if (existsSync(registerDir)) {
+    for (const entry of readdirSync(registerDir)) {
+      if (!entry.endsWith(".md")) continue;
+      const text = readFileSync(join(registerDir, entry), "utf8");
+      for (const name of unknownCredentials) {
+        if (text.includes(name)) registered.add(name);
+      }
+    }
+  }
+  const unregistered = unknownCredentials.filter((name) => !registered.has(name));
   console.log(`\nSet, but nothing here knows how to test them (${unknownCredentials.length}):`);
   console.log(`  ${unknownCredentials.join(", ")}`);
-  console.log("  Each should have a row in ENVIRONMENT.md saying which skill reaches it.");
+  if (!existsSync(registerDir)) {
+    // No register to read — say the general thing rather than accuse every one of them.
+    console.log("  Each needs a file in systems/ saying which skill reaches it.");
+  } else {
+    if (registered.size) {
+      console.log(`  In systems/, so a job can reach them: ${[...registered].sort().join(", ")}`);
+    }
+    if (unregistered.length) {
+      console.log(`  Not in systems/, so no skill will find them: ${unregistered.join(", ")}`);
+    }
+  }
 }
 if (unconfigured.length) {
   console.log(`\nNot set up here (${unconfigured.length}): ${unconfigured.map((r) => r.name).join(", ")}.`);