@ran-sh/dsh-crew 1.0.3 → 1.1.1

package/src/provider-settings-store.mjs

@@ -11,14 +11,28 @@ const PROVIDER_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
 function sha256(value) { return createHash('sha256').update(value, 'utf8').digest('hex'); }
 function indentOf(line) { return (line.match(/^\s*/u) ?? [''])[0].length; }
 function nonBlank(line) { return line.trim() !== '' && !line.trimStart().startsWith('#'); }
+function nextContentLine(lines, start, end = lines.length) {
+  for (let index = start; index < end; index += 1) if (nonBlank(lines[index])) return index;
+  return -1;
+}
+function unquoteScalar(value) {
+  const input = typeof value === 'string' ? value.trim() : '';
+  if (!input) return null;
+  if (input.startsWith('"') && input.endsWith('"')) {
+    try { return JSON.parse(input); } catch { return null; }
+  }
+  if (input.startsWith("'") && input.endsWith("'")) return input.slice(1, -1).replace(/''/gu, "'");
+  return input;
+}
 function scalarField(lines, entry, field) {
-  const pattern = new RegExp(`^\\s+${field}:\\s*(.*?)\\s*$`);
+  const indent = Number.isInteger(entry?.fieldIndent) ? entry.fieldIndent : null;
+  const pattern = new RegExp(`^${indent === null ? '\\s+' : ` {${indent}}`}${field}:\\s*(.*?)\\s*$`);
   for (const line of lines.slice(entry.start, entry.end)) {
     const match = line.match(pattern);
     if (!match) continue;
-    const value = match[1].trim();
+    const value = (entry?.style === 'flow' ? match[1].replace(/,\s*$/u, '') : match[1]).trim();
     if (!value) return null;
-    return value.replace(/^(?:"([\s\S]*)"|'([\s\S]*)')$/u, '$1$2');
+    return unquoteScalar(value);
   }
   return null;
 }
@@ -51,6 +65,39 @@ function parseProviderMap(source) {
   }
   const providersLine = lines.findIndex((line, index) => index > llmStart && index < blockEnd && /^ {2}providers:\s*(?:\{\s*\})?\s*$/u.test(line));
   if (providersLine < 0) return { ok: false, code: 'PROVIDER_SETTINGS_SCHEMA_UNSUPPORTED' };
+  const flowOpenLine = nextContentLine(lines, providersLine + 1, blockEnd);
+  if (flowOpenLine >= 0 && /^ {4}\{\s*$/u.test(lines[flowOpenLine])) {
+    let flowCloseLine = -1;
+    const entries = [];
+    let index = flowOpenLine + 1;
+    while (index < blockEnd) {
+      index = nextContentLine(lines, index, blockEnd);
+      if (index < 0) break;
+      if (/^ {4}\}\s*$/u.test(lines[index])) { flowCloseLine = index; break; }
+      const match = lines[index].match(/^ {6}([A-Za-z0-9][A-Za-z0-9._-]*):\s*$/u);
+      if (!match) return { ok: false, code: 'PROVIDER_SETTINGS_SCHEMA_UNSUPPORTED' };
+      const objectOpen = nextContentLine(lines, index + 1, blockEnd);
+      if (objectOpen < 0 || !/^ {8}\{\s*$/u.test(lines[objectOpen])) return { ok: false, code: 'PROVIDER_SETTINGS_SCHEMA_UNSUPPORTED' };
+      let objectClose = -1;
+      for (let cursor = objectOpen + 1; cursor < blockEnd; cursor += 1) {
+        if (/^ {8}\},?\s*$/u.test(lines[cursor])) { objectClose = cursor; break; }
+      }
+      if (objectClose < 0) return { ok: false, code: 'PROVIDER_SETTINGS_SCHEMA_UNSUPPORTED' };
+      entries.push({ id: match[1], start: index, end: objectClose + 1, style: 'flow', fieldIndent: 10, objectOpen, objectClose });
+      index = objectClose + 1;
+    }
+    if (flowCloseLine < 0) return { ok: false, code: 'PROVIDER_SETTINGS_SCHEMA_UNSUPPORTED' };
+    for (let entryIndex = 0; entryIndex < entries.length - 1; entryIndex += 1) {
+      if (!/^ {8}\},\s*$/u.test(lines[entries[entryIndex].objectClose])) return { ok: false, code: 'PROVIDER_SETTINGS_SCHEMA_UNSUPPORTED' };
+    }
+    if (entries.some((entry) => !validFlowEntryStructure(lines, entry))) {
+      return { ok: false, code: 'PROVIDER_SETTINGS_SCHEMA_UNSUPPORTED' };
+    }
+    return {
+      ok: true, style: 'flow', lines, llmStart, blockEnd, providersLine,
+      providersBlockEnd: flowCloseLine + 1, flowOpenLine, flowCloseLine, entries,
+    };
+  }
   let providersBlockEnd = blockEnd;
   for (let index = providersLine + 1; index < blockEnd; index += 1) {
     if (nonBlank(lines[index]) && indentOf(lines[index]) <= 2) { providersBlockEnd = index; break; }
@@ -74,10 +121,235 @@ function parseProviderMap(source) {
       if (nonBlank(next) && indentOf(next) <= providerIndent) break;
       end += 1;
     }
-    entries.push({ id: match[1], start: index, end });
+    entries.push({ id: match[1], start: index, end, style: 'block', fieldIndent: 6 });
     index = end - 1;
   }
