@cyber-dash-tech/revela 0.17.18 → 0.17.21

package/lib/domain/domains.ts

@@ -22,7 +22,7 @@ import {
   statSync,
   writeFileSync,
 } from "fs"
-import { join, resolve, basename } from "path"
+import { dirname, join, resolve, basename } from "path"
 import { tmpdir } from "os"
 import { parseFrontmatter } from "../frontmatter"
 import {
@@ -49,6 +49,44 @@ export interface DomainInfo {
   skillText: string
 }
 
+export interface CreateDomainPackageArgs {
+  name: string
+  domainMd: string
+  overwrite?: boolean
+}
+
+export interface CreateDomainDraftArgs extends CreateDomainPackageArgs {
+  workspaceRoot: string
+}
+
+export interface CreateDomainPackageResult {
+  ok: true
+  name: string
+  path: string
+  files: string[]
+  overwritten: boolean
+}
+
+export interface InstallDomainDraftArgs {
+  workspaceRoot: string
+  name: string
+  overwrite?: boolean
+}
+
+export interface InstallDomainDraftResult extends CreateDomainPackageResult {
+  sourcePath: string
+}
+
+export interface ValidateDomainPackageResult {
+  ok: boolean
+  name: string
+  path: string
+  hasIndustryMd: boolean
+  hasRequiredFrontmatter: boolean
+  hasBody: boolean
+  errors: string[]
+}
+
 // ---------------------------------------------------------------------------
 // Seed
 // ---------------------------------------------------------------------------
@@ -148,6 +186,188 @@ export function getDomainSkillMd(name?: string): string {
   return info.skillText
 }
 
+/** Normalize and validate a domain package name. */
+export function normalizeDomainName(name: string): string {
+  const normalized = name.trim().toLowerCase()
+  if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(normalized)) {
+    throw new Error("Domain name must be kebab-case using lowercase letters, numbers, and hyphens")
+  }
+  return normalized
+}
+
+/** Create a local domain package in ~/.config/revela/domains/<name>/. */
+export function createDomainPackage(args: CreateDomainPackageArgs): CreateDomainPackageResult {
+  const name = normalizeDomainName(args.name)
+  const domainMd = args.domainMd?.trim()
+
+  if (!domainMd) throw new Error("domainMd is required")
+
+  const target = join(DOMAINS_DIR, name)
+  const existed = existsSync(target)
+  if (existed && !args.overwrite) {
+    throw new Error(`Domain '${name}' already exists. Pass overwrite=true to replace it.`)
+  }
+
+  mkdirSync(DOMAINS_DIR, { recursive: true })
+  if (existed) {
+    rmSync(target, { recursive: true, force: true })
+  }
+  mkdirSync(target, { recursive: true })
+  writeFileSync(join(target, DOMAIN_FILE), `${domainMd}\n`, "utf-8")
+
+  const validation = validateDomainPackage(name)
+  if (!validation.ok) {
+    throw new Error(`Created domain package is invalid: ${validation.errors.join("; ")}`)
+  }
+
+  return {
+    ok: true,
+    name,
+    path: target,
+    files: [DOMAIN_FILE],
+    overwritten: existed,
+  }
+}
+
+/** Create a project-local domain draft under .revela/drafts/domains/<name>/. */
+export function createDomainDraftPackage(args: CreateDomainDraftArgs): CreateDomainPackageResult {
+  const name = normalizeDomainName(args.name)
+  const domainMd = args.domainMd?.trim()
+
+  if (!domainMd) throw new Error("domainMd is required")
+
+  const target = domainDraftDir(args.workspaceRoot, name)
+  const existed = existsSync(target)
+  if (existed && !args.overwrite) {
+    throw new Error(`Domain draft '${name}' already exists. Pass overwrite=true to replace it.`)
+  }
+
+  mkdirSync(dirname(target), { recursive: true })
+  if (existed) {
+    rmSync(target, { recursive: true, force: true })
+  }
+  mkdirSync(target, { recursive: true })
+  writeFileSync(join(target, DOMAIN_FILE), `${domainMd}\n`, "utf-8")
+
+  const validation = validateDomainDraftPackage(args.workspaceRoot, name)
+  if (!validation.ok) {
+    throw new Error(`Created domain draft is invalid: ${validation.errors.join("; ")}`)
+  }
+
+  return {
+    ok: true,
+    name,
+    path: target,
+    files: [DOMAIN_FILE],
+    overwritten: existed,
+  }
+}
+
+/** Validate a project-local domain draft. */
+export function validateDomainDraftPackage(workspaceRoot: string, nameInput: string): ValidateDomainPackageResult {
+  let name = nameInput
+  try {
+    name = normalizeDomainName(nameInput)
+  } catch {
+    // validateDomainPackageAt records the invalid-name error.
+  }
+  return validateDomainPackageAt(nameInput, domainDraftDir(workspaceRoot, name))
+}
+
+/** Install a validated project-local domain draft into the user-level domain registry. */
+export function installDomainDraftPackage(args: InstallDomainDraftArgs): InstallDomainDraftResult {
+  const name = normalizeDomainName(args.name)
+  const sourcePath = domainDraftDir(args.workspaceRoot, name)
+  const validation = validateDomainDraftPackage(args.workspaceRoot, name)
+  if (!validation.ok) {
+    throw new Error(`Domain draft is invalid: ${validation.errors.join("; ")}`)
+  }
+
+  const target = join(DOMAINS_DIR, name)
+  const existed = existsSync(target)
+  if (existed && !args.overwrite) {
+    throw new Error(`Domain '${name}' already exists. Pass overwrite=true to replace it.`)
+  }
+
+  try {
+    mkdirSync(DOMAINS_DIR, { recursive: true })
+    if (existed) {
+      rmSync(target, { recursive: true, force: true })
+    }
+    cpSync(sourcePath, target, { recursive: true })
+  } catch (e) {
+    throw new Error(`Installing domain draft requires write access to Revela user config at ${DOMAINS_DIR}: ${e instanceof Error ? e.message : String(e)}`)
+  }
+
+  return {
+    ok: true,
+    name,
+    path: target,
+    sourcePath,
+    files: [DOMAIN_FILE],
+    overwritten: existed,
+  }
+}
+
+/** Validate a local domain package for the minimum Revela domain contract. */
+export function validateDomainPackage(nameInput: string): ValidateDomainPackageResult {
+  let name = nameInput
+  try {
+    name = normalizeDomainName(nameInput)
+  } catch {
+    // validateDomainPackageAt records the invalid-name error.
+  }
+  return validateDomainPackageAt(nameInput, join(DOMAINS_DIR, name))
+}
+
+function validateDomainPackageAt(nameInput: string, dir: string): ValidateDomainPackageResult {
+  let name = nameInput
+  const errors: string[] = []
+  try {
+    name = normalizeDomainName(nameInput)
+  } catch (e) {
+    errors.push(e instanceof Error ? e.message : String(e))
+  }
+
+  const mdPath = join(dir, DOMAIN_FILE)
+  const hasIndustryMd = existsSync(mdPath)
+  let hasRequiredFrontmatter = false
+  let hasBody = false
+
+  if (!existsSync(dir)) errors.push(`Domain directory does not exist: ${dir}`)
+  if (!hasIndustryMd) errors.push(`${DOMAIN_FILE} is missing`)
+
+  if (hasIndustryMd) {
+    try {
+      const text = readFileSync(mdPath, "utf-8")
+      const { meta, body } = parseFrontmatter(text)
+      const required = ["name", "description", "author", "version"]
+      const missing = required.filter((field) => !meta[field]?.trim())
+      hasRequiredFrontmatter = missing.length === 0
+      hasBody = body.trim().length > 0
+      if (!hasRequiredFrontmatter) errors.push(`INDUSTRY.md frontmatter is missing required field(s): ${missing.join(", ")}`)
+      if (!hasBody) errors.push("INDUSTRY.md body/guidance is empty")
+      if (meta.name && meta.name.trim() !== name) errors.push(`INDUSTRY.md frontmatter name '${meta.name.trim()}' does not match package name '${name}'`)
+    } catch (e) {
+      errors.push(`INDUSTRY.md could not be parsed: ${e instanceof Error ? e.message : String(e)}`)
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    name,
+    path: dir,
+    hasIndustryMd,
+    hasRequiredFrontmatter,
+    hasBody,
+    errors,
+  }
+}
+
+function domainDraftDir(workspaceRoot: string, name: string): string {
+  return resolve(workspaceRoot, ".revela", "drafts", "domains", name)
+}
+
 /** Remove an installed domain. Throws if not found or is the protected default. */
 export function removeDomain(name: string): void {
   if (name === DEFAULT_DOMAIN) {

package/lib/qa/checks.ts

@@ -209,19 +209,16 @@ function checkCanvas(metrics: SlideMetrics): LayoutIssue[] {
   }
 
   const canvasBad = Math.abs(metrics.canvasRect.width - CANVAS_W) > tol || Math.abs(metrics.canvasRect.height - CANVAS_H) > tol
-  const slideBad = Math.abs(metrics.slideRect.width - CANVAS_W) > tol || Math.abs(metrics.slideRect.height - CANVAS_H) > tol
 
-  if (canvasBad || slideBad) {
+  if (canvasBad) {
     issues.push({
       type: "canvas",
       sub: "size_mismatch",
       severity: "error",
-      detail: `Slide and canvas must render exactly ${CANVAS_W}x${CANVAS_H}px. Measured slide ${Math.round(metrics.slideRect.width)}x${Math.round(metrics.slideRect.height)}px, canvas ${Math.round(metrics.canvasRect.width)}x${Math.round(metrics.canvasRect.height)}px.`,
+      detail: `.slide-canvas must render exactly ${CANVAS_W}x${CANVAS_H}px. Measured canvas ${Math.round(metrics.canvasRect.width)}x${Math.round(metrics.canvasRect.height)}px.`,
       data: {
         expectedWidth: CANVAS_W,
         expectedHeight: CANVAS_H,
-        slideWidth: Math.round(metrics.slideRect.width),
-        slideHeight: Math.round(metrics.slideRect.height),
         canvasWidth: Math.round(metrics.canvasRect.width),
         canvasHeight: Math.round(metrics.canvasRect.height),
       },
@@ -911,7 +908,7 @@ export function formatReport(report: QAReport): string {
     `### Action Required`,
     ``,
     `Please fix the above hard-error issues in the HTML file. For each issue type:`,
-    `- **canvas**: ensure each slide and .slide-canvas render exactly 1920x1080px, not merely any 16:9 size.`,
+    `- **canvas**: ensure each canonical .slide has exactly one direct .slide-canvas and that .slide-canvas renders exactly 1920x1080px, not merely any 16:9 size.`,
     `- **scrollbar**: remove horizontal document/body scrolling and slide-internal scrolling. Multi-slide decks may use normal vertical document scroll for navigation.`,
     `- **navigation**: keep every .slide in normal document flow; do not stack slides with fixed/absolute positioning or rely on aria-hidden/visibility toggles for pagination. Use scrollIntoView-based navigation.`,
     `- **overflow**: reduce font size, padding, or content amount for the affected element.`,

package/lib/runtime/index.ts

@@ -4,18 +4,24 @@ import { dirname, resolve } from "path"
 import {
   activeDesign,
   activateDesign,
+  createDesignDraftPackage,
   createDesignPackage,
   getDesignSection,
   getDesignSkillMd,
+  installDesignDraftPackage,
   listDesigns,
   seedBuiltinDesigns,
+  validateDesignDraftPackage,
   validateDesignPackage,
 } from "../design/designs"
 import { createDeckFoundation as createDeckFoundationShell } from "../deck-html/foundation"
-import { activeDomain, activateDomain, getDomainSkillMd, listDomains, seedBuiltinDomains } from "../domain/domains"
+import { activeDomain, activateDomain, createDomainDraftPackage, createDomainPackage, getDomainSkillMd, installDomainDraftPackage, listDomains, seedBuiltinDomains, validateDomainDraftPackage, validateDomainPackage } from "../domain/domains"
 import { computeNarrativeHash } from "../narrative-state/hash"
 import { compileNarrativeVault } from "../narrative-vault/compile"
+import { autoCompileNarrativeVault } from "../narrative-vault/auto-compile"
+import { extractNarrativeVaultMarkdownTargetsFromPatch } from "../narrative-vault/hook-targets"
 import { runNarrativeMarkdownQa, type MarkdownQaOptions } from "../narrative-vault/markdown-qa"
+import { formatArtifactQaUserNotice, formatMarkdownQaUserNotice } from "../hook-notifications"
 import { readDeckPlanArtifact } from "../narrative-state/deck-plan-artifact"
 import { extractDesignClasses } from "../design/designs"
 import { recordRenderedArtifact, workspaceRelative } from "../workspace-state/rendered-artifacts"
@@ -32,6 +38,10 @@ export interface RuntimeFileInput extends RuntimeWorkspaceInput {
   file: string
 }
 
+export interface RuntimeNarrativeAutoCompileInput extends RuntimeWorkspaceInput {
+  touched?: string[]
+}
+
 export interface RuntimeDeckFoundationInput extends RuntimeWorkspaceInput {
   outputPath: string
   title: string
@@ -55,12 +65,28 @@ export interface RuntimeDesignCreateInput {
   overwrite?: boolean
 }
 
+export interface RuntimeDesignDraftCreateInput extends RuntimeDesignCreateInput, RuntimeWorkspaceInput {}
+
+export interface RuntimeDomainCreateInput {
+  name: string
+  domainMd: string
+  overwrite?: boolean
+}
+
+export interface RuntimeDomainDraftCreateInput extends RuntimeDomainCreateInput, RuntimeWorkspaceInput {}
+
+export interface RuntimeDraftInstallInput extends RuntimeWorkspaceInput {
+  name: string
+  overwrite?: boolean
+}
+
 export interface RuntimeNameInput {
   name: string
 }
 
 export function doctor(input: RuntimeWorkspaceInput = {}) {
   const workspaceRoot = root(input.workspaceRoot)
+  const domain = activeDomainDoctorInfo()
   return {
     ok: true,
     version: pkg.version,
@@ -69,6 +95,8 @@ export function doctor(input: RuntimeWorkspaceInput = {}) {
     hasDeckPlan: existsSync(resolve(workspaceRoot, "deck-plan")),
     hasDecksJson: existsSync(resolve(workspaceRoot, "DECKS.json")),
     activeDesign: safe(activeDesign),
+    activeDomain: domain.name,
+    activeDomainDescription: domain.description,
   }
 }
 
@@ -86,6 +114,18 @@ export function markdownQa(input: RuntimeWorkspaceInput & MarkdownQaOptions = {}
   })
 }
 
+export function autoCompileNarrative(input: RuntimeNarrativeAutoCompileInput = {}) {
+  const workspaceRoot = root(input.workspaceRoot)
+  return autoCompileNarrativeVault(workspaceRoot, input.touched ?? [])
+}
+
+export function extractNarrativeVaultMarkdownPatchTargets(input: RuntimeWorkspaceInput & { patch: string }) {
+  const workspaceRoot = root(input.workspaceRoot)
+  return extractNarrativeVaultMarkdownTargetsFromPatch(input.patch, workspaceRoot)
+}
+
+export { formatArtifactQaUserNotice, formatMarkdownQaUserNotice }
+
 export function readDeckPlan(input: RuntimeWorkspaceInput = {}) {
   const workspaceRoot = root(input.workspaceRoot)
   const compiled = compileNarrativeVault(workspaceRoot)
@@ -220,6 +260,30 @@ export function designValidate(input: RuntimeNameInput) {
   return validateDesignPackage(requiredName(input, "design"))
 }
 
+export function designDraftCreate(input: RuntimeDesignDraftCreateInput) {
+  return createDesignDraftPackage({
+    workspaceRoot: root(input.workspaceRoot),
+    name: requiredString(input?.name, "design name"),
+    base: input.base,
+    designMd: requiredString(input?.designMd, "designMd"),
+    previewHtml: requiredString(input?.previewHtml, "previewHtml"),
+    overwrite: input.overwrite ?? false,
+  })
+}
+
+export function designDraftValidate(input: RuntimeWorkspaceInput & RuntimeNameInput) {
+  return validateDesignDraftPackage(root(input.workspaceRoot), requiredName(input, "design draft"))
+}
+
+export function designDraftInstall(input: RuntimeDraftInstallInput) {
+  seedBuiltinDesigns()
+  return installDesignDraftPackage({
+    workspaceRoot: root(input.workspaceRoot),
+    name: requiredName(input, "design draft"),
+    overwrite: input.overwrite ?? false,
+  })
+}
+
 export interface DesignRulesReadinessResult {
   ok: boolean
   activeDesign: string
@@ -322,6 +386,42 @@ export function domainActivate(input: RuntimeNameInput) {
   }
 }
 
+export function domainCreate(input: RuntimeDomainCreateInput) {
+  seedBuiltinDomains()
+  return createDomainPackage({
+    name: requiredString(input?.name, "domain name"),
+    domainMd: requiredString(input?.domainMd, "domainMd"),
+    overwrite: input.overwrite ?? false,
+  })
+}
+
+export function domainValidate(input: RuntimeNameInput) {
+  seedBuiltinDomains()
+  return validateDomainPackage(requiredName(input, "domain"))
+}
+
+export function domainDraftCreate(input: RuntimeDomainDraftCreateInput) {
+  return createDomainDraftPackage({
+    workspaceRoot: root(input.workspaceRoot),
+    name: requiredString(input?.name, "domain name"),
+    domainMd: requiredString(input?.domainMd, "domainMd"),
+    overwrite: input.overwrite ?? false,
+  })
+}
+
+export function domainDraftValidate(input: RuntimeWorkspaceInput & RuntimeNameInput) {
+  return validateDomainDraftPackage(root(input.workspaceRoot), requiredName(input, "domain draft"))
+}
+
+export function domainDraftInstall(input: RuntimeDraftInstallInput) {
+  seedBuiltinDomains()
+  return installDomainDraftPackage({
+    workspaceRoot: root(input.workspaceRoot),
+    name: requiredName(input, "domain draft"),
+    overwrite: input.overwrite ?? false,
+  })
+}
+
 function root(workspaceRoot: string | undefined): string {
   return resolve(workspaceRoot || process.cwd())
 }
@@ -334,6 +434,17 @@ function safe<T>(fn: () => T): T | undefined {
   }
 }
 
+function activeDomainDoctorInfo(): { name: string; description: string } {
+  try {
+    seedBuiltinDomains()
+    const name = activeDomain()
+    const description = listDomains().find((domain) => domain.name === name)?.description ?? ""
+    return { name, description }
+  } catch {
+    return { name: safe(activeDomain) ?? "", description: "" }
+  }
+}
+
 function requiredName(input: RuntimeNameInput, label: string): string {
   const name = input?.name?.trim()
   if (!name) throw new Error(`${label} name is required`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyber-dash-tech/revela",
-  "version": "0.17.18",
+  "version": "0.17.21",
   "description": "OpenCode plugin for trusted narrative artifacts from local sources, research, and evidence",
   "type": "module",
   "main": "./index.ts",

package/plugins/revela/.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "revela": {
       "command": "npx",
-      "args": ["-y", "@cyber-dash-tech/revela@0.17.18", "mcp"]
+      "args": ["-y", "@cyber-dash-tech/revela@0.17.21", "mcp"]
     }
   }
 }

package/plugins/revela/hooks/revela_guard.ts

@@ -17,6 +17,15 @@ export async function runPreWriteChecks(input: string): Promise<HookResult> {
     messages.push(`Revela controls ${controlledStateFile}. Use Revela MCP/runtime tools or file-native narrative files instead of direct ${controlledStateFile} patches.`)
   }
 
+  const cacheTargets = extractNarrativeCachePatchTargets(input)
+  if (cacheTargets.length > 0) {
+    messages.push([
+      "Revela narrative cache patches are blocked.",
+      `Controlled cache target(s): ${cacheTargets.map((target) => `\`${target}\``).join(", ")}`,
+      "Edit `revela-narrative/**/*.md` instead; compile/cache files under `.opencode/revela/narrative-cache/` are regenerated.",
+    ].join("\n"))
+  }
+
   const deckTargets = extractDeckHtmlPatchTargets(input)
   if (deckTargets.length > 0) {
     const pluginRoot = resolve(process.env.PLUGIN_ROOT || dirname(dirname(fileURLToPath(import.meta.url))))
@@ -55,6 +64,16 @@ export function extractDeckHtmlPatchTargets(input: string): string[] {
   return [...targets].sort((a, b) => a.localeCompare(b))
 }
 
+export function extractNarrativeCachePatchTargets(input: string): string[] {
+  const targets = new Set<string>()
+  for (const patch of patchPayloads(input)) {
+    const pattern = /(?:^\*\*\* Update File: |^\*\*\* Add File: |^\*\*\* Delete File: |^\*\*\* Move to: )([^\r\n]*\.opencode\/revela\/narrative-cache\/[^\r\n]+)\s*$/gm
+    let match: RegExpExecArray | null
+    while ((match = pattern.exec(patch))) targets.add(match[1].trim())
+  }
+  return [...targets].sort((a, b) => a.localeCompare(b))
+}
+
 function patchPayloads(input: string): string[] {
   try {
     const parsed = JSON.parse(input)

package/plugins/revela/hooks/revela_post_write_notice.ts

@@ -24,6 +24,20 @@ export function extractDeckHtmlTargets(input: string): string[] {
   return [...targets].sort((a, b) => a.localeCompare(b))
 }
 
+export function patchPayloadsFromInput(input: string): string[] {
+  try {
+    const parsed = JSON.parse(input)
+    return [
+      parsed.patch,
+      parsed.args?.patch,
+      parsed.tool_input?.patch,
+      parsed.toolInput?.patch,
+    ].filter((item): item is string => typeof item === "string")
+  } catch {
+    return [input]
+  }
+}
+
 export function workspaceRootFromInput(input: string): string {
   try {
     const parsed = JSON.parse(input)
@@ -47,18 +61,16 @@ export function workspaceRootFromInput(input: string): string {
 
 export async function runPostWriteChecks(input: string): Promise<HookResult> {
   const messages: string[] = []
-  if (/revela-narrative\/.*\.md/.test(input)) {
-    messages.push("Revela narrative Markdown changed. Run `revela_markdown_qa` and `revela_compile_narrative` before treating the graph as usable.")
-  }
-
   const deckTargets = extractDeckHtmlTargets(input)
-  if (deckTargets.length === 0) return { ok: true, messages }
+  const hasPossibleNarrativeMarkdown = /revela-narrative\/.*\.md/.test(input)
+  if (deckTargets.length === 0 && !hasPossibleNarrativeMarkdown) return { ok: true, messages }
 
   const pluginRoot = resolve(process.env.PLUGIN_ROOT || dirname(dirname(fileURLToPath(import.meta.url))))
   const runtime = resolveRevelaRuntime({ pluginRoot })
   if (!runtime.ok || !runtime.runtimePath) {
+    const changed = deckTargets.length > 0 ? "deck HTML changed" : "narrative Markdown changed"
     messages.push([
-      "Revela deck HTML changed, but Codex hook could not locate the Revela runtime to run Artifact QA.",
+      `Revela ${changed}, but Codex hook could not locate the Revela runtime to run write-after checks.`,
       ...runtime.diagnostics.map((item) => `- ${item}`),
     ].join("\n"))
     return { ok: false, messages }
@@ -67,9 +79,28 @@ export async function runPostWriteChecks(input: string): Promise<HookResult> {
   const workspaceRoot = workspaceRootFromInput(input)
   const runtimeModule = await import(pathToFileURL(runtime.runtimePath).href)
   let ok = true
+
+  if (hasPossibleNarrativeMarkdown) {
+    const touched = new Set<string>()
+    for (const patch of patchPayloadsFromInput(input)) {
+      const targets = runtimeModule.extractNarrativeVaultMarkdownPatchTargets({ workspaceRoot, patch })
+      for (const target of targets) touched.add(target)
+    }
+
+    if (touched.size > 0) {
+      const result = runtimeModule.autoCompileNarrative({ workspaceRoot, touched: [...touched] })
+      messages.push(result.markdown ?? JSON.stringify(result, null, 2))
+      const notice = runtimeModule.formatMarkdownQaUserNotice?.(result)
+      if (notice) messages.push(notice)
+      if (!result.ok) ok = false
+    }
+  }
+
   for (const target of deckTargets) {
     const result = await runtimeModule.runDeckQa({ workspaceRoot, file: target })
     messages.push(result.markdown ?? JSON.stringify(result, null, 2))
+    const notice = runtimeModule.formatArtifactQaUserNotice?.(result.report)
+    if (notice) messages.push(notice)
     if (!result.ok) ok = false
   }