@synap-core/workspace-templates 0.11.0 → 0.23.0

package/src/domain-template-type.test.ts

@@ -0,0 +1,75 @@
+/**
+ * A template that DECLARES entity kinds must be installable as a workspace
+ * that can HOLD them.
+ *
+ * The pod refuses to file entities into a workspace whose type is
+ * `operational` or `agent` (`isDomainHomeWorkspace`, synap-backend
+ * `packages/database/src/services/workspace-resolution-service.ts`; enforced at
+ * `routers/entities/create.ts` with DOMAIN_INTO_NON_DOMAIN_HOME_MESSAGE) and
+ * leaves it out of auto-placement and of the orient domain map. That rule is
+ * deliberate — for real admin/system surfaces. Finance, People (hr), Legal and
+ * Internal Runbook are DOMAINS that ship profiles (account, invoice, contract,
+ * …) yet were typed `operational`, so live 2026-09-25 no entity could be filed
+ * into Finance at all.
+ *
+ * Reads the YAML SOURCES (not the generated `templates.ts`), and derives the
+ * set by globbing every `src/*.yaml` — a new template joins by existing.
+ */
+import { readdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { describe, expect, it } from "vitest";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const NON_DOMAIN_TYPES = new Set(["operational", "agent"]);
+
+// Declares kinds AND is a non-domain type — an OPEN founder decision, not a
+// silent pass. A ratchet: delete a line once the template is retyped (or its
+// profiles move out); the test fails on a stale entry.
+// Empty since R7 (2026-09-27): both former entries — dev-dashboard and
+// agent-fleet — were retired as templates (option A); their useful views were
+// folded into builder-workspace.
+const KNOWN_CONTRADICTIONS = new Set<string>([]);
+
+type Tpl = {
+  meta?: { slug?: string };
+  workspace?: { workspaceType?: string };
+  profiles?: unknown[];
+};
+
+const templates = readdirSync(HERE)
+  .filter((f) => f.endsWith(".yaml"))
+  .map((f) => load(readFileSync(join(HERE, f), "utf8")) as Tpl)
+  .filter((t) => t && typeof t === "object" && t.meta?.slug);
+
+describe("a template that declares kinds can hold them", () => {
+  it("scans a plausible corpus (non-vacuity)", () => {
+    expect(templates.length).toBeGreaterThan(20);
+    const slugs = templates.map((t) => t.meta!.slug);
+    expect(slugs).toEqual(expect.arrayContaining(["finance", "crm"]));
+  });
+
+  it("no kind-declaring template is typed operational/agent (except the ratchet)", () => {
+    const offenders = templates
+      .filter(
+        (t) =>
+          (t.profiles?.length ?? 0) > 0 &&
+          NON_DOMAIN_TYPES.has(t.workspace?.workspaceType ?? "")
+      )
+      .map((t) => t.meta!.slug!)
+      .sort();
+    expect(offenders.filter((s) => !KNOWN_CONTRADICTIONS.has(s))).toEqual([]);
+    expect(
+      [...KNOWN_CONTRADICTIONS].filter((s) => !offenders.includes(s)),
+      "resolved — remove from KNOWN_CONTRADICTIONS"
+    ).toEqual([]);
+  });
+
+  it("the four domains named in the 2026-09-25 bug are domain homes", () => {
+    const bySlug = new Map(templates.map((t) => [t.meta!.slug, t]));
+    for (const slug of ["finance", "hr", "legal", "internal-runbook"]) {
+      expect(bySlug.get(slug)?.workspace?.workspaceType, slug).toBe("personal");
+    }
+  });
+});

package/src/ecosystem.yaml

@@ -9,12 +9,15 @@
 meta:
   slug: ecosystem
   domain: strategy
-  name: Ecosystem
+  name: Market
   description: Map the market you operate in — the partners, competitors, and players, the segments and trends, and the relationships between them.
   icon: radar
   color: "#0EA5E9"
   tags: [ecosystem, market, partners, competitors, graph]
   isPublic: true
+  # A LIBRARY: it produces nothing a home counts (homes).
+  intent:
+    label: Ecosystem
 
 # SSOT ordering guarantee — this template REFERENCES foundation's pod-wide
 # shared `partner` role. The apply engine seeds a shared profile's pod-wide BASE
@@ -30,7 +33,7 @@ dependencies:
     reason: "Provides the pod-wide partner role vocabulary this workspace reuses."
 
 workspace:
-  name: Ecosystem
+  name: Market
   description: Map the market you operate in — the partners, competitors, and players, the segments and trends, and the relationships between them.
   subtype: ecosystem
   visibility: pod_visible
@@ -253,74 +256,16 @@ profiles:
         constraints: { defaultValue: watching }
 
   # Partner (shared ecosystem role — SSOT is foundation.yaml) ─────────────────
-  # `scope: shared` dedups to the ONE pod-wide `partner` profile seeded by
-  # foundation; provisioning grants THIS workspace access to it (SHARED profiles
-  # are grant-gated, so the reference is required). Shapes match foundation
-  # verbatim, so no property drift.
+  # A REFERENCE (W4a): slug + displayName + scope + profileKind only. It
+  # resolves to the ONE pod-wide `partner` row foundation seeds and grants THIS
+  # workspace access (shared profiles are grant-gated, so the reference is
+  # required); the body is never restated. validate.ts rule
+  # `shared-role-reference-*` requires foundation in the dependency chain.
   - slug: partner
     displayName: Partner
-    icon: handshake
-    color: teal
-    description: A partner relationship — both a referral source and a co-delivery collaborator, distinguished by partner type.
     scope: shared
     profileKind: role
-    applicableKinds:
-      - company
-      - person
-    properties:
-      - slug: partnerStatus
-        label: Status
-        valueType: string
-        inputType: select
-        enumValues:
-          - prospect
-          - active
-          - paused
-          - churned
-      - slug: partnerType
-        label: Partner Type
-        valueType: string
-        inputType: select
-        enumValues:
-          - referral
-          - co-delivery
-          - both
-      - slug: accountManager
-        label: Account Manager
-        valueType: string
-        inputType: text
-      - slug: engagementStartDate
-        label: Engagement Start
-        valueType: date
-        inputType: date
-      - slug: satisfactionScore
-        label: Satisfaction
-        valueType: number
-        inputType: number
-      - slug: lifetimeValue
-        label: Lifetime Value
-        valueType: number
-        inputType: number
-      - slug: notes
-        label: Notes
-        valueType: string
-        inputType: textarea
-      - slug: contractValue
-        label: Contract Value
-        valueType: number
-        inputType: number
-      - slug: renewalDate
-        label: Renewal Date
-        valueType: date
-        inputType: date
-      - slug: healthScore
-        label: Health
-        valueType: string
-        inputType: select
-        enumValues:
-          - healthy
-          - at_risk
-          - critical
+    properties: []
 
 views:
   - name: Ecosystem Map
@@ -470,6 +415,20 @@ integrations:
   - templateKey: exa
   - templateKey: apify
 
+# ── taskIntents — WHAT THIS WORKSPACE NEEDS TO FUNCTION ───────────────────
+# Closed vocabulary: `@synap-core/types/capability-intents` (pod migrations
+# 0283/0284). DERIVED from the declared intents of this template's own
+# `integrations` capability packs — not hand-guessed. Checked at authoring
+# time by `validateTemplate` (`task-intent-unknown`) and by
+# `src/task-intents.test.ts`.
+taskIntents:
+  - search_external
+  - fetch_record
+  - list_records
+  - run_external_job
+  - capture_into_pod
+  - enrich_entity
+
 onboarding:
   goal: >
     Map the real ecosystem — the key players (companies and people), who partners
@@ -519,10 +478,12 @@ onboarding:
       the threats, and the open lane, not just a pile of logos.
   collect:
     - profileSlug: company
+      min: 1
       what: The real companies in your ecosystem — the players you operate around.
       cardinality: several
       keyFields: [industry, website]
     - profileSlug: market-segment
+      min: 1
       what: The market slices you play in, with rough size and ocean.
       cardinality: few
       keyFields: [ocean, tam]

package/src/enterprise-os.yaml

@@ -2,11 +2,12 @@
 # ==================================================
 # A SUITE template: it stands up a whole company's public operating core in one
 # install by REQUIRING its constituent workspaces (deps-first), then adds a thin
-# "command tower" home of its own — a place to track the company's objectives
-# across the lenses it just installed.
+# home of its own that owns no data (`profiles: []`). What the company is driving
+# toward is a goal on the pod (a track), not a kind in this space.
 #
 # What it composes (all public, all bundled):
 #   • foundation — strategic DNA (mission, audience, positioning, principles)
+#   • business-model — the GRP method (a track template) layered onto foundation
 #   • ecosystem  — the market graph (partners, competitors, segments, trends)
 #   • operations — how the company runs (the operational lens)
 #   • crm        — the pipeline (contacts, leads, clients, deals)
@@ -22,7 +23,7 @@ meta:
   slug: enterprise-os
   domain: company
   name: Enterprise OS
-  description: Stand up a company's public operating core in one install — strategy, market, operations, and pipeline — plus a command tower to track objectives across them.
+  description: Stand up a company's public operating core in one install — strategy, market, operations, and pipeline. What you are driving toward lives on your pod as goals.
   icon: layout-dashboard
   color: "#4F46E5"
   tags: [suite, enterprise, os, foundation, crm, operations, ecosystem]
@@ -36,6 +37,10 @@ dependencies:
     kind: workspace
     relation: require
     reason: "Strategic DNA + the pod-wide role vocabulary (partner/client/lead) every other lens reuses. Must resolve first."
+  - slug: business-model
+    kind: workspace
+    relation: require
+    reason: "The canonical GRP — the business-model track template (six steps across strategy, finance and research) plus the convention/projection kinds. An overlay: it composes onto the Foundation installed above, it never creates a workspace."
   - slug: ecosystem
     kind: workspace
     relation: require
@@ -48,10 +53,6 @@ dependencies:
     kind: workspace
     relation: require
     reason: "The pipeline — contacts, leads, clients, and deals."
-  - slug: business-developer
-    kind: workspace
-    relation: require
-    reason: "The lead-first sales motion (the business-development overlay on the pod-wide lead/client roles, commercial proposals, commission handoff) that the CRM app runs on. Composes onto the CRM workspace above — without it the CRM lens has the bare lead/client roles with no lifecycle or handoff fields and the app's pipeline is empty."
   - slug: content-os
     kind: workspace
     relation: require
@@ -59,135 +60,10 @@ dependencies:
 
 workspace:
   name: Enterprise OS
-  description: The command tower for the company operating system — track strategic objectives across the strategy, market, operations, and pipeline lenses this suite installs.
+  description: The home of the company operating system — the strategy, market, operations, and pipeline lenses this suite installs.
   subtype: enterprise-os
   visibility: pod_visible
   sourceRoles:
     strategy: consumer
 
-profiles:
-  # The one native profile the command tower owns: a strategic objective the
-  # company is driving across the lenses this suite installs. Deliberately light
-  # — the depth lives in the constituent workspaces; this is the cross-cutting
-  # scoreboard that ties them together.
-  - slug: objective
-    displayName: Objective
-    icon: target
-    color: "#4F46E5"
-    description: A company objective the operating system is driving toward — the cross-cutting outcome the lenses serve.
-    properties:
-      - slug: outcome
-        label: Outcome
-        valueType: string
-        inputType: textarea
-      - slug: status
-        label: Status
-        valueType: string
-        inputType: select
-        enumValues: [on-track, at-risk, off-track, achieved]
-        constraints: { defaultValue: on-track }
-      - slug: horizon
-        label: Horizon
-        valueType: string
-        inputType: select
-        enumValues: [now, next, later]
-        constraints: { defaultValue: now }
-      - slug: owner
-        label: Owner
-        valueType: string
-        inputType: text
-      - slug: targetDate
-        label: Target Date
-        valueType: date
-        inputType: date
-
-views:
-  - name: Objectives
-    slug: objectives
-    type: table
-    scopeProfileSlug: objective
-    description: The company's strategic objectives across every lens, by horizon and status.
-    defaultView: true
-    config:
-      columns: [title, status, horizon, owner, targetDate]
-  - name: Objective Board
-    slug: objective-board
-    type: kanban
-    scopeProfileSlug: objective
-    description: Objectives grouped by status — a running scoreboard for the operating system.
-    config:
-      groupBy: status
-
-onboarding:
-  goal: >
-    Stand up the company's operating core and name the handful of strategic
-    objectives it is driving — so strategy, market, operations, and pipeline are
-    all in place and pointed at the same outcomes from day one.
-  framing: |
-    THE CHIEF OF STAFF: Act as a sharp chief of staff standing up the company OS.
-    The four lenses (foundation, ecosystem, operations, CRM) are already
-    installed — your job is to name the 3-5 objectives that cut across them, so
-    the operating system has a scoreboard, not just structure.
-  expertise:
-    starters:
-      - >
-        Name few, real objectives. An operating system with 20 objectives has
-        none; force the 3-5 that actually decide the year, each with an owner and
-        a horizon (now / next / later).
-      - >
-        Tie each objective to a lens. A good objective names where it lives —
-        pipeline growth (CRM), a market move (ecosystem), an operational fix
-        (operations), or a positioning shift (foundation) — so the scoreboard
-        maps to the structure underneath it.
-    blindSpots:
-      - >
-        Objectives with no owner and no date are wishes. Every one needs a single
-        owner and a target date, or it will not move.
-      - >
-        "Grow the business" is not an objective — it is a category. Push for the
-        specific outcome that would make this quarter a win.
-    bar: >
-      A short, honest scoreboard: 3-5 objectives, each owned, dated, placed on a
-      horizon, and tied to the lens that serves it — sitting on top of a fully
-      installed operating core.
-  collect:
-    - profileSlug: objective
-      what: The 3-5 strategic objectives the company is driving this horizon.
-      cardinality: few
-      keyFields: [status, horizon, owner]
-  openingQuestions:
-    - "What are the 3-5 objectives that will decide this year for the company?"
-    - "Who owns each one, and is it a now, next, or later horizon?"
-  doneWhen: A few objectives captured, each with an owner and a horizon.
-
-app:
-  kind: stored
-  cellKey: entity-detail
-
-layout:
-  defaultView: Objectives
-  defaultApp: null
-  pinnedApps: [dashboard, data]
-  sidebarItems:
-    - kind: view
-      viewName: Objectives
-      label: Objectives
-      icon: target
-    - kind: view
-      viewName: Objective Board
-      label: Board
-      icon: kanban-square
-    - kind: app
-      appId: data
-      label: Data
-      icon: database
-
-bento:
-  viewName: Objectives
-  blocks:
-    - kind: view
-      viewName: Objectives
-      pos: { x: 0, y: 0, w: 8, h: 4 }
-    - kind: view
-      viewName: Objective Board
-      pos: { x: 8, y: 0, w: 4, h: 4 }
+profiles: []

package/src/facecam-edit.audio-studio.test.ts

@@ -0,0 +1,188 @@
+/**
+ * facecam-edit, round 2 (31 Oct, wave session 742c7d5a):
+ *
+ *   - Audio. Run 22dcabe8's delivery was re-encoded to fit the upload: the
+ *     voice's third AAC encode (125 kb/s), with coding noise ~5 dB under the
+ *     voice at 12-16 kHz, which the founder heard. The voice is encoded once
+ *     after the take; every render gets the cut's audio stream back by a
+ *     remux, checked by hash; a size re-encode touches the video only.
+ *     Loudness moves only on the person's answer (pod knowledge f47a2a76).
+ *   - Studio names a place (contract with Content Studio, lane cs-studio-bg):
+ *     the desktop app is opened on the edit folder (`open -a HyperFrames
+ *     <dir>`, the open-file event a running app also receives), recorded as
+ *     `studio-app`; a missing app is the `needs-tool-hyperframes-app` slot;
+ *     `studio` is retired whenever the preview process stops.
+ *
+ * Read from the skill JSON and the YAML source, so an edit is seen without a
+ * rebuild.
+ */
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { load } from "js-yaml";
+import { describe, expect, it } from "vitest";
+import type { TemplatePlaybook, WorkspaceYaml } from "./types.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const skill = JSON.parse(
+  readFileSync(
+    join(here, "../skills/facecam-edit/facecam-edit.skill.json"),
+    "utf8"
+  )
+) as {
+  spec: { body: string };
+};
+const body = skill.spec.body;
+const section = (from: string, to: string) => {
+  const start = body.indexOf(from);
+  const end = body.indexOf(to, start + 1);
+  expect(start).toBeGreaterThanOrEqual(0);
+  expect(end).toBeGreaterThan(start);
+  return body.slice(start, end);
+};
+const source = load(
+  readFileSync(join(here, "content-os.yaml"), "utf8")
+) as WorkspaceYaml;
+const produce = (source.playbooks ?? []).find(
+  (p) => p.name === "Produce Content"
+) as TemplatePlaybook | undefined;
+const draftGoal = (
+  produce?.stages?.find((s) => s.key === "draft")?.goal ?? ""
+).replace(/\s+/g, " ");
+
+describe("facecam-edit encodes the voice once after the take", () => {
+  it("states the rule among the hard rules", () => {
+    const rules = section("## Hard rules", "## 1.");
+    expect(rules).toContain(
+      "**The voice is encoded once after the take, never again.**"
+    );
+    expect(rules).toContain("`media/cut-audio.m4a`");
+  });
+
+  it("builds the cut's audio from the take once, at 256 kb/s, with the clips' ramps", () => {
+    const cut = section("## 4. Apply the cut", "## 5.");
+    expect(cut).toContain("ffmpeg -i media/take-cfr.mp4 -filter_complex");
+    expect(cut).toContain("afade=t=in:d=0.03");
+    expect(cut).toContain("-c:a aac -b:a 256k -ar 48000 media/cut-audio.m4a");
+    expect(cut).toContain(
+      "Never build it from a file that is already a re-encode of the take."
+    );
+  });
+
+  it("encodes audio in exactly one command of the whole skill: the cut's audio", () => {
+    // Any other audio encoder in a command (a render step, a size re-encode) is the 31 Oct defect.
+    const encodes = body.match(/-c:a (?!copy)[a-z_]+/g) ?? [];
+    expect(encodes).toEqual(["-c:a aac"]);
+    expect(body.indexOf("-c:a aac")).toBe(
+      body.indexOf("-c:a aac -b:a 256k -ar 48000 media/cut-audio.m4a")
+    );
+  });
+
+  it("remuxes every render with the cut's audio and checks the hash before upload", () => {
+    const save = section("## 8. Review, render, save", "## Revisions");
+    const remux = save.indexOf(
+      "-i media/cut-audio.m4a -map 0:v:0 -map 1:a:0 -c copy -movflags +faststart <name>-final.mp4"
+    );
+    const hash = save.indexOf("-map 0:a:0 -f md5 -");
+    const sizeOnly = save.indexOf(
+      "-c:v libx264 -crf <a higher CRF> -preset slow -c:a copy"
+    );
+    const upload = save.indexOf("Upload the final MP4");
+    expect(remux).toBeGreaterThan(0);
+    expect(hash).toBeGreaterThan(remux);
+    expect(sizeOnly).toBeGreaterThan(hash);
+    expect(upload).toBeGreaterThan(sizeOnly);
+    expect(save).toContain("a pass's preview included");
+    expect(save).toContain("Different hashes: do not upload");
+  });
+
+  it("moves loudness only on the person's answer, and QA checks the level they chose", () => {
+    const cut = section("## 4. Apply the cut", "## 5.");
+    expect(cut).toContain("ask on the slot `ask-loudness`");
+    expect(cut).toContain(
+      "Never normalise without that answer, and never on a render."
+    );
+    const qa = section("## 7. QA", "## 8.");
+    expect(qa).not.toContain("target about -14 LUFS");
+    expect(qa).toContain("the level the person chose in §4");
+  });
+
+  it("says the same in Produce Content's Draft goal", () => {
+    expect(draftGoal).toContain(
+      "Every render the person hears, a preview included, carries the cut's audio copied (a remux, never the render's own encode), and a re-encode for size touches the video only"
+    );
+  });
+});
+
+describe("facecam-edit opens Studio where Content Studio asks", () => {
+  const setup = section("## 1. Recall and set up", "## 2.");
+
+  it("notes in step 0 whether the desktop app is installed, with no slot unless asked", () => {
+    expect(setup).toContain(
+      "test -d /Applications/HyperFrames.app || test -d ~/Applications/HyperFrames.app"
+    );
+    expect(setup).toContain("A missing app is not a slot by itself");
+  });
+
+  it("retires `studio` whenever the preview process stops", () => {
+    expect(setup).toContain(
+      'Whenever your preview process stops (the run leaves Draft or ends, the worker stops, or you stop it): `npx hyperframes preview --stop` and `retireOutput: "studio"`'
+    );
+  });
+
+  it("opens the edit folder in the app as a document, never through --args, and records studio-app", () => {
+    const app = section("- **app**", "- **browser**:");
+    expect(app).toContain(
+      '`open -a HyperFrames "$HOME/synap-work/<run session id>/edit"`'
+    );
+    expect(app).toContain("ignored by a running app");
+    expect(app).toContain(
+      '{ key: "studio-app", kind: "app", label: "HyperFrames app on <this computer\'s name>", required: false }'
+    );
+    expect(app).toContain('`completeOutput: "studio-app"`');
+  });
+
+  it("hands a missing app to the person on needs-tool-hyperframes-app, install first, browser second", () => {
+    const app = section("- **app**", "- **browser**:");
+    for (const part of [
+      'key: "needs-tool-hyperframes-app"',
+      'owner: "human"',
+      'blockedReason: "capability"',
+      "why: \"The HyperFrames desktop app isn't installed on <this computer's name>\"",
+      "https://hyperframes.dev/studio/download",
+    ]) {
+      expect(app).toContain(part);
+    }
+    const installed = app.indexOf('label: "I installed it", recommended: true');
+    const browser = app.indexOf('label: "Use the browser Studio"');
+    expect(installed).toBeGreaterThan(0);
+    expect(browser).toBeGreaterThan(installed);
+    expect(app).toContain(
+      '`retireOutput: "needs-tool-hyperframes-app"` and do **browser**'
+    );
+  });
+
+  it("starts the browser Studio as step 5 does, reusing a live address", () => {
+    const browser = section("- **browser**:", "## 2.");
+    expect(browser).toContain("record `studio` as in step 5");
+    expect(browser).toContain("never a second server");
+  });
+});
+
+describe("facecam-edit's local matte goes over the chosen background", () => {
+  const fallback = section("**Fallback, in order.**", "**Colour pass.**");
+
+  it("extracts the matte from remove-background's WebM with the libvpx decoder, gates it, and composites as the tool's matte", () => {
+    expect(fallback).toContain(
+      "npx hyperframes remove-background media/take-cfr.mp4 -o media/person-rb.webm --json"
+    );
+    expect(fallback).toContain(
+      "ffmpeg -c:v libvpx-vp9 -i media/person-rb.webm -vf alphaextract"
+    );
+    expect(fallback).toContain("Run the gate (step 3) on it");
+    expect(fallback).toContain("Then steps 4 to 6 as for the tool's matte");
+    expect(fallback).toContain(
+      "over the background the look chose: the photo, or the blurred room for `mode: blur`"
+    );
+  });
+});