-  return { ok: true, lines, llmStart, blockEnd, providersLine, providersBlockEnd, entries };
+  return { ok: true, style: 'block', lines, llmStart, blockEnd, providersLine, providersBlockEnd, entries };
+}
+
+function splitFlowItems(source) {
+  const items = [];
+  let start = 0;
+  let braces = 0;
+  let brackets = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (quote === '"' && escaped) { escaped = false; continue; }
+      if (quote === '"' && char === '\\') { escaped = true; continue; }
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") { quote = char; continue; }
+    if (char === '{') braces += 1;
+    else if (char === '}') braces -= 1;
+    else if (char === '[') brackets += 1;
+    else if (char === ']') brackets -= 1;
+    else if (char === ',' && braces === 0 && brackets === 0) {
+      items.push(source.slice(start, index).trim());
+      start = index + 1;
+    }
+    if (braces < 0 || brackets < 0) return null;
+  }
+  if (quote || braces !== 0 || brackets !== 0) return null;
+  const tail = source.slice(start).trim();
+  if (tail) items.push(tail);
+  return items;
+}
+
+function parseFlowObject(source, depth = 0) {
+  if (depth > 8) return null;
+  const input = source.trim().replace(/,\s*$/u, '');
+  if (!input.startsWith('{') || !input.endsWith('}')) return null;
+  const items = splitFlowItems(input.slice(1, -1));
+  if (!items) return null;
+  const fields = new Map();
+  for (const item of items) {
+    let splitAt = -1;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < item.length; index += 1) {
+      const char = item[index];
+      if (quote) {
+        if (quote === '"' && escaped) { escaped = false; continue; }
+        if (quote === '"' && char === '\\') { escaped = true; continue; }
+        if (char === quote) quote = null;
+      } else if (char === '"' || char === "'") quote = char;
+      else if (char === ':') { splitAt = index; break; }
+    }
+    if (splitAt < 1 || hasUnseparatedFlowMapping(item, splitAt)) return null;
+    const key = item.slice(0, splitAt).trim();
+    const value = item.slice(splitAt + 1).trim();
+    if (!/^[A-Za-z][A-Za-z0-9_-]*$/u.test(key) || !value || fields.has(key)) return null;
+    if (value.startsWith('{') && (!value.endsWith('}') || parseFlowObject(value, depth + 1) === null)) return null;
+    fields.set(key, value);
+  }
+  return fields;
+}
+
+function hasUnseparatedFlowMapping(item, firstColon) {
+  let braces = 0;
+  let brackets = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = firstColon + 1; index < item.length; index += 1) {
+    const char = item[index];
+    if (quote) {
+      if (quote === '"' && escaped) { escaped = false; continue; }
+      if (quote === '"' && char === '\\') { escaped = true; continue; }
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") { quote = char; continue; }
+    if (char === '{') braces += 1;
+    else if (char === '}') braces -= 1;
+    else if (char === '[') brackets += 1;
+    else if (char === ']') brackets -= 1;
+    else if (char === ':' && braces === 0 && brackets === 0 && /\s/u.test(item[index + 1] ?? '')) return true;
+    if (braces < 0 || brackets < 0) return true;
+  }
+  return quote !== null || braces !== 0 || brackets !== 0;
+}
+
+function validFlowEntryStructure(lines, entry) {
+  const fields = [];
+  let cursor = entry.objectOpen + 1;
+  while (cursor < entry.objectClose) {
+    cursor = nextContentLine(lines, cursor, entry.objectClose);
+    if (cursor < 0) break;
+    const line = lines[cursor];
+    if (indentOf(line) !== entry.fieldIndent) return false;
+    const field = line.match(/^\s+([A-Za-z][A-Za-z0-9_-]*):\s*(.*?)\s*$/u);
+    if (!field) return false;
+    let terminator = cursor;
+    if (!field[2]) {
+      const listOpen = nextContentLine(lines, cursor + 1, entry.objectClose);
+      if (listOpen < 0 || indentOf(lines[listOpen]) !== entry.fieldIndent + 2 || !/^\s*\[\s*$/u.test(lines[listOpen])) return false;
+      const items = [];
+      let listClose = -1;
+      for (let nested = listOpen + 1; nested < entry.objectClose; nested += 1) {
+        if (!nonBlank(lines[nested])) continue;
+        if (indentOf(lines[nested]) === entry.fieldIndent + 2 && /^\s*\]\s*,?\s*$/u.test(lines[nested])) {
+          listClose = nested;
+          break;
+        }
+        if (indentOf(lines[nested]) !== entry.fieldIndent + 4 || !parseFlowObject(lines[nested])) return false;
+        items.push(nested);
+      }
+      if (listClose < 0) return false;
+      for (let index = 0; index < items.length - 1; index += 1) if (!/,\s*$/u.test(lines[items[index]])) return false;
+      terminator = listClose;
+      cursor = listClose + 1;
+    } else {
+      cursor += 1;
+    }
+    fields.push({ terminator });
+  }
+  for (let index = 0; index < fields.length - 1; index += 1) {
+    if (!/,\s*$/u.test(lines[fields[index].terminator])) return false;
+  }
+  return true;
+}
+
+function parseFlowModel(source) {
+  const fields = parseFlowObject(source);
+  if (!fields) return null;
+  const allowed = new Set(['id', 'name', 'contextWindow', 'maxTokens', 'input', 'reasoningEfforts', 'compat']);
+  if ([...fields.keys()].some((key) => !allowed.has(key))) return null;
+  const id = unquoteScalar(fields.get('id'));
+  if (!id || id.length > 256 || /[\r\n]/u.test(id)) return null;
+  const model = { id };
+  if (fields.has('name')) {
+    const name = unquoteScalar(fields.get('name'));
+    if (!name || name.length > 256 || /[\r\n]/u.test(name)) return null;
+    model.name = name;
+  }
+  for (const [sourceKey, targetKey] of [['contextWindow', 'context_window'], ['maxTokens', 'max_tokens']]) {
+    if (!fields.has(sourceKey)) continue;
+    const value = Number(unquoteScalar(fields.get(sourceKey)));
+    if (!Number.isSafeInteger(value) || value <= 0) return null;
+    model[targetKey] = value;
+  }
+  if (fields.has('input')) {
+    const input = fields.get('input').trim();
+    if (!input.startsWith('[') || !input.endsWith(']')) return null;
+    const modalities = splitFlowItems(input.slice(1, -1));
+    if (!modalities) return null;
+    const normalized = modalities.map(unquoteScalar);
+    if (normalized.some((value) => !['text', 'image'].includes(value))) return null;
+    model.input = [...new Set(normalized)];
+  }
+  if (fields.has('reasoningEfforts')) {
+    const efforts = parseFlowObject(fields.get('reasoningEfforts'));
+    if (!efforts) return null;
+    const normalized = {};
+    for (const [key, raw] of efforts) {
+      const value = unquoteScalar(raw);
+      if (raw === 'null' || raw === '~') normalized[key] = null;
+      else if (!value || value.length > 256 || /[\r\n]/u.test(value)) return null;
+      else normalized[key] = value;
+    }
+    model.reasoning_efforts = normalized;
+  }
+  if (fields.has('compat')) {
+    if (fields.get('compat').trim() !== '{}') return null;
+    model.compat = {};
+  }
+  return model;
+}
+
+function readFlowMaterialization(parsed, entry, file) {
+  const directFields = new Set();
+  for (const line of parsed.lines.slice(entry.objectOpen + 1, entry.objectClose)) {
+    if (!nonBlank(line) || indentOf(line) !== entry.fieldIndent) continue;
+    const match = line.match(/^\s+([A-Za-z][A-Za-z0-9_-]*):/u);
+    if (!match || directFields.has(match[1])) return { ok: false, code: 'PROVIDER_MATERIALIZATION_UNSUPPORTED_FIELDS' };
+    directFields.add(match[1]);
+  }
+  const allowed = new Set(['displayName', 'apiKeyEnv', 'api', 'baseURL', 'models']);
+  if ([...directFields].some((field) => !allowed.has(field))) return { ok: false, code: 'PROVIDER_MATERIALIZATION_UNSUPPORTED_FIELDS' };
+  const rawDisplayName = scalarField(parsed.lines, entry, 'displayName');
+  const displayName = rawDisplayName && rawDisplayName.length <= 256 && !/[\r\n]/u.test(rawDisplayName) ? rawDisplayName : entry.id;
+  const rawCredentialRef = scalarField(parsed.lines, entry, 'apiKeyEnv');
+  const credential = classifyCredentialReference(rawCredentialRef, { kind: 'env' });
+  if (credential.redacted) return { ok: false, code: 'PROVIDER_CREDENTIAL_REFERENCE_UNSAFE' };
+  const api = scalarField(parsed.lines, entry, 'api');
+  if (api && (!/^[A-Za-z][A-Za-z0-9._-]{0,127}$/u.test(api) || /^(?:sk|pk|rk|token|secret)[_-]/iu.test(api))) return { ok: false, code: 'PROVIDER_API_SCHEMA_UNSUPPORTED' };
+  const rawBaseUrl = scalarField(parsed.lines, entry, 'baseURL');
+  const baseUrl = rawBaseUrl && rawBaseUrl.length <= 2048 && !/[\r\n]/u.test(rawBaseUrl) ? rawBaseUrl : null;
+  if (baseUrl) {
+    try {
+      const url = new URL(baseUrl);
+      if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash || !url.hostname) return { ok: false, code: 'PROVIDER_BASE_URL_UNSAFE' };
+    } catch { return { ok: false, code: 'PROVIDER_BASE_URL_UNSAFE' }; }
+  }
+  const models = [];
+  if (directFields.has('models')) {
+    const modelsLine = parsed.lines.findIndex((line, index) => index > entry.objectOpen && index < entry.objectClose && /^ {10}models:\s*$/u.test(line));
+    const listOpen = nextContentLine(parsed.lines, modelsLine + 1, entry.objectClose);
+    if (modelsLine < 0 || listOpen < 0 || !/^ {12}\[\s*$/u.test(parsed.lines[listOpen])) return { ok: false, code: 'PROVIDER_MODEL_SCHEMA_UNSUPPORTED' };
+    let listClose = -1;
+    for (let index = listOpen + 1; index < entry.objectClose; index += 1) {
+      if (/^ {12}\]\s*,?\s*$/u.test(parsed.lines[index])) { listClose = index; break; }
+      if (!nonBlank(parsed.lines[index])) continue;
+      if (indentOf(parsed.lines[index]) !== 14) return { ok: false, code: 'PROVIDER_MODEL_SCHEMA_UNSUPPORTED' };
+      const model = parseFlowModel(parsed.lines[index]);
+      if (!model || models.some((candidate) => candidate.id === model.id)) return { ok: false, code: 'PROVIDER_MODEL_SCHEMA_UNSUPPORTED' };
+      models.push(model);
+    }
+    if (listClose < 0) return { ok: false, code: 'PROVIDER_MODEL_SCHEMA_UNSUPPORTED' };
+  }
+  return {
+    ok: true,
+    provider: {
+      id: entry.id, display_name: displayName,
+      ...(credential.value ? { credential_ref: credential.value } : {}),
+      ...(api ? { api } : {}), ...(baseUrl ? { base_url: baseUrl } : {}),
+      models: models.slice(0, 256), source_file: file,
+    },
+  };
 }
 
 const SENSITIVE_CREDENTIAL_FIELD = /(?:api[_-]?key|access[_-]?token|refresh[_-]?token|(?:^|[_-])token(?:$|[_-])|secret|password|authorization|credential|private[_-]?key|client[_-]?secret|cookie|bearer|webhook)/iu;
