@synap-core/workspace-templates 0.11.0 → 0.23.0

package/src/jev.test.ts

@@ -0,0 +1,356 @@
+/**
+ * Jev (capability `jev`): the four verbs speak TypeSafe's System One API.
+ *
+ * SEAM: each verb's REAL `code` body, run the way the pod's executor wraps it
+ * (`async (args, context) => { <code> }` with `callProvider` in scope), against
+ * responses shaped like TypeSafe's documented examples
+ * (https://docs.typesafe.ai/api/system-one.md, OpenAPI 0.2.0, read 2026-10-28).
+ * The request asserted is exactly what `callProvider` would send.
+ *
+ * NOT covered: Jev's live behaviour (the founder's own install is the live
+ * test), the pod's `{{param}}` interpolation (simulated below the way
+ * `interpolateDeep` does it) and the IS isolate (Node's AsyncFunction is used).
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const manifest = JSON.parse(
+  readFileSync(join(HERE, "../capabilities/jev.capability.json"), "utf8")
+);
+type Skill = {
+  name: string;
+  code?: string;
+  parameters?: Record<string, string>;
+};
+const skills = manifest.spec.skills as Skill[];
+
+const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor as new (
+  ...args: string[]
+) => (...a: unknown[]) => Promise<unknown>;
+
+type Call = {
+  tool: string;
+  method: string;
+  path: string;
+  input: Record<string, any>;
+};
+function verb(name: string) {
+  const code = skills.find((s) => s.name === name)!.code!;
+  const body = new AsyncFunction("args", "context", "callProvider", code);
+  return async (
+    args: Record<string, unknown>,
+    answers: Record<string, unknown>,
+    status = 200
+  ) => {
+    const calls: Call[] = [];
+    const callProvider = async (
+      tool: string,
+      method: string,
+      path: string,
+      input: Record<string, any>
+    ) => {
+      calls.push({ tool, method, path, input });
+      return {
+        status,
+        headers: {},
+        body: {
+          model: input.model,
+          answers,
+          usage: { input_tokens: 120, output_tokens: 12 },
+        },
+      };
+    };
+    const out = (await body(args, {}, callProvider)) as Record<string, any>;
+    return { out, calls };
+  };
+}
+
+/**
+ * What the pod checks BEFORE a verb runs (backend validate-verb-parameters.ts):
+ * each declared field's base type against the argument's runtime type, and
+ * required fields present. The live run of 28 Oct was refused there ("options
+ * should be array, got object") while every code-level test passed.
+ */
+function declaredTypeErrors(
+  name: string,
+  args: Record<string, unknown>
+): string[] {
+  const declared = skills.find((s) => s.name === name)!.parameters ?? {};
+  const kind = (v: unknown) =>
+    Array.isArray(v) ? "array" : v === null ? "null" : typeof v;
+  const errors: string[] = [];
+  for (const [field, type] of Object.entries(declared)) {
+    const optional = type.endsWith("?");
+    const base = type.replace(/\?$/, "");
+    if (!(field in args)) {
+      if (!optional) errors.push(`${field} missing`);
+      continue;
+    }
+    if (kind(args[field]) !== base)
+      errors.push(`${field} should be ${base}, got ${kind(args[field])}`);
+  }
+  return errors;
+}
+
+const STATE =
+  "I was charged twice for my subscription this month. Please refund the extra charge.";
+
+describe("jev_choose — one choice question, Jev's probabilities and confidence back", () => {
+  it("sends one POST /v1/systemone through jev_api with the options as criteria", async () => {
+    const { out, calls } = await verb("jev_choose")(
+      {
+        state: STATE,
+        question: "What is the tone?",
+        options: ["angry", "calm"],
+        descriptions: { angry: "An upset message", calm: "A polite message" },
+        minConfidence: 0.6,
+      },
+      {
+        decision: {
+          type: "choice",
+          choice: "calm",
+          confidence: 0.7,
+          probabilities: { angry: 0.2, calm: 0.8 },
+        },
+      }
+    );
+    expect(calls).toEqual([
+      {
+        tool: "jev_api",
+        method: "POST",
+        path: "/v1/systemone",
+        input: {
+          model: "jev-latest",
+          state: STATE,
+          questions: {
+            decision: {
+              type: "choice",
+              instructions: "What is the tone?",
+              criteria: { angry: "An upset message", calm: "A polite message" },
+            },
+          },
+        },
+      },
+    ]);
+    expect(out).toMatchObject({
+      choice: "calm",
+      confidence: 0.7,
+      confident: true,
+      probabilities: { angry: 0.2, calm: 0.8 },
+      model: "jev-latest",
+    });
+  });
+
+  it("a list of options becomes criteria keyed by the option; under minConfidence is not confident", async () => {
+    const { out, calls } = await verb("jev_choose")(
+      {
+        state: STATE,
+        question: "Which team?",
+        options: ["billing", "support", "none_of_these"],
+        minConfidence: 0.8,
+      },
+      {
+        decision: {
+          type: "choice",
+          choice: "billing",
+          confidence: 0.55,
+          probabilities: { billing: 0.6, support: 0.3, none_of_these: 0.1 },
+        },
+      }
+    );
+    expect(calls[0].input.questions.decision.criteria).toEqual({
+      billing: "billing",
+      support: "support",
+      none_of_these: "none_of_these",
+    });
+    expect(out.confident).toBe(false);
+  });
+
+  it("a model passed in the call is the one sent", async () => {
+    const { calls } = await verb("jev_choose")(
+      {
+        state: STATE,
+        question: "Tone?",
+        options: ["angry", "calm"],
+        model: "jev-1.14.0",
+      },
+      {
+        decision: {
+          type: "choice",
+          choice: "calm",
+          confidence: 0.9,
+          probabilities: {},
+        },
+      }
+    );
+    expect(calls[0].input.model).toBe("jev-1.14.0");
+  });
+
+  it("refuses fewer than 2 options or no state, before calling Jev", async () => {
+    await expect(
+      verb("jev_choose")(
+        { state: STATE, question: "Tone?", options: ["calm"] },
+        {}
+      )
+    ).rejects.toThrow(/at least 2 options/);
+    await expect(
+      verb("jev_choose")({ question: "Tone?", options: ["a", "b"] }, {})
+    ).rejects.toThrow(/state is required/);
+  });
+
+  it("a non-2xx answer fails loudly with Jev's status", async () => {
+    await expect(
+      verb("jev_choose")(
+        { state: STATE, question: "Tone?", options: ["a", "b"] },
+        {},
+        429
+      )
+    ).rejects.toThrow(/Jev answered 429/);
+  });
+});
+
+describe("the template can be updated on every pod", () => {
+  // The pod's capability reconcile refuses to re-apply a skill whose code carries an
+  // install-time {{param}} ("manual re-apply needed"): on 28 Oct every installed jev was stuck
+  // on its install-day version because each verb baked {{jevModel}} into its code.
+  const codeSkills = skills.filter((s) => s.code && s.name.startsWith("jev_"));
+
+  it("sees every verb's code (the scan is not empty)", () => {
+    expect(codeSkills.map((s) => s.name).sort()).toEqual([
+      "jev_ask",
+      "jev_choose",
+      "jev_noul",
+      "jev_score",
+    ]);
+  });
+
+  it.each(codeSkills.map((s) => [s.name, s.code!] as const))(
+    "%s carries no install-time placeholder in its code",
+    (_name, code) => {
+      expect(code).not.toMatch(/\{\{\s*\w+\s*\}\}/);
+    }
+  );
+});
+
+describe("every verb speaks System One", () => {
+  // Each verb carries its own copy of the call helper (skill code is standalone), so each is checked.
+  const cases: Array<[string, Record<string, unknown>]> = [
+    [
+      "jev_choose",
+      {
+        state: STATE,
+        question: "Tone?",
+        options: ["a", "b"],
+        descriptions: { a: "first", b: "second" },
+      },
+    ],
+    [
+      "jev_score",
+      { state: STATE, question: "Urgency?", levels: ["low", "high"] },
+    ],
+    ["jev_noul", { state: STATE, question: "Billing?" }],
+    [
+      "jev_ask",
+      {
+        state: STATE,
+        questions: { q: { type: "noul", instructions: "Billing?" } },
+      },
+    ],
+  ];
+  it.each(cases)(
+    "%s posts to /v1/systemone through jev_api with the default model",
+    async (name, args) => {
+      expect(declaredTypeErrors(name, args)).toEqual([]);
+      const { calls } = await verb(name)(args, {});
+      expect(calls).toHaveLength(1);
+      expect(calls[0]).toMatchObject({
+        tool: "jev_api",
+        method: "POST",
+        path: "/v1/systemone",
+        input: { model: "jev-latest", state: STATE },
+      });
+    }
+  );
+});
+
+describe("jev_score, jev_noul, jev_ask — the other primitives", () => {
+  it("jev_score sends ordered levels as criteria and returns the score", async () => {
+    const { out, calls } = await verb("jev_score")(
+      {
+        state: STATE,
+        question: "How urgent?",
+        levels: ["Can wait", "This week", "Today"],
+      },
+      {
+        rating: {
+          type: "score",
+          score: 1.7,
+          confidence: 0.55,
+          legend: { "0": "Can wait", "1": "This week", "2": "Today" },
+          probabilities: { "0": 0.1, "1": 0.1, "2": 0.8 },
+        },
+      }
+    );
+    expect(calls[0].input.questions).toEqual({
+      rating: {
+        type: "score",
+        instructions: "How urgent?",
+        criteria: ["Can wait", "This week", "Today"],
+      },
+    });
+    expect(out).toMatchObject({ score: 1.7, confidence: 0.55 });
+  });
+
+  it("jev_noul asks a yes/no question and returns the probability of yes", async () => {
+    const { out, calls } = await verb("jev_noul")(
+      { state: STATE, question: "Is this about billing?" },
+      { answer: { type: "noul", noul: 0.98 } }
+    );
+    expect(calls[0].input.questions).toEqual({
+      answer: { type: "noul", instructions: "Is this about billing?" },
+    });
+    expect(out.probabilityYes).toBe(0.98);
+  });
+
+  it("jev_ask sends several questions in ONE call and returns the answers by name", async () => {
+    const questions = {
+      billing: { type: "noul", instructions: "Is this about billing?" },
+      tone: {
+        type: "choice",
+        instructions: "Tone?",
+        criteria: { angry: "upset", calm: "polite" },
+      },
+    };
+    const answers = {
+      billing: { type: "noul", noul: 0.98 },
+      tone: {
+        type: "choice",
+        choice: "calm",
+        confidence: 0.7,
+        probabilities: { angry: 0.2, calm: 0.8 },
+      },
+    };
+    const { out, calls } = await verb("jev_ask")(
+      { state: STATE, questions },
+      answers
+    );
+    expect(calls).toHaveLength(1);
+    expect(calls[0].input.questions).toEqual(questions);
+    expect(out.answers).toEqual(answers);
+  });
+
+  it("jev_ask refuses a question type Jev does not have", async () => {
+    await expect(
+      verb("jev_ask")(
+        {
+          state: STATE,
+          questions: { q: { type: "generate", instructions: "Write a reply" } },
+        },
+        {}
+      )
+    ).rejects.toThrow(/use choice, score or noul/);
+  });
+});

