feat: add workspace bridge core

.doghouse/workspace.json

@@ -0,0 +1,16 @@
+{
+  "version": 1,
+  "workspace": {
+    "id": "dotdog",
+    "name": "dotdog"
+  },
+  "repos": [
+    {
+      "alias": "dotdog",
+      "role": "cli",
+      "path": ".."
+    }
+  ],
+  "groups": [],
+  "edges": []
+}

package.json

@@ -1,16 +1,16 @@
 {
-  "name": "spec-platform",
+  "name": "dotdog-workspace",
   "version": "0.1.0",
   "private": true,
-  "description": "Spec genome platform — validate, simulate, generate code. MCP server for AI agents. $0 stack.",
+  "description": "Private workspace for the dotdog CLI package.",
   "workspaces": [
     "packages/*"
   ],
   "scripts": {
-    "dev": "bun --cwd packages/spec-api dev",
     "build": "bun run --filter '*' build",
     "lint": "bun run --filter '*' lint",
     "test": "bun test",
+    "pack:check": "node scripts/check-pack.mjs",
     "validate": "bun packages/spec-cli/src/index.ts validate"
   },
   "dependencies": {

packages/dotdog/__tests__/cli.test.ts

@@ -170,4 +170,71 @@ describe('CLI', () => {
       rmSync(dir, { recursive: true, force: true });
     }
   });
+
+  test('serve reads compiled .doghouse graph artifacts', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'dotdog-test-serve-compiled-'));
+    try {
+      mkdirSync(join(dir, '.doghouse', 'semantic'), { recursive: true });
+      writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'compiled-graph-app', version: '1.0.0' }, null, 2));
+      writeFileSync(join(dir, 'railway.json'), JSON.stringify({ startCommand: 'bun start' }, null, 2));
+      writeFileSync(join(dir, '.doghouse', 'semantic', 'deployment.dog'), [
+        '## Deployment',
+        '',
+        '### Entity: Deployment',
+        '',
+        'A generic deployment capability.',
+        '',
+        '```yaml',
+        'entity: Deployment',
+        'type: external',
+        '```',
+        '',
+        '### Entity: RailwayService',
+        '',
+        'A generic Railway deployment service.',
+        '',
+        '```yaml',
+        'entity: RailwayService',
+        'type: external',
+        '```',
+        '',
+        '### Relationship: Deployment → RailwayService',
+        '',
+        '```yaml',
+        'relationship: Deployment → RailwayService',
+        'source: Deployment',
+        'target: RailwayService',
+        'verb: includes',
+        '```',
+      ].join('\n'));
+
+      await $`cd ${dir} && ${BUN} ${ROOT}/packages/dotdog/src/cli.ts map . --project compiled-graph-app`.quiet();
+      await $`cd ${dir} && ${BUN} ${ROOT}/packages/dotdog/src/cli.ts compile`.quiet();
+      expect(existsSync(join(dir, '.doghouse', 'compiled', 'repo.dag'))).toBe(true);
+
+      const proc = Bun.spawn([BUN, join(ROOT, 'packages/dotdog/src/cli.ts'), 'serve'], {
+        stdin: 'pipe', stdout: 'pipe', stderr: 'pipe',
+        cwd: dir,
+      });
+      proc.stdin.write(JSON.stringify({jsonrpc:'2.0',id:1,method:'initialize',params:{}})+'\n');
+      await new Promise(r => setTimeout(r, 1000));
+      proc.stdin.write(JSON.stringify({jsonrpc:'2.0',id:2,method:'tools/call',params:{name:'getEntity',arguments:{name:'Deployment'}}})+'\n');
+      proc.stdin.write(JSON.stringify({jsonrpc:'2.0',id:3,method:'tools/call',params:{name:'traverse',arguments:{from:'Deployment',depth:1}}})+'\n');
+      proc.stdin.end();
+      const out = await new Response(proc.stdout).text();
+      proc.kill();
+
+      const lines = out.split('\n').filter(l => l.trim());
+      expect(lines.length).toBeGreaterThanOrEqual(3);
+      const entity = JSON.parse(JSON.parse(lines[1]).result.content[0].text);
+      expect(entity.name).toBe('Deployment');
+      expect(entity.type).toBe('external');
+      expect(entity.edges.some((edge: any) => edge[0] === 'RailwayService' && edge[1] === 'includes')).toBe(true);
+      const graph = JSON.parse(JSON.parse(lines[2]).result.content[0].text);
+      expect(graph.nodes.some((node: any) => node.name === 'Deployment')).toBe(true);
+      expect(graph.nodes.some((node: any) => node.edges.some((edge: string) => edge.startsWith('RailwayService:includes')))).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });

packages/dotdog/__tests__/commands.test.ts

