create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/workflow-node-types/markdown-node.mjs

@@ -0,0 +1,225 @@
+import {
+  ComponentNodeError,
+  acquireLock as acquireComponentLock,
+  assertRevision,
+  getComponentNode,
+  isLocked,
+  listComponentNodes,
+  releaseLock as releaseComponentLock,
+  updateComponentNode,
+} from '../component-node-store.mjs'
+
+function rethrow(error) {
+  if (error instanceof ComponentNodeError) throw error
+  throw new ComponentNodeError(error.message, {
+    statusCode: error.statusCode,
+    code: error.code,
+  })
+}
+
+function requireMarkdownNode(current) {
+  if (current.state.type !== 'markdown') {
+    throw new ComponentNodeError(`Node is not a markdown node: ${current.node.nodeId}`, {
+      statusCode: 409,
+      code: 'TYPE_MISMATCH',
+    })
+  }
+  return current.state.markdown
+}
+
+function persistMarkdown(projectRoot, current, markdown) {
+  const updated = updateComponentNode(projectRoot, current.node.nodeId, {
+    revision: current.node.revision,
+    markdown,
+  })
+  return { markdown: updated.state.markdown, revision: updated.node.revision }
+}
+
+// Guard for guarded writes (patch/append/replace): a live lock held by another
+// holder is mandatory exclusion while held (F18/D15) — the write is refused
+// with a markdown_locked error EVEN IF no expectedRevision is supplied. When
+// no lock exists, lockless writes stay compatible and the revision guard
+// (markdown_conflict) applies unchanged. The error carries holder/expiresAt
+// (+ currentRevision/expectedRevision when supplied) so the agent can reread
+// and retry.
+function assertWriteAllowed(current, payload = {}, projectRoot = null) {
+  const expectedRevision = payload.expectedRevision
+  const lock = isLocked(current.node.nodeId, undefined, { projectRoot })
+  if (lock) {
+    const declaredLockId = payload.lockId !== undefined && payload.lockId !== null ? String(payload.lockId).trim() : ''
+    const declaredOwner = String(payload.lockOwner || '').trim()
+    const holdsLock = (declaredLockId !== '' && declaredLockId === lock.lockId)
+      || (declaredLockId === '' && declaredOwner !== '' && declaredOwner === lock.holder)
+    if (!holdsLock) {
+      const error = new ComponentNodeError(
+        `Markdown node is locked by ${lock.holder}. Reread, merge your changes, and retry.`,
+        { statusCode: 409, code: 'markdown_locked' },
+      )
+      error.currentRevision = current.node.revision
+      error.expectedRevision = expectedRevision === undefined || expectedRevision === null
+        ? current.node.revision
+        : Number(expectedRevision)
+      error.holder = lock.holder
+      error.expiresAt = lock.expiresAt
+      throw error
+    }
+  }
+  const stale = assertRevision(current.node.revision, expectedRevision)
+  if (stale) throw stale
+}
+
+function boundedOffset(value, length) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new ComponentNodeError('Markdown patch offset must be a non-negative number')
+  }
+  return Math.min(Math.floor(parsed), length)
+}
+
+export function read(nodeId, projectRoot) {
+  try {
+    const current = getComponentNode(projectRoot, nodeId)
+    const markdown = requireMarkdownNode(current)
+    return {
+      markdown,
+      revision: current.node.revision,
+      title: current.node.title,
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+export function patch(nodeId, projectRoot, { diff, expectedRevision, lockId, lockOwner } = {}) {
+  try {
+    const current = getComponentNode(projectRoot, nodeId)
+    const markdown = requireMarkdownNode(current)
+    assertWriteAllowed(current, { expectedRevision, lockId, lockOwner }, projectRoot)
+    const op = String(diff?.op || 'append').trim()
+    const text = String(diff?.text ?? '')
+    let next
+    if (op === 'append') {
+      next = markdown + text
+    } else if (op === 'insert') {
+      const offset = boundedOffset(diff?.offset, markdown.length)
+      next = markdown.slice(0, offset) + text + markdown.slice(offset)
+    } else if (op === 'replace') {
+      const offset = boundedOffset(diff?.offset, markdown.length)
+      const length = Number(diff?.length)
+      const count = Number.isFinite(length) && length >= 0
+        ? Math.min(Math.floor(length), markdown.length - offset)
+        : 0
+      next = markdown.slice(0, offset) + text + markdown.slice(offset + count)
+    } else {
+      throw new ComponentNodeError(`Unsupported markdown patch op: ${op}; expected append, insert, or replace`)
+    }
+    return persistMarkdown(projectRoot, current, next)
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+export function replace(nodeId, projectRoot, { markdown, expectedRevision, lockId, lockOwner } = {}) {
+  try {
+    const current = getComponentNode(projectRoot, nodeId)
+    requireMarkdownNode(current)
+    assertWriteAllowed(current, { expectedRevision, lockId, lockOwner }, projectRoot)
+    return persistMarkdown(projectRoot, current, String(markdown ?? ''))
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+export function append(nodeId, projectRoot, { markdown, expectedRevision, lockId, lockOwner } = {}) {
+  try {
+    const current = getComponentNode(projectRoot, nodeId)
+    const currentMarkdown = requireMarkdownNode(current)
+    assertWriteAllowed(current, { expectedRevision, lockId, lockOwner }, projectRoot)
+    return persistMarkdown(projectRoot, current, currentMarkdown + String(markdown ?? ''))
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+// Find markdown nodes by nodeId (exact) or title (case-insensitive substring).
+// Returns metadata only (nodeId, title, revision, stateRef) — never content.
+export function find(nodeId, projectRoot, payload = {}) {
+  try {
+    const targetNodeId = String(payload.nodeId || '').trim()
+    const title = String(payload.title || '').trim()
+    const matches = listComponentNodes(projectRoot)
+      .filter(node => node.type === 'markdown')
+      .filter(node => !targetNodeId || node.nodeId === targetNodeId)
+      .filter(node => !title || node.title.toLowerCase().includes(title.toLowerCase()))
+      .map(node => ({ nodeId: node.nodeId, title: node.title, revision: node.revision, stateRef: node.stateRef }))
+    return { matches, count: matches.length }
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+// Acquire (or renew) a write lease. Payload: { lockOwner, ttlSeconds = 30 (max
+// 300), lockId? (renewal) }. Unexpired foreign locks -> markdown_locked error
+// carrying holder + expiresAt.
+export function acquireLock(nodeId, projectRoot, payload = {}) {
+  try {
+    const current = getComponentNode(projectRoot, nodeId)
+    requireMarkdownNode(current)
+    const owner = String(payload.lockOwner || '').trim()
+    if (!owner) {
+      throw new ComponentNodeError('markdown.acquireLock requires lockOwner', {
+        statusCode: 400,
+        code: 'BAD_REQUEST',
+      })
+    }
+    const ttlSeconds = payload.ttlSeconds === undefined ? 30 : Number(payload.ttlSeconds)
+    if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {
+      throw new ComponentNodeError('markdown.acquireLock ttlSeconds must be a positive number', {
+        statusCode: 400,
+        code: 'BAD_REQUEST',
+      })
+    }
+    const ttlMs = Math.min(Math.floor(ttlSeconds * 1000), 300000)
+    // F18/D15: the lease is persisted into the node's backend-owned state file
+    // (projectRoot), so restarts keep it; TTL expiry is honored on read.
+    const lock = acquireComponentLock(current.node.nodeId, owner, ttlMs, { lockId: payload.lockId, projectRoot })
+    return {
+      lockId: lock.lockId,
+      owner: lock.holder,
+      acquiredAt: lock.acquiredAt,
+      expiresAt: lock.expiresAt,
+      revision: current.node.revision,
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+// Release a lease; only the holder may release (release by a non-holder is a
+// markdown_locked error). Missing/expired leases are a no-op.
+export function releaseLock(nodeId, projectRoot, payload = {}) {
+  try {
+    const current = getComponentNode(projectRoot, nodeId)
+    requireMarkdownNode(current)
+    const owner = String(payload.lockOwner || '').trim()
+    if (!owner) {
+      throw new ComponentNodeError('markdown.releaseLock requires lockOwner', {
+        statusCode: 400,
+        code: 'BAD_REQUEST',
+      })
+    }
+    const result = releaseComponentLock(current.node.nodeId, owner, { lockId: payload.lockId, projectRoot })
+    return {
+      ok: true,
+      released: result.released,
+      nodeId: current.node.nodeId,
+      lockId: result.lockId,
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+export function save(nodeId, projectRoot, { markdown } = {}) {
+  return replace(nodeId, projectRoot, { markdown })
+}

package/src/wf-ui-server/workflow-node-types/mcp-connector-node.mjs

@@ -0,0 +1,71 @@
+import { CapabilityNodeError, getCapabilityNode, updateCapabilityNode } from '../workflow-capability-node-store.mjs'
+
+function rethrow(error) {
+  if (error instanceof CapabilityNodeError) throw error
+  throw new CapabilityNodeError(error.message, {
+    statusCode: error.statusCode,
+    code: error.code,
+  })
+}
+
+function requireMcpConnectorNode(current) {
+  if (current.state.type !== 'mcp-connector') {
+    throw new CapabilityNodeError(`Node is not an mcp-connector node: ${current.node.nodeId}`, {
+      statusCode: 409,
+      code: 'TYPE_MISMATCH',
+    })
+  }
+  return current.state
+}
+
+export function read(nodeId, projectRoot) {
+  try {
+    const current = getCapabilityNode(projectRoot, nodeId)
+    const state = requireMcpConnectorNode(current)
+    return {
+      title: current.node.title,
+      revision: current.node.revision,
+      description: state.description || '',
+      sourceGroup: state.sourceGroup || null,
+      servers: state.servers || [],
+      serverNames: state.serverNames || [],
+      serverCount: Number(state.serverCount || 0),
+      transports: state.transports || [],
+      envKeyNames: state.envKeyNames || [],
+      envKeyCount: Number(state.envKeyCount || 0),
+      redactedFieldCount: Number(state.redactedFieldCount || 0),
+      nodeSemantics: state.nodeSemantics,
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+export function configure(nodeId, projectRoot, payload = {}) {
+  try {
+    const current = getCapabilityNode(projectRoot, nodeId)
+    requireMcpConnectorNode(current)
+    const updated = updateCapabilityNode(projectRoot, nodeId, {
+      revision: current.node.revision,
+      title: payload.title,
+      description: payload.description,
+      sourceGroup: payload.sourceGroup,
+      servers: payload.servers,
+      server: payload.server,
+    })
+    return {
+      revision: updated.node.revision,
+      description: updated.state.description || '',
+      sourceGroup: updated.state.sourceGroup || null,
+      servers: updated.state.servers || [],
+      serverNames: updated.state.serverNames || [],
+      serverCount: Number(updated.state.serverCount || 0),
+      transports: updated.state.transports || [],
+      envKeyNames: updated.state.envKeyNames || [],
+      envKeyCount: Number(updated.state.envKeyCount || 0),
+      redactedFieldCount: Number(updated.state.redactedFieldCount || 0),
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}

package/src/wf-ui-server/workflow-node-types/role-profile-store.mjs

@@ -0,0 +1,191 @@
+// role-profile-store.mjs — backend-owned role profile store for Agent nodes
+// (agent-team-cooperation-spec §3, AC-001). Agents never write these files;
+// the store is written by the backend create-agent path and read for context
+// injection (AC-002).
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ROLES_DIR_NAME = 'agent-roles';
+
+// Canonical subagent role order for auto-assignment (spec §3.1, AC-004/F6).
+const CANONICAL_SUBAGENT_ROLES = ['reviewer', 'implementer', 'verifier', 'planner', 'manager'];
+
+function rolesDir(projectRoot) {
+  return path.join(projectRoot, 'Harness', 'a2a', ROLES_DIR_NAME);
+}
+
+function profileJsonPath(projectRoot, nodeId) {
+  return path.join(rolesDir(projectRoot), `${nodeId}.json`);
+}
+
+/**
+ * The agent-readable profile reference (markdown file path, spec §3.3).
+ * @param {string} nodeId
+ * @returns {string}
+ */
+export function roleProfileRefFor(nodeId) {
+  return `Harness/a2a/agent-roles/${nodeId}.md`;
+}
+
+function renderRoleProfileMarkdown(profile) {
+  return [
+    `# Role Profile — ${profile.displayName}`,
+    '',
+    '<!-- Role profile (agent-team-cooperation-spec §3). Backend-owned; agents never edit this file. -->',
+    '',
+    `- nodeId: ${profile.nodeId}`,
+    `- displayName: ${profile.displayName}`,
+    `- roleTitle: ${profile.roleTitle}`,
+    `- agentKind: ${profile.agentKind}`,
+    `- runtime: ${profile.runtime}`,
+    `- provider: ${profile.provider || ''}`,
+    `- model: ${profile.model || ''}`,
+    `- capabilities: ${profile.capabilities.join(', ')}`,
+    `- roleProfileRef: ${profile.roleProfileRef}`,
+    '',
+    '## Responsibility',
+    '',
+    profile.responsibility,
+    '',
+  ].join('\n');
+}
+
+/**
+ * Create (or overwrite) the role profile for an agent node. Writes both the
+ * markdown role profile (the agent-readable roleProfileRef, spec §3.4) and the
+ * profile JSON (read back by readRoleProfile / listRoleProfiles). The JSON
+ * shape follows spec §3.3 exactly.
+ *
+ * @param {object} profile
+ * @param {string} profile.nodeId - graph node id of the agent
+ * @param {string} profile.roleTitle - canonical id or free-form role (spec §3.1)
+ * @param {string} [profile.displayName] - user-visible name; defaults to roleTitle
+ * @param {string} [profile.responsibility=''] - one-paragraph mandate, plain language
+ * @param {string} [profile.agentKind='subagent'] - lifecycle flag only (main | subagent)
+ * @param {string} profile.runtime - from session-registry ALLOWED_RUNTIMES
+ * @param {string} [profile.provider='']
+ * @param {string} [profile.model='']
+ * @param {string[]} [profile.capabilities=[]]
+ * @param {string} [profile.createdBy='unknown']
+ * @param {string} [profile.parentSessionId=''] - creating parent session id
+ *   (backend-owned; used by nextAvailableRole for AC-004 distinct roles)
+ * @param {string} [projectRoot=process.cwd()]
+ * @returns {{profile: object, roleProfileRef: string}}
+ */
+export function createRoleProfile(profile, projectRoot = process.cwd()) {
+  const nodeId = String(profile?.nodeId || '').trim();
+  if (!nodeId) {
+    throw new Error('createRoleProfile requires a nodeId');
+  }
+  const roleTitle = String(profile?.roleTitle || '').trim() || 'terminal-agent';
+  const capabilities = Array.isArray(profile?.capabilities)
+    ? [...new Set(profile.capabilities.map(item => String(item || '').trim()).filter(Boolean))]
+    : [];
+  const full = {
+    nodeId,
+    displayName: String(profile?.displayName || '').trim() || roleTitle,
+    roleTitle,
+    agentKind: String(profile?.agentKind || '').trim() || 'subagent',
+    responsibility: String(profile?.responsibility || '').trim(),
+    runtime: String(profile?.runtime || '').trim(),
+    provider: String(profile?.provider || '').trim() || null,
+    model: String(profile?.model || '').trim() || null,
+    capabilities,
+    roleProfileRef: roleProfileRefFor(nodeId),
+    createdAt: new Date().toISOString(),
+    createdBy: String(profile?.createdBy || '').trim() || 'unknown',
+    parentSessionId: String(profile?.parentSessionId || '').trim() || null,
+  };
+  fs.mkdirSync(rolesDir(projectRoot), { recursive: true });
+  fs.writeFileSync(profileJsonPath(projectRoot, nodeId), `${JSON.stringify(full, null, 2)}\n`);
+  fs.writeFileSync(path.join(rolesDir(projectRoot), `${nodeId}.md`), renderRoleProfileMarkdown(full));
+  return { profile: full, roleProfileRef: full.roleProfileRef };
+}
+
+/**
+ * Read the role profile JSON for a node.
+ * @param {string} nodeId
+ * @param {string} [projectRoot=process.cwd()]
+ * @returns {object|null}
+ */
+export function readRoleProfile(nodeId, projectRoot = process.cwd()) {
+  try {
+    const raw = fs.readFileSync(profileJsonPath(projectRoot, String(nodeId || '').trim()), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * List every stored role profile.
+ * @param {string} [projectRoot=process.cwd()]
+ * @returns {object[]}
+ */
+export function listRoleProfiles(projectRoot = process.cwd()) {
+  try {
+    const dir = rolesDir(projectRoot);
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir)
+      .filter(file => file.endsWith('.json'))
+      .map(file => {
+        try {
+          return JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Session-record patch for a profile (spec §3.3: profile written at
+ * create-agent time as both a session record field set and the markdown file).
+ * @param {object} profile
+ * @returns {{displayName: string, roleTitle: string, responsibility: string, capabilities: string[], roleProfileRef: string|null}}
+ */
+export function profileSessionFields(profile) {
+  return {
+    displayName: profile?.displayName || '',
+    roleTitle: profile?.roleTitle || '',
+    responsibility: profile?.responsibility || '',
+    capabilities: Array.isArray(profile?.capabilities) ? profile.capabilities : [],
+    roleProfileRef: profile?.roleProfileRef || null,
+  };
+}
+
+/**
+ * Next distinct subagent role for a parent (spec §3.3, AC-004/F6). Canonical
+ * order: reviewer, implementer, verifier, planner, manager. Roles already used
+ * by the parent's existing children (profiles recorded with the same
+ * parentSessionId) are skipped; when every canonical role is taken, the order
+ * cycles with a numeric suffix (reviewer-2, implementer-2, ...) so each new
+ * child still gets a distinct roleTitle.
+ *
+ * @param {string} parentSessionId - creating parent session id
+ * @param {string} [projectRoot=process.cwd()]
+ * @returns {string}
+ */
+export function nextAvailableRole(parentSessionId, projectRoot = process.cwd()) {
+  const parent = String(parentSessionId || '').trim();
+  const used = new Set(
+    listRoleProfiles(projectRoot)
+      .filter(profile => parent && String(profile?.parentSessionId || '').trim() === parent)
+      .map(profile => String(profile?.roleTitle || '').trim())
+      .filter(Boolean),
+  );
+  for (const role of CANONICAL_SUBAGENT_ROLES) {
+    if (!used.has(role)) return role;
+  }
+  let index = 0;
+  let suffix = 2;
+  for (;;) {
+    const candidate = `${CANONICAL_SUBAGENT_ROLES[index % CANONICAL_SUBAGENT_ROLES.length]}-${suffix}`;
+    if (!used.has(candidate)) return candidate;
+    index += 1;
+    if (index % CANONICAL_SUBAGENT_ROLES.length === 0) suffix += 1;
+  }
+}

package/src/wf-ui-server/workflow-node-types/skill-group-node.mjs

@@ -0,0 +1,98 @@
+import { CapabilityNodeError, getCapabilityNode, updateCapabilityNode, setSkillEnabled as setSkillEnabledInStore } from '../workflow-capability-node-store.mjs'
+
+function rethrow(error) {
+  if (error instanceof CapabilityNodeError) throw error
+  throw new CapabilityNodeError(error.message, {
+    statusCode: error.statusCode,
+    code: error.code,
+  })
+}
+
+function requireSkillGroupNode(current) {
+  if (current.state.type !== 'skill-group') {
+    throw new CapabilityNodeError(`Node is not a skill-group node: ${current.node.nodeId}`, {
+      statusCode: 409,
+      code: 'TYPE_MISMATCH',
+    })
+  }
+  return current.state
+}
+
+export function read(nodeId, projectRoot) {
+  try {
+    const current = getCapabilityNode(projectRoot, nodeId)
+    const state = requireSkillGroupNode(current)
+    return {
+      title: current.node.title,
+      revision: current.node.revision,
+      description: state.description || '',
+      prompt: state.prompt || '',
+      sourceGroup: state.sourceGroup || null,
+      skills: state.skills || [],
+      skillNames: state.skillNames || [],
+      skillCount: Number(state.skillCount || 0),
+      nodeSemantics: state.nodeSemantics,
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+export function setSkillEnabled(nodeId, projectRoot, payload = {}) {
+  try {
+    const current = getCapabilityNode(projectRoot, nodeId)
+    requireSkillGroupNode(current)
+    const rawSkillId = payload && Object.hasOwn(payload, 'skillId') ? payload.skillId : payload.skill
+    const enabled = payload ? payload.enabled : undefined
+    const skillId = String(rawSkillId || '').trim()
+    if (!skillId) {
+      throw new CapabilityNodeError('skillId is required for skill-group.setSkillEnabled', {
+        statusCode: 400,
+        code: 'SKILL_ID_REQUIRED',
+      })
+    }
+    if (enabled !== true && enabled !== false) {
+      throw new CapabilityNodeError('enabled must be a boolean for skill-group.setSkillEnabled', {
+        statusCode: 400,
+        code: 'INVALID_ENABLED',
+      })
+    }
+    const result = setSkillEnabledInStore(projectRoot, nodeId, skillId, enabled)
+    return {
+      revision: result.revision,
+      skillId: result.skillId,
+      enabled: result.enabled,
+      skills: result.skills,
+      skillNames: result.skillNames,
+      skillCount: result.skillCount,
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}
+
+export function configure(nodeId, projectRoot, payload = {}) {
+  try {
+    const current = getCapabilityNode(projectRoot, nodeId)
+    requireSkillGroupNode(current)
+    const updated = updateCapabilityNode(projectRoot, nodeId, {
+      revision: current.node.revision,
+      title: payload.title,
+      description: payload.description,
+      prompt: payload.prompt,
+      sourceGroup: payload.sourceGroup,
+      skills: payload.skills,
+    })
+    return {
+      revision: updated.node.revision,
+      description: updated.state.description || '',
+      prompt: updated.state.prompt || '',
+      sourceGroup: updated.state.sourceGroup || null,
+      skills: updated.state.skills || [],
+      skillNames: updated.state.skillNames || [],
+      skillCount: Number(updated.state.skillCount || 0),
+    }
+  } catch (error) {
+    rethrow(error)
+  }
+}