package/src/legal.yaml

@@ -13,6 +13,12 @@ meta:
   color: "#4338CA"
   tags: [legal, contracts, compliance, ip]
   isPublic: true
+  # What this space PRODUCES (homes): the purpose word, then its kinds/roles.
+  intent:
+    label: Legal
+    produces:
+      - profile: legal-contract
+      - profile: compliance-item
 
 workspace:
   name: Legal
@@ -20,7 +26,10 @@ workspace:
   proposalId: legal-v1
   subtype: legal
   visibility: members
-  workspaceType: operational
+  # A DOMAIN workspace that holds entities — NOT `operational`. `operational`
+  # marks an admin/system surface: `isDomainHomeWorkspace` refuses filing
+  # entities into it and excludes it from auto-placement (2026-09-25).
+  workspaceType: personal
   capabilities:
     - legal.contracts
     - legal.compliance
@@ -74,6 +83,17 @@ profiles:
     icon: file-signature
     color: violet
     description: "A legal agreement with a counterparty — its status, term, and renewal."
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: status
+      options:
+        - { key: draft, category: open }
+        - { key: in-review, category: active }
+        - { key: negotiation, category: active }
+        - { key: signed, category: active }
+        - { key: active, category: active }
+        - { key: expired, category: done }
+        - { key: terminated, category: lost }
     properties:
       - slug: contractType
         label: Type
@@ -139,6 +159,15 @@ profiles:
     icon: shield-check
     color: cyan
     description: "A regulatory or legal obligation with an owner and a deadline."
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: status
+      options:
+        - { key: not-started, category: open }
+        - { key: in-progress, category: active }
+        - { key: submitted, category: active }
+        - { key: complete, category: done }
+        - { key: overdue, category: active }
     properties:
       - slug: obligationType
         label: Obligation Type
@@ -498,14 +527,17 @@ onboarding:
       lawyer, and not one invented legal conclusion anywhere in it.
   collect:
     - profileSlug: legal-entity
+      min: 1
       what: The company's legal entities and the jurisdictions they operate in.
       cardinality: few
       keyFields: [entityType, jurisdiction, status]
     - profileSlug: legal-contract
+      min: 1
       what: The key live agreements — the ones with real obligations, value, or renewal dates.
       cardinality: several
       keyFields: [contractType, status, counterparty, renewalDate]
     - profileSlug: compliance-item
+      min: 1
       what: Compliance obligations and filings with real deadlines.
       cardinality: several
       keyFields: [obligationType, dueDate, owner]