@@ -130,8 +130,8 @@ describe('untested commands', () => {
       setupTempProject(dir, 'testproj');
       const out = await $`cd ${dir} && ${BUN} ${ROOT}/packages/dotdog/src/cli.ts map . --project repo-world-test`.text();
       expect(out).toContain('repo.dag');
-      expect(existsSync(join(dir, '.dotdog', 'generated', 'repo-map.dog'))).toBe(true);
-      expect(existsSync(join(dir, '.dotdog', 'generated', 'repo.dag'))).toBe(true);
+      expect(existsSync(join(dir, '.doghouse', 'generated', 'repo-map.dog'))).toBe(true);
+      expect(existsSync(join(dir, '.doghouse', 'generated', 'repo.dag'))).toBe(true);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -142,7 +142,7 @@ describe('untested commands', () => {
     try {
       setupTempProject(dir, 'testproj');
       await $`cd ${dir} && ${BUN} ${ROOT}/packages/dotdog/src/cli.ts map . --project repo-world-test`.quiet();
-      const dag = join(dir, '.dotdog', 'generated', 'repo.dag');
+      const dag = join(dir, '.doghouse', 'generated', 'repo.dag');
       const out = await $`cd ${dir} && ${BUN} ${ROOT}/packages/dotdog/src/cli.ts query repository --dag ${dag}`.text();
       expect(out.toLowerCase()).toContain('repository');
     } finally {

packages/dotdog/__tests__/regression.test.ts

@@ -71,10 +71,10 @@ describe('regression', () => {
   test('semantic deployment nodes survive map and compile remap', async () => {
     const dir = mkdtempSync(join(tmpdir(), 'dotdog-test-layers-'));
     try {
-      mkdirSync(join(dir, '.dotdog', 'semantic'), { recursive: true });
+      mkdirSync(join(dir, '.doghouse', 'semantic'), { recursive: true });
       writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'example-web-app', version: '1.0.0' }, null, 2));
       writeFileSync(join(dir, 'railway.json'), JSON.stringify({ startCommand: 'npm start' }, null, 2));
-      writeFileSync(join(dir, '.dotdog', 'semantic', 'deployment.dog'), [
+      writeFileSync(join(dir, '.doghouse', 'semantic', 'deployment.dog'), [
         '## Deployment',
         '',
         '### Entity: Deployment',
@@ -119,7 +119,7 @@ describe('regression', () => {
       await $`cd ${dir} && ${BUN} ${ROOT}/packages/dotdog/src/cli.ts map`.quiet();
       await $`cd ${dir} && ${BUN} ${ROOT}/packages/dotdog/src/cli.ts compile`.quiet();
 
-      const compiled = JSON.parse(readFileSync(join(dir, '.dotdog', 'compiled', 'repo.dag'), 'utf-8'));
+      const compiled = JSON.parse(readFileSync(join(dir, '.doghouse', 'compiled', 'repo.dag'), 'utf-8'));
       const labels = compiled.nodes.map((node: any) => node.label);
       expect(labels).toContain('Deployment');
       expect(labels).toContain('RailwayService');

packages/dotdog/__tests__/workspace.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { buildWorkspaceGraph } from '../src/workspace/graph';
+import { resolveWorkspace } from '../src/workspace/resolver';
+import { validateWorkspaceConfig } from '../src/workspace/validator';
+import { isIgnoredRepoPath, resolveUserPath } from '../src/workspace/paths';
+
+function fixtureWorkspace() {
+  const root = mkdtempSync(path.join(tmpdir(), 'dotdog-workspace-'));
+  const doghouse = path.join(root, '.doghouse');
+  const repos = path.join(root, 'repos');
+  mkdirSync(path.join(repos, 'example-web'), { recursive: true });
+  mkdirSync(path.join(repos, 'example-api'), { recursive: true });
+  mkdirSync(path.join(repos, 'example-worker'), { recursive: true });
+  mkdirSync(doghouse, { recursive: true });
+  writeFileSync(path.join(doghouse, 'workspace.json'), JSON.stringify({
+    version: 1,
+    workspace: { id: 'example-product', name: 'example-product' },
+    repos: [
+      { alias: 'example-web', role: 'web', path: '../repos/example-web' },
+      { alias: 'example-api', role: 'api', path: '../repos/example-api' },
+      { alias: 'example-worker', role: 'worker', path: '../repos/example-worker' },
+    ],
+    groups: [{ name: 'checkout', repos: ['example-web', 'example-api', 'example-worker'] }],
+    edges: [
+      { from: 'example-web', to: 'example-api', type: 'http' },
+      { from: 'example-api', to: 'example-worker', type: 'event' },
+    ],
+  }, null, 2));
+  return root;
+}
+
+describe('workspace bridge', () => {
+  test('validates duplicate aliases and unknown edges', () => {
+    const result = validateWorkspaceConfig({
+      version: 1,
+      workspace: { id: 'example-product' },
+      repos: [
+        { alias: 'example-api', path: '.' },
+        { alias: 'example-api', path: '.' },
+      ],
+      edges: [{ from: 'example-api', to: 'example-worker', type: 'http' }],
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.map((error) => error.code)).toContain('duplicate_repo_alias');
+    expect(result.errors.map((error) => error.code)).toContain('unknown_edge_to');
+  });
+
+  test('loads a workspace manifest and builds deterministic graph facts', () => {
+    const root = fixtureWorkspace();
+    const context = resolveWorkspace(root);
+    expect(context.mode).toBe('workspace');
+    expect(context.repos.map((repo) => repo.alias)).toEqual(['example-web', 'example-api', 'example-worker']);
+    const graph = buildWorkspaceGraph(context);
+    expect(graph.workspace).toBe('example-product');
+    expect(graph.nodes.map((node) => node.id)).toContain('repo:example-api');
+    expect(graph.edges.map((edge) => edge.type)).toContain('http');
+  });
+
+  test('blocks parent path traversal and ignores secret paths', () => {
+    const root = fixtureWorkspace();
+    expect(() => resolveUserPath('..', root)).toThrow();
+    expect(isIgnoredRepoPath('.env')).toBe(true);
+    expect(isIgnoredRepoPath('src/index.ts')).toBe(false);
+  });
+});

packages/dotdog/package.json

@@ -20,7 +20,6 @@
     "ai",
     "bun",
     "cli",
-    "code-generation",
     "dag",
     "graph",
     "knowledge-graph",
@@ -29,7 +28,6 @@
     "mcp",
     "mcp-server",
     "spec-driven-development",
-    "spec-genome",
     "specification",
     "structured",
     "typescript",