@cohortapp/agent-sdk 2.3.0

package/lib/org/board.test.mjs

@@ -0,0 +1,177 @@
+/**
+ * board.test.mjs — agent-side board ops routing + the read-only YAML projection
+ * writer. Ops are verified against an injected client (no network); the
+ * projection writer is verified against a real tmp dir (atomic write).
+ *
+ * Run: node --test lib/org/board.test.mjs
+ */
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  createItem, claimItem, completeItem, decompose, assign, link, ready,
+  buildProjection, writeProjection, writeReadyProjection,
+} from "./board.mjs";
+import { okFrame, errFrame, BOARD_STATUS } from "./protocol.mjs";
+
+function tmp() { return mkdtempSync(join(tmpdir(), "org-board-")); }
+const CONN = { base: "https://org.cohortapp.com", token: "tok" };
+
+/** A fake client that records which helper was called with what. */
+function fakeClient(map = {}) {
+  const calls = [];
+  const make = (name) => async (params, opts) => {
+    calls.push({ name, params, opts });
+    return (map[name] || (() => okFrame(null)))(params, opts);
+  };
+  return {
+    calls,
+    createItem: make("createItem"),
+    claimItem: make("claimItem"),
+    completeItem: make("completeItem"),
+    boardDecompose: make("boardDecompose"),
+    boardAssign: make("boardAssign"),
+    boardLink: make("boardLink"),
+    listReady: make("listReady"),
+  };
+}
+
+// --- ops route to the right client helpers ---------------------------------
+
+test("board ops route to their client helpers, forwarding conn opts", async () => {
+  const client = fakeClient();
+  const o = { client, ...CONN, idempotencyKey: "k" };
+  await createItem({ id: "i1", title: "t" }, o);
+  await claimItem({ itemId: "i1" }, o);
+  await completeItem({ itemId: "i1", proof: { url: "x" } }, o);
+  await decompose({ itemId: "i1", children: [{ title: "c" }] }, o);
+  await assign({ itemId: "i1", assignee: "bob" }, o);
+  await link({ fromItemId: "i1", toItemId: "i2", type: "blocks" }, o);
+  await ready(o);
+  assert.deepEqual(client.calls.map((c) => c.name), [
+    "createItem", "claimItem", "completeItem", "boardDecompose", "boardAssign", "boardLink", "listReady",
+  ]);
+  // conn opts are forwarded (base/token/idempotencyKey) on a side-effecting call
+  const claim = client.calls.find((c) => c.name === "claimItem");
+  assert.equal(claim.opts.base, CONN.base);
+  assert.equal(claim.opts.token, CONN.token);
+  assert.equal(claim.opts.idempotencyKey, "k");
+});
+
+test("decompose/assign surface the server's GOVERNANCE_NOT_READY frame untouched", async () => {
+  const client = fakeClient({
+    boardDecompose: () => errFrame("GOVERNANCE_NOT_READY", "decision_rights empty"),
+    boardAssign: () => errFrame("GOVERNANCE_NOT_READY", "decision_rights empty"),
+  });
+  const d = await decompose({ itemId: "i1", children: [] }, { client, ...CONN });
+  assert.equal(d.ok, false);
+  assert.equal(d.error.code, "GOVERNANCE_NOT_READY");
+  const a = await assign({ itemId: "i1", assignee: "bob" }, { client, ...CONN });
+  assert.equal(a.error.code, "GOVERNANCE_NOT_READY");
+});
+
+test("ready: returns the items array (fail-open [] handled by the client)", async () => {
+  const client = fakeClient({ listReady: () => [{ id: "r1" }, { id: "r2" }] });
+  assert.deepEqual(await ready({ client, ...CONN }), [{ id: "r1" }, { id: "r2" }]);
+});
+
+// --- projection: pure builder ----------------------------------------------
+
+test("buildProjection: groups by status, counts, stamps metadata", () => {
+  const items = [
+    { id: "a", title: "A", status: "ready", priority: "high" },
+    { id: "b", title: "B", status: "running", assignee_agent: "bob" },
+    { id: "c", title: "C", status: "done" },
+  ];
+  const doc = buildProjection(items, { board: "growth", generatedAt: "2026-06-11T00:00:00Z", cursorHead: 42 });
+  assert.equal(doc.schemaVersion, 1);
+  assert.equal(doc.board, "growth");
+  assert.equal(doc.generatedAt, "2026-06-11T00:00:00Z");
+  assert.equal(doc.cursorHead, 42);
+  assert.equal(doc.count, 3);
+  assert.equal(doc.byStatus.ready, 1);
+  assert.equal(doc.byStatus.running, 1);
+  assert.equal(doc.byStatus.done, 1);
+  // every canonical status present (even at zero) so the view is stable
+  for (const s of BOARD_STATUS) assert.ok(s in doc.byStatus);
+  // assignee projected from assignee_agent; id/title/status normalised
+  assert.equal(doc.items[1].assignee, "bob");
+});
+
+test("buildProjection: normalises id aliases and never leaks lease/token fields", () => {
+  const doc = buildProjection([
+    { itemId: "x1", title: "X", status: "ready", lease_token: "SECRET", token: "SECRET2" },
+  ]);
+  const it = doc.items[0];
+  assert.equal(it.id, "x1");
+  assert.ok(!("lease_token" in it), "lease_token must not appear on a read surface");
+  assert.ok(!("token" in it), "token must not appear on a read surface");
+});
+
+test("buildProjection: unknown status buckets under _other (no silent drop)", () => {
+  const doc = buildProjection([{ id: "z", title: "Z", status: "weird-future-status" }]);
+  assert.equal(doc.byStatus._other, 1);
+  assert.equal(doc.count, 1);
+});
+
+// --- projection: writer ----------------------------------------------------
+
+test("writeProjection: writes a read-only YAML with provenance header; parses back", async () => {
+  const root = tmp();
+  try {
+    const items = [{ id: "a", title: "Ship it", status: "ready" }];
+    const path = await writeProjection(root, items, { board: "self", generatedAt: "2026-06-11T00:00:00Z" });
+    assert.equal(path, join(root, "state", "org", "board", "self.yaml"));
+    assert.ok(existsSync(path));
+    const raw = readFileSync(path, "utf8");
+    assert.match(raw, /DERIVED, READ-ONLY/);
+    assert.match(raw, /DO NOT hand-edit/);
+    // round-trips through the YAML parser
+    const m = await import("js-yaml");
+    const doc = (m.default || m).load(raw);
+    assert.equal(doc.board, "self");
+    assert.equal(doc.count, 1);
+    assert.equal(doc.items[0].id, "a");
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test("writeProjection: sanitises the board name into the filename", async () => {
+  const root = tmp();
+  try {
+    const path = await writeProjection(root, [], { board: "growth/../etc" });
+    assert.ok(path.endsWith(join("state", "org", "board", "growth_.._etc.yaml")));
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test("writeProjection: no agentRoot → null (fail-open)", async () => {
+  assert.equal(await writeProjection("", [{ id: "a" }]), null);
+});
+
+test("writeReadyProjection: pulls board.ready and writes ready.yaml", async () => {
+  const root = tmp();
+  try {
+    const client = fakeClient({ listReady: () => [{ id: "r1", title: "do", status: "ready" }] });
+    const path = await writeReadyProjection(root, { client, ...CONN, generatedAt: "2026-06-11T00:00:00Z" });
+    assert.equal(path, join(root, "state", "org", "board", "ready.yaml"));
+    const m = await import("js-yaml");
+    const doc = (m.default || m).load(readFileSync(path, "utf8"));
+    assert.equal(doc.board, "ready");
+    assert.equal(doc.items[0].id, "r1");
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
+
+test("writeReadyProjection: down server (empty ready) writes an empty projection", async () => {
+  const root = tmp();
+  try {
+    const client = fakeClient({ listReady: () => [] });
+    const path = await writeReadyProjection(root, { client, ...CONN });
+    const m = await import("js-yaml");
+    const doc = (m.default || m).load(readFileSync(path, "utf8"));
+    assert.equal(doc.count, 0);
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});

package/lib/org/bootstrap-context.mjs

@@ -0,0 +1,169 @@
+/**
+ * lib/org/bootstrap-context.mjs — assemble the agent's authoritative org context
+ * from Cohort in ONE pass, so a provisioned agent consumes the org as its source
+ * of truth rather than running on a locally-synthesised picture.
+ *
+ * `bootstrapContext(o)` pulls (each fail-open, in parallel where safe):
+ *   - self profile        (org-data API: GET /api/v1/org/whoami|members/<slug>)
+ *   - org chart           (org-data API: GET /api/v1/org/chart)
+ *   - relationships       (org-data API: GET /api/v1/org/relationships?member=)
+ *   - strategy            (org-data API: GET /api/v1/org/strategy)
+ *   - hierarchy           (/v1 read surface: GET /v1/hierarchy)
+ *   - adopted decisions   (/v1 read surface: GET /v1/decision.list)
+ *   - policy bundle       (/v1 read surface: GET /v1/policy)
+ *   - board.ready feed    (/v1 read surface: GET /v1/board.ready)
+ *
+ * and returns a single
+ *   { profile, chart, relationships, strategy, hierarchy, decisions, policy, board }
+ * object. Every object-shaped part is `null` when its fetch failed; the two
+ * array-shaped reads (decisions, board) degrade to `[]` (their published
+ * fail-open value — an empty feed is indistinguishable from a failed one over the
+ * read contract). NEVER throws: a degraded/unreachable Cohort yields a context
+ * full of nulls/empties and the agent falls back to its local model.
+ *
+ * The credential model mirrors the rest of lib/org: the org-data DTO reads take
+ * the org API KEY as `apiKey` (Bearer + `?slug=`), the /v1 reads take it as the
+ * bearer `token` — in practice the SAME OrgApiKey, so `token` defaults to
+ * `apiKey` when not separately supplied. `fetchImpl` is injectable for tests.
+ *
+ * Node builtins only. ESM.
+ *
+ * @module lib/org/bootstrap-context
+ */
+
+"use strict";
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeJsonAtomic } from "../fs-atomic.mjs";
+import {
+  fetchSelfProfile,
+  fetchOrgChart,
+  fetchRelationships,
+  fetchStrategy,
+  fetchHierarchy,
+  decisionList,
+  policyFetch,
+  listReady,
+} from "./client.mjs";
+
+/** Relative path of the persisted org-context cache. */
+export const ORG_CONTEXT_REL = join("config", "org-context.json");
+
+/** Unwrap a res frame to its bare result, or null when the frame is not ok. */
+function frameResult(frame) {
+  return frame && frame.ok && frame.result != null ? frame.result : null;
+}
+
+/** Resolve a promise that may reject into a benign fallback (never throws). */
+async function safe(promise, fallback) {
+  try {
+    return await promise;
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Fetch the agent's full org context in one pass. Fail-open throughout.
+ *
+ * @param {object} o
+ * @param {string} o.base     Cohort server origin
+ * @param {string} o.apiKey   org API key (Bearer; used for the org-data DTO reads)
+ * @param {string} [o.token]  bearer for the /v1 read surface (defaults to apiKey)
+ * @param {string} o.orgId    org slug (?slug= for org-data; x-org-id pin for /v1)
+ * @param {string} [o.agentId]   this agent's member slug (selects members/<slug>)
+ * @param {string} [o.emailHint] email hint for whoami resolution
+ * @param {Function} [o.fetchImpl] injectable fetch for tests
+ * @returns {Promise<{profile:object|null, chart:object|null, relationships:object|null, strategy:object|null, hierarchy:object|null, decisions:object[], policy:object|null, board:object[]}>}
+ */
+export async function bootstrapContext(o = {}) {
+  const base = o.base ? String(o.base) : "";
+  const apiKey = o.apiKey ? String(o.apiKey) : "";
+  // The /v1 read surface authenticates with the same OrgApiKey as a Bearer
+  // `token`; honour an explicit token but fall back to the api key.
+  const token = o.token ? String(o.token) : apiKey;
+  const orgId = o.orgId ? String(o.orgId) : "";
+  const fetchImpl = o.fetchImpl;
+  const dataOpts = { base, apiKey, orgId, fetchImpl };
+  const readOpts = { base, token, orgId, fetchImpl };
+
+  // Self first: relationships are keyed by the member slug, which we derive from
+  // an explicit agentId or the resolved self profile. Everything else is
+  // independent and fans out in parallel.
+  const profile = frameResult(await safe(fetchSelfProfile({ ...dataOpts, agentId: o.agentId || undefined, emailHint: o.emailHint || undefined }), null));
+  const memberSlug = (o.agentId && String(o.agentId)) || (profile && profile.slug ? String(profile.slug) : "");
+
+  const [chart, relationships, strategy, hierarchy, decisions, policy, board] = await Promise.all([
+    safe(fetchOrgChart(dataOpts), null).then(frameResult),
+    memberSlug
+      ? safe(fetchRelationships({ ...dataOpts, member: memberSlug }), null).then(frameResult)
+      : Promise.resolve(null),
+    safe(fetchStrategy(dataOpts), null).then(frameResult),
+    safe(fetchHierarchy(readOpts), null),
+    safe(decisionList(readOpts), []),
+    safe(policyFetch(readOpts), null),
+    safe(listReady(readOpts), []),
+  ]);
+
+  return {
+    profile,
+    chart,
+    relationships,
+    strategy,
+    hierarchy,
+    decisions: Array.isArray(decisions) ? decisions : [],
+    policy,
+    board: Array.isArray(board) ? board : [],
+  };
+}
+
+/**
+ * Persist a bootstrapped context to `config/org-context.json` via the atomic FS
+ * util (crash-safe write-temp → fsync → rename). Stamps `fetchedAt`. Fail-open:
+ * an IO error returns null rather than throwing, so a failed cache write can
+ * never take down setup/sync.
+ * @param {string} agentRoot
+ * @param {object} ctx the bootstrapContext result
+ * @returns {string|null} the written path, or null on failure
+ */
+export function persistOrgContext(agentRoot, ctx) {
+  try {
+    const path = join(agentRoot, ORG_CONTEXT_REL);
+    writeJsonAtomic(path, { fetchedAt: new Date().toISOString(), ...ctx });
+    return path;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load the cached org context from `config/org-context.json`. Returns null when
+ * absent or unparseable (fail-open) so the awareness SDK can null-check uniformly.
+ * @param {string} agentRoot
+ * @returns {object|null}
+ */
+export function loadOrgContext(agentRoot) {
+  try {
+    const path = join(agentRoot, ORG_CONTEXT_REL);
+    if (!existsSync(path)) return null;
+    const doc = JSON.parse(readFileSync(path, "utf8"));
+    return doc && typeof doc === "object" ? doc : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Bootstrap + persist in one call (the seam `maestro setup`/`sync` wires). Pulls
+ * the context and writes the cache; returns `{ ctx, path }`. Fail-open: a
+ * degraded Cohort still yields a (mostly-null) ctx and a best-effort cache.
+ * @param {string} agentRoot
+ * @param {object} o the bootstrapContext options
+ * @returns {Promise<{ctx:object, path:string|null}>}
+ */
+export async function bootstrapAndPersist(agentRoot, o = {}) {
+  const ctx = await bootstrapContext(o);
+  const path = persistOrgContext(agentRoot, ctx);
+  return { ctx, path };
+}

package/lib/org/bootstrap-context.test.mjs

@@ -0,0 +1,153 @@
+/**
+ * bootstrap-context.test.mjs — assemble the agent's org context in one pass,
+ * fail-open per part, and persist/load it via the atomic FS util. Uses an
+ * injected fetchImpl that routes by URL (no network).
+ * Run: node --test lib/org/bootstrap-context.test.mjs
+ */
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { bootstrapContext, persistOrgContext, loadOrgContext, bootstrapAndPersist, ORG_CONTEXT_REL } from "./bootstrap-context.mjs";
+
+const BASE = "https://org.cohortapp.com";
+
+const PROFILE = { slug: "robin", kind: "AI_AGENT", displayName: "Robin Vega", agentEmail: "robin@example.com", escalationPath: "CTO then CEO" };
+const CHART = { ok: true, nodes: [{ slug: "robin", displayName: "Robin Vega" }], edges: [{ kind: "reporting", from: "layla", to: "robin", type: "SOLID" }] };
+const REL = { ok: true, member: { slug: "robin" }, reportingLine: { manager: { slug: "layla", displayName: "Layla" } }, reports: [{ member: { slug: "kai", displayName: "Kai" }, style: "SOLID" }], governance: [] };
+const STRATEGY = { ok: true, strategy: { slug: "strategy", northStar: { goal: "win" }, phases: [], streams: [{ code: "S1", name: "Growth", raci: [{ role: "Accountable", member: { slug: "robin", displayName: "Robin Vega" } }] }] } };
+const HIERARCHY = { members: [{ slug: "robin" }, { slug: "layla" }], reporting: [{ from: "layla", to: "robin" }] };
+const DECISIONS = { decisions: [{ id: "D1", title: "Adopt postgres", status: "adopted" }] };
+const POLICY = { bundleId: "policy-1", version: 3 };
+const BOARD = { items: [{ id: "T1", title: "Do the thing" }] };
+
+/**
+ * A fetch that routes by URL. `failing` is a Set of keys to make return non-ok.
+ * Keys: profile, chart, relationships, strategy, hierarchy, decisions, policy, board.
+ */
+function routerFetch(failing = new Set()) {
+  const calls = [];
+  const reply = (key, body) => {
+    if (failing.has(key)) {
+      return { ok: false, status: 503, headers: { get: () => undefined }, json: async () => ({ ok: false, error: { code: "INTERNAL", message: "down" } }) };
+    }
+    return { ok: true, status: 200, headers: { get: () => undefined }, json: async () => body };
+  };
+  const impl = async (url) => {
+    calls.push(String(url));
+    const u = String(url);
+    if (u.includes("/api/v1/org/whoami") || u.includes("/api/v1/org/members/")) return reply("profile", PROFILE);
+    if (u.includes("/api/v1/org/chart")) return reply("chart", CHART);
+    if (u.includes("/api/v1/org/relationships")) return reply("relationships", REL);
+    if (u.includes("/api/v1/org/strategy")) return reply("strategy", STRATEGY);
+    if (u.includes("/v1/hierarchy")) return reply("hierarchy", HIERARCHY);
+    if (u.includes("/v1/decision.list")) return reply("decisions", DECISIONS);
+    if (u.includes("/v1/policy")) return reply("policy", POLICY);
+    if (u.includes("/v1/board.ready")) return reply("board", BOARD);
+    return { ok: false, status: 404, headers: { get: () => undefined }, json: async () => ({ ok: false, error: { code: "NOT_FOUND", message: "x" } }) };
+  };
+  impl.calls = calls;
+  return impl;
+}
+
+function tmpRoot() {
+  const root = mkdtempSync(join(tmpdir(), "maestro-bootstrap-"));
+  mkdirSync(join(root, "config"), { recursive: true });
+  return root;
+}
+
+test("bootstrapContext: happy path populates every part", async () => {
+  const f = routerFetch();
+  const ctx = await bootstrapContext({ base: BASE, apiKey: "key", orgId: "acme", agentId: "robin", fetchImpl: f });
+  assert.equal(ctx.profile.slug, "robin");
+  assert.equal(ctx.chart.nodes.length, 1);
+  assert.equal(ctx.relationships.reportingLine.manager.slug, "layla");
+  assert.equal(ctx.strategy.streams[0].code, "S1");
+  assert.equal(ctx.hierarchy.members.length, 2);
+  assert.equal(ctx.decisions[0].id, "D1");
+  assert.equal(ctx.policy.bundleId, "policy-1");
+  assert.equal(ctx.board[0].id, "T1");
+});
+
+test("bootstrapContext: relationships uses agentId; chart/strategy slug-scoped", async () => {
+  const f = routerFetch();
+  await bootstrapContext({ base: BASE, apiKey: "key", orgId: "acme", agentId: "robin", fetchImpl: f });
+  assert.ok(f.calls.some((u) => u === `${BASE}/api/v1/org/relationships?orgId=acme&member=robin`));
+  assert.ok(f.calls.some((u) => u === `${BASE}/api/v1/org/chart?orgId=acme`));
+  assert.ok(f.calls.some((u) => u === `${BASE}/api/v1/org/strategy?orgId=acme`));
+});
+
+test("bootstrapContext: each part is independently fail-open (object → null, array → [])", async () => {
+  const failing = new Set(["chart", "relationships", "strategy", "hierarchy", "policy"]);
+  const f = routerFetch(failing);
+  const ctx = await bootstrapContext({ base: BASE, apiKey: "key", orgId: "acme", agentId: "robin", fetchImpl: f });
+  // profile/decisions/board still succeed
+  assert.equal(ctx.profile.slug, "robin");
+  assert.equal(ctx.decisions[0].id, "D1");
+  assert.equal(ctx.board[0].id, "T1");
+  // failed object parts → null
+  assert.equal(ctx.chart, null);
+  assert.equal(ctx.relationships, null);
+  assert.equal(ctx.strategy, null);
+  assert.equal(ctx.hierarchy, null);
+  assert.equal(ctx.policy, null);
+});
+
+test("bootstrapContext: total failure → all-null/empty, never throws", async () => {
+  const all = new Set(["profile", "chart", "relationships", "strategy", "hierarchy", "decisions", "policy", "board"]);
+  const ctx = await bootstrapContext({ base: BASE, apiKey: "key", orgId: "acme", agentId: "robin", fetchImpl: routerFetch(all) });
+  assert.equal(ctx.profile, null);
+  assert.equal(ctx.chart, null);
+  assert.equal(ctx.relationships, null);
+  assert.equal(ctx.strategy, null);
+  assert.equal(ctx.hierarchy, null);
+  assert.deepEqual(ctx.decisions, []);
+  assert.equal(ctx.policy, null);
+  assert.deepEqual(ctx.board, []);
+});
+
+test("bootstrapContext: missing base/creds → all-null/empty (no fetch)", async () => {
+  const ctx = await bootstrapContext({ orgId: "acme", fetchImpl: routerFetch() });
+  assert.equal(ctx.profile, null);
+  assert.equal(ctx.chart, null);
+  assert.deepEqual(ctx.decisions, []);
+  assert.deepEqual(ctx.board, []);
+});
+
+test("bootstrapContext: relationships skipped when no member slug resolvable", async () => {
+  // whoami fails → no profile.slug, no agentId → relationships not even attempted.
+  const f = routerFetch(new Set(["profile"]));
+  const ctx = await bootstrapContext({ base: BASE, apiKey: "key", orgId: "acme", fetchImpl: f });
+  assert.equal(ctx.relationships, null);
+  assert.ok(!f.calls.some((u) => u.includes("/api/v1/org/relationships")));
+});
+
+test("persistOrgContext + loadOrgContext: atomic round-trip with fetchedAt", () => {
+  const root = tmpRoot();
+  const ctx = { profile: { slug: "robin" }, chart: null, decisions: [], board: [] };
+  const path = persistOrgContext(root, ctx);
+  assert.equal(path, join(root, ORG_CONTEXT_REL));
+  assert.ok(existsSync(path));
+  const loaded = loadOrgContext(root);
+  assert.equal(loaded.profile.slug, "robin");
+  assert.ok(typeof loaded.fetchedAt === "string" && loaded.fetchedAt.length > 0);
+  const onDisk = JSON.parse(readFileSync(path, "utf8"));
+  assert.equal(onDisk.profile.slug, "robin");
+});
+
+test("loadOrgContext: absent file → null (fail-open)", () => {
+  const root = tmpRoot();
+  assert.equal(loadOrgContext(root), null);
+});
+
+test("bootstrapAndPersist: returns {ctx, path} and writes the cache", async () => {
+  const root = tmpRoot();
+  const { ctx, path } = await bootstrapAndPersist(root, { base: BASE, apiKey: "key", orgId: "acme", agentId: "robin", fetchImpl: routerFetch() });
+  assert.equal(ctx.profile.slug, "robin");
+  assert.ok(existsSync(path));
+  assert.equal(loadOrgContext(root).profile.slug, "robin");
+});