@@ -142,6 +414,7 @@ export function readProviderSettingsMaterialization(source, { providerId, file =
   if (!parsed.ok) return { ok: false, code: parsed.code };
   const entry = parsed.entries.find((candidate) => candidate.id === providerId);
   if (!entry) return { ok: false, code: 'PROVIDER_NOT_FOUND' };
+  if (parsed.style === 'flow') return readFlowMaterialization(parsed, entry, file);
   const block = parsed.lines.slice(entry.start, entry.end).map((line) => `  ${line}`);
   const synthetic = ['- id: llm-pi-ai', '  config:', '    providers:', ...block, ''].join('\n');
   const result = readProviderMaterialization(synthetic, { providerId, file });
@@ -159,6 +432,47 @@ function yamlScalar(value, max = 2048) {
   return JSON.stringify(value.trim());
 }
 
+function flowModelLine(model) {
+  const fields = [`id: ${yamlScalar(model.id, 256)}`];
+  const name = yamlScalar(model.name, 256);
+  if (name) fields.push(`name: ${name}`);
+  if (Number.isSafeInteger(model.context_window) && model.context_window > 0) fields.push(`contextWindow: ${model.context_window}`);
+  if (Number.isSafeInteger(model.max_tokens) && model.max_tokens > 0) fields.push(`maxTokens: ${model.max_tokens}`);
+  if (Array.isArray(model.input) && model.input.every((value) => value === 'text' || value === 'image')) fields.push(`input: [${[...new Set(model.input)].join(', ')}]`);
+  if (model.reasoning_efforts && typeof model.reasoning_efforts === 'object' && !Array.isArray(model.reasoning_efforts)) {
+    const efforts = [];
+    for (const [key, value] of Object.entries(model.reasoning_efforts)) {
+      if (/^[A-Za-z][A-Za-z0-9_-]*$/u.test(key) && (value === null || yamlScalar(value, 256))) efforts.push(`${key}: ${value === null ? 'null' : yamlScalar(value, 256)}`);
+    }
+    if (efforts.length > 0) fields.push(`reasoningEfforts: { ${efforts.join(', ')} }`);
+  }
+  if (model.compat && typeof model.compat === 'object' && !Array.isArray(model.compat) && Object.keys(model.compat).length === 0) fields.push('compat: {}');
+  return `{ ${fields.join(', ')} }`;
+}
+
+function flowProviderLines(provider) {
+  const displayName = yamlScalar(provider.display_name ?? provider.id, 256);
+  if (!displayName) return null;
+  const credential = provider.credential_ref ? classifyCredentialReference(provider.credential_ref, { kind: 'env' }).value : null;
+  if (provider.credential_ref && !credential) return null;
+  const api = yamlScalar(provider.api, 128);
+  const baseUrl = yamlScalar(provider.base_url, 2048);
+  const models = Array.isArray(provider.models)
+    ? provider.models.filter((model) => model && typeof model.id === 'string' && yamlScalar(model.id, 256)).slice(0, 256)
+    : [];
+  const fields = [`          displayName: ${displayName}`];
+  if (api) fields.push(`          api: ${api}`);
+  if (baseUrl) fields.push(`          baseURL: ${baseUrl}`);
+  if (credential) fields.push(`          apiKeyEnv: ${yamlScalar(credential, 256)}`);
+  if (models.length === 0) {
+    return [`      ${provider.id}:`, '        {', ...fields.map((line, index) => `${line}${index < fields.length - 1 ? ',' : ''}`), '        }'];
+  }
+  const lines = [`      ${provider.id}:`, '        {', ...fields.map((line) => `${line},`), '          models:', '            ['];
+  for (let index = 0; index < models.length; index += 1) lines.push(`              ${flowModelLine(models[index])}${index < models.length - 1 ? ',' : ''}`);
+  lines.push('            ]', '        }');
+  return lines;
+}
+
 /**
  * Add one already-sanitized provider projection to the Harness user layer.
  * The operation is pure and revision-bound; callers perform the atomic write.
@@ -172,6 +486,17 @@ export function addProviderSettings(source, { provider, expectedRevision } = {})
   const parsed = parseProviderMap(source);
   if (!parsed.ok) return { ok: false, code: parsed.code, revision: currentRevision };
   if (parsed.entries.some((entry) => entry.id === provider.id)) return { ok: false, code: 'PROVIDER_SETTINGS_PROVIDER_EXISTS', revision: currentRevision };
+  if (parsed.style === 'flow') {
+    const providerLines = flowProviderLines(provider);
+    if (!providerLines) return { ok: false, code: 'PROVIDER_MATERIALIZATION_INVALID', revision: currentRevision };
+    const nextLines = [...parsed.lines];
+    const previous = parsed.entries.at(-1);
+    if (previous && !/,\s*$/u.test(nextLines[previous.objectClose])) nextLines[previous.objectClose] = `${nextLines[previous.objectClose]},`;
+    nextLines.splice(parsed.flowCloseLine, 0, ...providerLines);
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    const text = nextLines.join(newline);
+    return { ok: true, text, added: provider.id, revision: sha256(text) };
+  }
   const displayName = yamlScalar(provider.display_name ?? provider.id, 256);
   if (!displayName) return { ok: false, code: 'PROVIDER_MATERIALIZATION_INVALID', revision: currentRevision };
   const lines = [`    ${provider.id}:`, `      displayName: ${displayName}`];
@@ -256,6 +581,23 @@ export function mutateProviderSettings(source, {
   }
   const ranges = providerEntry ? [[providerEntry.start, providerEntry.end]] : [];
   const finalProvider = providerEntry && parsed.entries.length === 1;
+  if (removeProvider && parsed.style === 'flow' && finalProvider) {
+    const lines = [...parsed.lines];
+    lines.splice(parsed.providersLine, parsed.flowCloseLine - parsed.providersLine + 1, '  providers: {}');
+    if (defaultParsed) {
+      const removedBeforeProvider = parsed.providersLine <= defaultParsed.providerLine ? parsed.flowCloseLine - parsed.providersLine : 0;
+      const removedBeforeModel = parsed.providersLine <= defaultParsed.modelLine ? parsed.flowCloseLine - parsed.providersLine : 0;
+      lines[defaultParsed.providerLine - removedBeforeProvider] = `  provider: ${replacementDefault.trim()}`;
+      lines[defaultParsed.modelLine - removedBeforeModel] = `  model: ${replacementModel.trim()}`;
+    }
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    const text = lines.join(newline);
+    return {
+      ok: true, text, removed: [providerId], remaining: [],
+      ...(defaultParsed ? { previous_default: { provider: defaultParsed.provider, model: defaultParsed.model } } : {}),
+      revision: sha256(text),
+    };
+  }
   const nextLines = parsed.lines.map((line, index) => {
     if (ranges.some(([start, end]) => index >= start && index < end)) return null;
     if (finalProvider && index === parsed.providersLine) return '  providers: {}';

package/src/runtime-identity.mjs

@@ -5,10 +5,18 @@
 // - HUB_PROTOCOL_VERSION changes only when Hub <-> MCP wire semantics become
 //   incompatible.
 //
+// The Harness/DSH cohort version (e.g. 0.1.2-rc.1) is a THIRD, independent
+// domain: it identifies the installed @deepseek-ai/dsh package generation,
+// never the Crew release. Verifiers must compare the cohort against
+// dsh_version, never against runtime_version.
+//
 // Keep this module dependency-light so Hub, MCP and tests all use the exact
 // same compatibility rules.
 
 import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 
 // Production Crew execution is intentionally bound to the isolated 3210 Hub.
 // These fields are public provenance only; no credential or session secret is
@@ -18,7 +26,7 @@ export const PRODUCTION_PROFILE = 'dsh-crew';
 export const PRODUCTION_LISTEN_PORT = 3210;
 const RUNTIME_ID = randomUUID();
 
-export const RUNTIME_VERSION = '1.0.3';
+export const RUNTIME_VERSION = '1.1.1';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([
@@ -80,6 +88,7 @@ export function getHubRuntimeIdentity() {
     surface: 'native-crew-harness',
     ui_role: 'runtime',
     runtime_version: RUNTIME_VERSION,
+    dsh_version: readCrewDshVersion(),
     protocol_version: HUB_PROTOCOL_VERSION,
     execution_plane: PRODUCTION_EXECUTION_PLANE,
     profile: PRODUCTION_PROFILE,
@@ -89,6 +98,19 @@ export function getHubRuntimeIdentity() {
   };
 }
 
+// Installed Harness cohort version (the @deepseek-ai/dsh package under the
+// Crew-owned DSH home). Null when unreadable: callers treat null as
+// "unknown cohort", never as a match. This is the ONLY field cohort
+// verifiers may compare against TARGET_DSH_VERSION.
+export function readCrewDshVersion({ home = homedir() } = {}) {
+  try {
+    const file = join(home, '.config', 'dsh-crew', 'harness', 'runtime', 'node_modules', '@deepseek-ai', 'dsh', 'package.json');
+    if (!existsSync(file)) return null;
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    return typeof parsed?.version === 'string' && parsed.version.length > 0 ? parsed.version : null;
+  } catch { return null; }
+}
+
 /**
  * Evaluate an already-received Hub ping body.
  *

package/src/supervisor/restart-request.mjs

@@ -0,0 +1,202 @@
+// Durable restart-request protocol between the Crew hub (3210) and the
+// Windows Crew supervisor (launcher).
+//
+// The hub must NEVER spawn itself: self-spawn creates an ownership handoff
+// window (port still held, PID reuse, no authority to judge the new
+// process). Instead the hub writes a durable, self-describing restart
+// request; the supervisor (the only process authority) polls, validates the
+// request against its persisted ownership (PID + start time + live
+// runtime_id), executes the restart, and writes a verified result.
+//
+// Directory layout (all under the Crew app root):
+//   supervisor/restart-requests/<request-id>.json
+//   supervisor/restart-results/<request-id>.json
+//   supervisor/heartbeat.json
+//   supervisor/ownership.json
+
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export const RESTART_REQUEST_SCHEMA = 1;
+export const RESTART_REQUEST_TTL_MS = 60_000;
+
+export function supervisorStateRoot(appRoot) {
+  return join(appRoot, 'supervisor');
+}
+
+export function restartRequestsDir(appRoot) {
+  return join(supervisorStateRoot(appRoot), 'restart-requests');
+}
+
+export function restartResultsDir(appRoot) {
+  return join(supervisorStateRoot(appRoot), 'restart-results');
+}
+
+export function heartbeatFile(appRoot) {
+  return join(supervisorStateRoot(appRoot), 'heartbeat.json');
+}
+
+export function ownershipFile(appRoot) {
+  return join(supervisorStateRoot(appRoot), 'ownership.json');
+}
+
+function writeFileAtomic(file, content) {
+  mkdirSync(dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temp, content);
+  try {
+    renameSync(temp, file);
+  } catch (error) {
+    try { rmSync(temp, { force: true }); } catch {}
+    throw error;
+  }
+}
+
+/**
+ * Create a durable restart request. The runtime identity is taken from the
+ * CALLER's own live identity contract — never accepted from the HTTP caller —
+ * so a stale or forged request cannot claim a runtime_id it does not hold.
+ */
+export function createRestartRequest({
+  appRoot,
+  runtimeIdentity,
+  reason = null,
+  now = Date.now(),
+  ttlMs = RESTART_REQUEST_TTL_MS,
+}) {
+  return createSupervisorRequest({
+    appRoot,
+    operation: 'restart',
+    runtimeIdentity,
+    reason,
+    now,
+    ttlMs,
+  });
+}
+
+/**
+ * Create a durable supervisor request for maintenance transactions
+ * (stop/start around a runtime-tree swap). The launcher-mediated npx flow
+ * uses these instead of spawning/killing the 3210 itself: the launcher is
+ * the only process authority. `lease` binds the stop and start phases of
+ * one transaction; `extra` carries the expected versions for verification.
+ */
+export function createSupervisorRequest({
+  appRoot,
+  operation,
+  runtimeIdentity,
+  reason = null,
+  lease = randomUUID(),
+  extra = null,
+  now = Date.now(),
+  ttlMs = RESTART_REQUEST_TTL_MS,
+}) {
+  const request = {
+    schema_version: RESTART_REQUEST_SCHEMA,
+    request_id: randomUUID(),
+    operation,
+    execution_plane: runtimeIdentity?.execution_plane ?? 'hub-3210',
+    profile: runtimeIdentity?.profile ?? 'dsh-crew',
+    port: runtimeIdentity?.listen_port ?? 3210,
+    runtime_id: runtimeIdentity?.runtime_id ?? null,
+    lease,
+    requested_at: now,
+    expires_at: now + ttlMs,
+    reason: reason ?? null,
+    extra,
+  };
+  if (typeof request.runtime_id !== 'string' || request.runtime_id.length === 0) {
+    return { ok: false, code: 'RUNTIME_IDENTITY_INCOMPLETE', error: 'cannot request supervisor action without a live runtime_id' };
+  }
+  const dir = operation.startsWith('maintenance-') ? maintenanceRequestsDir(appRoot) : restartRequestsDir(appRoot);
+  mkdirSync(dir, { recursive: true });
+  const file = join(dir, `${request.request_id}.json`);
+  writeFileAtomic(file, JSON.stringify(request, null, 2) + '\n');
+  return { ok: true, request, file };
+}
+
+export function maintenanceRequestsDir(appRoot) {
+  return join(supervisorStateRoot(appRoot), 'maintenance-requests');
+}
+
+export function maintenanceResultsDir(appRoot) {
+  return join(supervisorStateRoot(appRoot), 'maintenance-results');
+}
+
+export function readRestartRequest(appRoot, requestId) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(restartRequestsDir(appRoot), `${requestId}.json`), 'utf8'));
+    if (parsed?.schema_version === RESTART_REQUEST_SCHEMA && parsed.request_id === requestId) return parsed;
+  } catch { /* absent or malformed */ }
+  return null;
+}
+
+export function listRestartRequests(appRoot) {
+  const dir = restartRequestsDir(appRoot);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((name) => name.endsWith('.json'))
+    .map((name) => {
+      try { return JSON.parse(readFileSync(join(dir, name), 'utf8')); } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+export function removeRestartRequest(appRoot, requestId) {
+  try { rmSync(join(restartRequestsDir(appRoot), `${requestId}.json`), { force: true }); } catch {}
+}
+
+export function writeRestartResult({ appRoot, request, state, detail = null, now = Date.now() }) {
+  const result = {
+    schema_version: RESTART_REQUEST_SCHEMA,
+    request_id: request.request_id,
+    operation: request.operation,
+    state,
+    runtime_id: request.runtime_id,
+    written_at: now,
+    detail,
+  };
+  const file = join(restartResultsDir(appRoot), `${request.request_id}.json`);
+  writeFileAtomic(file, JSON.stringify(result, null, 2) + '\n');
+  return result;
+}
+
+export function readRestartResult(appRoot, requestId) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(restartResultsDir(appRoot), `${requestId}.json`), 'utf8'));
+    if (parsed?.schema_version === RESTART_REQUEST_SCHEMA && parsed.request_id === requestId) return parsed;
+  } catch { /* absent */ }
+  return null;
+}
+
+/**
+ * Read the supervisor heartbeat. Returns null when the supervisor is not
+ * actively heartbeating (absent, stale beyond tolerance, or malformed).
+ */
+export function readSupervisorHeartbeat(appRoot, { now = Date.now(), staleAfterMs = 15_000 } = {}) {
+  try {
+    const parsed = JSON.parse(readFileSync(heartbeatFile(appRoot), 'utf8'));
+    if (parsed?.schema_version !== 1 || !Number.isInteger(parsed.pid) || parsed.pid < 1) return null;
+    if (typeof parsed.last_seen !== 'number' || now - parsed.last_seen > staleAfterMs) return null;
+    return parsed;
+  } catch { return null; }
+}
+
+export function writeSupervisorHeartbeat({ appRoot, pid, now = Date.now() }) {
+  const record = {
+    schema_version: 1,
+    supervisor_instance_id: randomUUID(),
+    pid,
+    last_seen: now,
+    protocol_version: 1,
+  };
+  // Merge onto the previous record so the instance id is stable per watcher
+  // run (the watcher rewrites this file every few seconds).
+  try {
+    const prev = JSON.parse(readFileSync(heartbeatFile(appRoot), 'utf8'));
+    if (prev?.schema_version === 1) record.supervisor_instance_id = prev.supervisor_instance_id;
+  } catch { /* first beat */ }
+  writeFileAtomic(heartbeatFile(appRoot), JSON.stringify(record, null, 2) + '\n');
+  return record;
+}