arkaos 2.77.0 → 2.79.0

package/VERSION

@@ -1 +1 @@
-2.77.0
+2.79.0

package/core/sync/update_orchestrator.py

@@ -0,0 +1,244 @@
+"""One-stop /arka update orchestrator (PR61 v2.78.0).
+
+The published 2-step process (`npx arkaos@latest update` then
+`/arka update`) is fragile in practice: operators run step 2 inside
+Claude Code without remembering step 1, so the sync engine silently
+runs from whichever npx cache `~/.arkaos/.repo-path` last pointed at.
+When that cache is months old the sync becomes a no-op against
+current versions.
+
+This module makes `/arka update` self-sufficient:
+
+1. Read the running ArkaOS version from `<repo>/VERSION`.
+2. Probe the npm registry for the published latest (5s timeout,
+   1-hour cache on disk to keep repeat runs cheap).
+3. If the running version is older than the latest, shell out to
+   `npx arkaos@latest update` and wait for it to finish before
+   touching the sync engine. The npx step rewrites
+   ``~/.arkaos/.repo-path`` to the freshly-extracted package so the
+   sync engine below reads the right code.
+4. Re-read VERSION (now updated) and dispatch to ``run_sync``.
+
+The orchestrator NEVER raises on transient failures — npm offline,
+slow registry, missing `npx` — it logs and falls through to the sync
+engine using whatever code is currently installed. Worst case the
+operator sees the same behaviour as before PR61.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from core.sync.engine import (
+    _read_current_version,
+    _read_repo_path,
+    run_sync,
+)
+from core.sync.schema import SyncReport
+
+
+# Cache the npm-view result for an hour so repeated /arka update calls
+# inside the same session don't re-hit the registry.
+_NPM_CACHE_TTL_SECONDS = 3600
+_NPM_TIMEOUT_SECONDS = 5
+_NPM_PROBE_CMD = ("npm", "view", "arkaos", "version")
+_NPX_UPDATE_CMD = ("npx", "-y", "arkaos@latest", "update")
+_NPX_TIMEOUT_SECONDS = 600  # 10 minutes — large installs can be slow
+
+
+def orchestrate(
+    arkaos_home: Path,
+    skills_dir: Path,
+    home_path: str,
+    *,
+    npm_probe=None,
+    npx_run=None,
+    cache_path: Path | None = None,
+) -> tuple[Optional[str], Optional[str], SyncReport]:
+    """Run npm-side update when stale, then the sync engine.
+
+    Returns ``(installed_version_before, latest_version_seen, report)``.
+    The first two are None when probing failed; the third is always a
+    SyncReport (the engine itself never raises on individual project
+    failures).
+    """
+    probe = npm_probe or _probe_npm_latest
+    runner = npx_run or _run_npx_update
+    cache = cache_path or (arkaos_home / "npm-latest.cache.json")
+
+    installed = _safe_read_version(arkaos_home)
+    latest = probe(cache)
+
+    if installed and latest and _is_older(installed, latest):
+        runner(arkaos_home)
+
+    report = run_sync(
+        arkaos_home=arkaos_home,
+        skills_dir=skills_dir,
+        home_path=home_path,
+    )
+    return installed, latest, report
+
+
+def _safe_read_version(arkaos_home: Path) -> Optional[str]:
+    try:
+        v = _read_current_version(arkaos_home)
+        return v if v and v != "unknown" else None
+    except Exception:  # noqa: BLE001 — never break the orchestrator
+        return None
+
+
+def _probe_npm_latest(cache_path: Path) -> Optional[str]:
+    """Return the latest published arkaos version, or None on failure.
+
+    Reads from disk cache when fresh; otherwise shells out to
+    ``npm view`` with a short timeout. Always swallows errors —
+    callers fall through to a no-op when probing fails.
+    """
+    cached = _read_cache(cache_path)
+    if cached is not None:
+        return cached
+    try:
+        result = subprocess.run(
+            list(_NPM_PROBE_CMD),
+            capture_output=True,
+            text=True,
+            timeout=_NPM_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    version = (result.stdout or "").strip()
+    if not _looks_like_semver(version):
+        return None
+    _write_cache(cache_path, version)
+    return version
+
+
+def _read_cache(cache_path: Path) -> Optional[str]:
+    if not cache_path.exists():
+        return None
+    try:
+        data = json.loads(cache_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    ts = data.get("ts")
+    version = data.get("version")
+    if not isinstance(ts, (int, float)) or not isinstance(version, str):
+        return None
+    if time.time() - ts > _NPM_CACHE_TTL_SECONDS:
+        return None
+    return version if _looks_like_semver(version) else None
+
+
+def _write_cache(cache_path: Path, version: str) -> None:
+    try:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        cache_path.write_text(
+            json.dumps({"version": version, "ts": time.time()}),
+            encoding="utf-8",
+        )
+    except OSError:
+        pass
+
+
+def _looks_like_semver(value: str) -> bool:
+    if not value or len(value) > 32:
+        return False
+    # Strip any `-prerelease.suffix` so "2.77.0-beta.1" reduces to "2.77.0"
+    # before structural validation. npm canonical semver allows almost any
+    # ASCII after the dash; we don't try to validate that — we only need
+    # to confirm the leading major.minor.patch shape is intact.
+    base = value.split("-", 1)[0]
+    parts = base.split(".")
+    if len(parts) != 3:
+        return False
+    return all(part.isdigit() for part in parts)
+
+
+def _is_older(installed: str, latest: str) -> bool:
+    return _parse_semver(installed) < _parse_semver(latest)
+
+
+def _parse_semver(value: str) -> tuple[int, int, int]:
+    parts = value.split(".")
+    try:
+        major = int(parts[0])
+        minor = int(parts[1])
+        patch_str = parts[2].split("-", 1)[0]
+        patch = int(patch_str)
+        return major, minor, patch
+    except (ValueError, IndexError):
+        return (0, 0, 0)
+
+
+def _run_npx_update(arkaos_home: Path) -> None:
+    """Best-effort shell-out to `npx arkaos@latest update`.
+
+    Inherits the parent's stdout/stderr so the operator sees the same
+    installer banner they would in a manual run. Swallows OSError /
+    TimeoutExpired so the surrounding sync still runs.
+    """
+    del arkaos_home  # passed for symmetry with _probe_npm_latest signature
+    try:
+        env = os.environ.copy()
+        # Some operators set CI=1 to suppress installer prompts; preserve it.
+        subprocess.run(
+            list(_NPX_UPDATE_CMD),
+            check=False,
+            timeout=_NPX_TIMEOUT_SECONDS,
+            env=env,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        sys.stderr.write(
+            f"[arkaos] npx arkaos@latest update failed: {exc}\n"
+            "[arkaos] continuing with the sync engine using the "
+            "currently-installed core.\n"
+        )
+
+
+def main(argv: list[str]) -> int:
+    """CLI entry: python -m core.sync.update_orchestrator --home X --skills Y."""
+    import argparse
+    parser = argparse.ArgumentParser(description="ArkaOS one-stop /arka update")
+    parser.add_argument("--home", required=True)
+    parser.add_argument("--skills", required=True)
+    parser.add_argument("--output", choices=["text", "json"], default="text")
+    args = parser.parse_args(argv[1:])
+
+    installed, latest, report = orchestrate(
+        arkaos_home=Path(args.home),
+        skills_dir=Path(args.skills),
+        home_path=str(Path.home()),
+    )
+
+    if args.output == "json":
+        payload = {
+            "installed_version_before": installed,
+            "latest_version_seen": latest,
+            "report": report.model_dump(),
+        }
+        print(json.dumps(payload, indent=2))
+    else:
+        from core.sync.reporter import format_report
+        print(f"Installed: {installed or 'unknown'}")
+        print(f"Latest published: {latest or 'unknown'}")
+        if installed and latest and _is_older(installed, latest):
+            print(f"Updated from {installed} → {latest} via npx arkaos@latest")
+        print()
+        print(format_report(report))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/dashboard/app/components/PersonaWizard.vue

@@ -0,0 +1,504 @@
+<script setup lang="ts">
+import type { Persona } from '~/types'
+
+// PR62 v2.79.0 — 4-step AI-powered persona wizard.
+// Replaces the original "fill a 30-field form" UX with:
+//   1. Sources  → operator pastes URLs / picks files, optionally types a name
+//   2. Ingest   → existing /api/knowledge/ingest-bulk fans the URLs out into
+//                 background jobs and shows progress via WebSocket
+//   3. Build    → /api/personas/build (PR57) reads the indexed chunks and
+//                 returns a draft Persona; operator reviews + edits
+//   4. Save     → POST /api/personas (manual create path), optional
+//                 clone-to-agent at the end
+//
+// The wizard NEVER auto-saves — every transition is operator-confirmed.
+
+const { apiBase } = useApi()
+const toast = useToast()
+
+const emit = defineEmits<{
+  (e: 'completed', persona: Persona): void
+  (e: 'cancelled'): void
+}>()
+
+type Step = 1 | 2 | 3 | 4
+const step = ref<Step>(1)
+
+// ─── Step 1 state ────────────────────────────────────────────────────────
+const name = ref('')
+const sourceLabel = ref('')
+const sources = ref('')
+const skipIngest = ref(false)
+const sourceLineCount = computed(() =>
+  sources.value
+    .split('\n')
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0)
+    .length,
+)
+
+// ─── Step 2 state ────────────────────────────────────────────────────────
+const ingestJobs = ref<Array<{
+  source: string
+  job_id?: string
+  status: 'queued' | 'processing' | 'completed' | 'failed'
+  progress: number
+  error?: string
+}>>([])
+let ws: WebSocket | null = null
+const allIngestComplete = computed(() =>
+  ingestJobs.value.length > 0
+  && ingestJobs.value.every((j) => j.status === 'completed' || j.status === 'failed'),
+)
+const ingestCompletedCount = computed(() =>
+  ingestJobs.value.filter((j) => j.status === 'completed').length,
+)
+
+// ─── Step 3 state ────────────────────────────────────────────────────────
+const draft = ref<Persona | null>(null)
+const building = ref(false)
+const buildError = ref<string | null>(null)
+const chunksUsed = ref<number | null>(null)
+
+// ─── Step 4 state ────────────────────────────────────────────────────────
+const saving = ref(false)
+const saveAndClone = ref(false)
+const cloneDept = ref('strategy')
+const cloneTier = ref<'1' | '2' | '3'>('2')
+
+const departmentOptions = [
+  'dev', 'marketing', 'brand', 'finance', 'strategy', 'ecom', 'kb', 'ops',
+  'pm', 'saas', 'landing', 'content', 'community', 'sales', 'leadership', 'org',
+].map((d) => ({ label: d, value: d }))
+
+const tierOptions = [
+  { label: 'Tier 1 — Squad Lead', value: '1' },
+  { label: 'Tier 2 — Specialist', value: '2' },
+  { label: 'Tier 3 — Support', value: '3' },
+]
+
+// ─── Step 1 → 2 transition ───────────────────────────────────────────────
+
+
+async function startIngest() {
+  if (skipIngest.value) {
+    // Jump straight to step 3 — operator says content is already indexed.
+    step.value = 3
+    await runBuild()
+    return
+  }
+  const cleaned = sources.value
+    .split('\n')
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0)
+  if (cleaned.length === 0 || !name.value.trim()) return
+  step.value = 2
+  ingestJobs.value = cleaned.map((source) => ({
+    source,
+    status: 'queued',
+    progress: 0,
+  }))
+  try {
+    const res = await $fetch<{ jobs: Array<{ source: string, job_id?: string, error?: string }>, count: number }>(
+      `${apiBase}/api/knowledge/ingest-bulk`,
+      { method: 'POST', body: { sources: cleaned } },
+    )
+    res.jobs.forEach((j) => {
+      const row = ingestJobs.value.find((r) => r.source === j.source)
+      if (!row) return
+      if (j.error) {
+        row.status = 'failed'
+        row.error = j.error
+      } else if (j.job_id) {
+        row.job_id = j.job_id
+        row.status = 'processing'
+      }
+    })
+    connectWebSocket()
+  } catch (err) {
+    toast.add({
+      title: 'Ingest failed',
+      description: err instanceof Error ? err.message : 'unknown error',
+      color: 'error',
+    })
+    step.value = 1
+  }
+}
+
+
+function connectWebSocket() {
+  if (ws && ws.readyState === WebSocket.OPEN) return
+  const wsUrl = apiBase.replace('http://', 'ws://').replace('https://', 'wss://') + '/ws/tasks'
+  ws = new WebSocket(wsUrl)
+  ws.onmessage = (event) => {
+    try {
+      const data = JSON.parse(event.data)
+      const row = ingestJobs.value.find((j) => j.job_id === data.job_id)
+      if (!row) return
+      if (data.type === 'job_progress') {
+        row.progress = data.progress
+        row.status = 'processing'
+      } else if (data.type === 'job_complete') {
+        row.status = 'completed'
+        row.progress = 100
+      } else if (data.type === 'job_failed') {
+        row.status = 'failed'
+        row.error = data.error
+      }
+    } catch { /* ignore malformed messages */ }
+  }
+}
+
+
+function disconnectWebSocket() {
+  if (ws) {
+    try { ws.close() } catch { /* already closed */ }
+    ws = null
+  }
+}
+
+
+onBeforeUnmount(() => {
+  disconnectWebSocket()
+})
+
+
+// ─── Step 3: build the persona draft ────────────────────────────────────
+
+
+async function runBuild() {
+  building.value = true
+  buildError.value = null
+  draft.value = null
+  try {
+    const res = await $fetch<{ persona: Persona, chunks_used: number, provider_name: string }>(
+      `${apiBase}/api/personas/build`,
+      {
+        method: 'POST',
+        body: {
+          name: name.value.trim(),
+          source_label: sourceLabel.value.trim() || name.value.trim(),
+        },
+      },
+    )
+    if ('error' in res && typeof (res as any).error === 'string') {
+      throw new Error((res as any).error)
+    }
+    draft.value = res.persona
+    chunksUsed.value = res.chunks_used
+    step.value = 4
+  } catch (err) {
+    buildError.value = err instanceof Error ? err.message : 'unknown error'
+  } finally {
+    building.value = false
+  }
+}
+
+
+// ─── Step 4: save + optional clone ──────────────────────────────────────
+
+
+async function savePersona() {
+  if (!draft.value) return
+  saving.value = true
+  try {
+    const created = await $fetch<Persona>(`${apiBase}/api/personas`, {
+      method: 'POST',
+      body: draft.value,
+    })
+    if (saveAndClone.value && cloneDept.value && cloneTier.value) {
+      await $fetch(`${apiBase}/api/personas/${created.id}/clone`, {
+        method: 'POST',
+        body: { department: cloneDept.value, tier: Number(cloneTier.value) },
+      })
+    }
+    toast.add({
+      title: saveAndClone.value ? 'Persona saved + agent cloned' : 'Persona saved',
+      description: `${created.name} is now in your board.`,
+      color: 'success',
+    })
+    emit('completed', created)
+  } catch (err) {
+    toast.add({
+      title: 'Save failed',
+      description: err instanceof Error ? err.message : 'unknown error',
+      color: 'error',
+    })
+  } finally {
+    saving.value = false
+  }
+}
+
+
+// ─── Auto-advance when ingest completes ─────────────────────────────────
+
+
+watch(allIngestComplete, async (done) => {
+  if (done && step.value === 2 && ingestCompletedCount.value > 0) {
+    step.value = 3
+    await runBuild()
+  }
+})
+
+
+function cancel() {
+  disconnectWebSocket()
+  emit('cancelled')
+}
+
+
+function backToStep1() {
+  disconnectWebSocket()
+  step.value = 1
+  ingestJobs.value = []
+}
+</script>
+
+<template>
+  <UCard>
+    <template #header>
+      <div class="flex items-center justify-between">
+        <div>
+          <h3 class="text-lg font-semibold">AI Persona Builder</h3>
+          <p class="text-sm text-muted mt-1">
+            Step {{ step }} of 4 — {{ {
+              1: 'Sources',
+              2: 'Indexing',
+              3: 'Generating DNA',
+              4: 'Review & save',
+            }[step] }}
+          </p>
+        </div>
+        <UButton
+          label="Cancel"
+          variant="ghost"
+          color="neutral"
+          size="sm"
+          @click="cancel"
+        />
+      </div>
+    </template>
+
+    <!-- Progress indicator -->
+    <div class="flex items-center gap-2 mb-6">
+      <div
+        v-for="s in [1, 2, 3, 4] as Step[]"
+        :key="s"
+        class="flex-1 h-1 rounded-full"
+        :class="s <= step ? 'bg-primary' : 'bg-muted/30'"
+      />
+    </div>
+
+    <!-- Step 1: Sources -->
+    <div v-if="step === 1" class="space-y-4">
+      <UFormField label="Person name" required>
+        <UInput
+          v-model="name"
+          placeholder="e.g. Alex Hormozi"
+          size="lg"
+          class="w-full"
+        />
+      </UFormField>
+
+      <UFormField label="Source label (optional)" help="How this person should appear in the persona's source field. Defaults to the name above.">
+        <UInput
+          v-model="sourceLabel"
+          placeholder="e.g. Alex Hormozi — $100M Offers / $100M Leads"
+          class="w-full"
+        />
+      </UFormField>
+
+      <UFormField
+        label="Sources (one URL per line)"
+        help="YouTube videos, articles, PDFs, blog posts about this person. The builder will search the indexed chunks and synthesise their behavioural DNA. Up to 50 sources per batch."
+      >
+        <UTextarea
+          v-model="sources"
+          :rows="6"
+          placeholder="https://www.youtube.com/watch?v=...&#10;https://example.com/article&#10;https://example.com/paper.pdf"
+          class="w-full font-mono text-sm"
+          :disabled="skipIngest"
+        />
+      </UFormField>
+
+      <div class="flex items-center justify-between text-xs text-muted">
+        <span>{{ sourceLineCount }} source{{ sourceLineCount === 1 ? '' : 's' }} detected</span>
+        <UCheckbox
+          v-model="skipIngest"
+          label="Skip ingest — content for this person is already in the knowledge base"
+        />
+      </div>
+
+      <div class="flex justify-end gap-2 pt-4">
+        <UButton
+          :label="skipIngest ? 'Generate from existing knowledge' : `Index ${sourceLineCount} source${sourceLineCount === 1 ? '' : 's'} & build`"
+          icon="i-lucide-arrow-right"
+          :disabled="!name.trim() || (!skipIngest && sourceLineCount === 0) || sourceLineCount > 50"
+          size="md"
+          @click="startIngest"
+        />
+      </div>
+      <p v-if="sourceLineCount > 50" class="text-xs text-red-400">
+        Over the 50-source cap. Trim the list before continuing.
+      </p>
+    </div>
+
+    <!-- Step 2: Ingest progress -->
+    <div v-else-if="step === 2" class="space-y-4">
+      <p class="text-sm text-muted">
+        Indexing {{ ingestJobs.length }} source{{ ingestJobs.length === 1 ? '' : 's' }} into the knowledge base.
+        This auto-advances when complete.
+      </p>
+      <div class="space-y-2">
+        <div
+          v-for="(job, idx) in ingestJobs"
+          :key="idx"
+          class="rounded-lg border border-default p-3"
+        >
+          <div class="flex items-center gap-3">
+            <UIcon
+              :name="{
+                queued: 'i-lucide-clock',
+                processing: 'i-lucide-loader-2 animate-spin',
+                completed: 'i-lucide-check-circle',
+                failed: 'i-lucide-x-circle',
+              }[job.status]"
+              :class="{
+                queued: 'text-muted',
+                processing: 'text-primary',
+                completed: 'text-green-500',
+                failed: 'text-red-500',
+              }[job.status]"
+              class="size-4 shrink-0"
+            />
+            <div class="flex-1 min-w-0">
+              <p class="text-sm font-mono truncate">{{ job.source }}</p>
+              <UProgress
+                v-if="job.status === 'processing' || job.status === 'queued'"
+                :value="job.progress"
+                :max="100"
+                size="xs"
+                class="mt-1"
+              />
+              <p v-if="job.error" class="text-xs text-red-400 mt-1">{{ job.error }}</p>
+            </div>
+            <span class="text-xs text-muted">{{ job.progress }}%</span>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Step 3: Building -->
+    <div v-else-if="step === 3" class="space-y-4">
+      <div v-if="building" class="flex flex-col items-center gap-4 py-12">
+        <UIcon name="i-lucide-loader-2" class="size-12 animate-spin text-primary" />
+        <p class="text-sm text-muted">
+          Reading indexed chunks about <strong>{{ name }}</strong>…
+        </p>
+        <p class="text-xs text-muted">
+          The builder searches the vector store, joins the top chunks, and asks the configured LLM to extract a behavioural-DNA persona.
+        </p>
+      </div>
+      <div v-else-if="buildError" class="rounded-lg border border-red-500/20 bg-red-500/5 p-4">
+        <div class="flex items-start gap-3">
+          <UIcon name="i-lucide-alert-circle" class="size-5 text-red-500 mt-0.5 shrink-0" />
+          <div class="flex-1">
+            <p class="text-sm font-medium text-red-400">Build failed</p>
+            <p class="text-xs text-muted mt-1">{{ buildError }}</p>
+          </div>
+        </div>
+        <div class="flex gap-2 mt-3">
+          <UButton label="Retry" variant="outline" size="sm" @click="runBuild" />
+          <UButton label="Back to sources" variant="ghost" size="sm" @click="backToStep1" />
+        </div>
+      </div>
+    </div>
+
+    <!-- Step 4: Review & save -->
+    <div v-else-if="step === 4 && draft" class="space-y-4">
+      <div class="rounded-lg border border-green-500/20 bg-green-500/5 p-3">
+        <p class="text-sm text-green-400">
+          <UIcon name="i-lucide-sparkles" class="size-4 inline" />
+          Built from <strong>{{ chunksUsed }}</strong> knowledge chunk{{ chunksUsed === 1 ? '' : 's' }}. Edit any field below before saving.
+        </p>
+      </div>
+
+      <fieldset class="space-y-3">
+        <legend class="text-xs font-bold uppercase tracking-widest text-muted mb-2">Identity</legend>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-3">
+          <UFormField label="Name">
+            <UInput v-model="draft.name" class="w-full" />
+          </UFormField>
+          <UFormField label="Title">
+            <UInput v-model="draft.title" class="w-full" />
+          </UFormField>
+        </div>
+        <UFormField label="Tagline">
+          <UInput v-model="draft.tagline" class="w-full" />
+        </UFormField>
+      </fieldset>
+
+      <fieldset class="space-y-3">
+        <legend class="text-xs font-bold uppercase tracking-widest text-muted mb-2">Behavioural DNA</legend>
+        <div class="grid grid-cols-2 md:grid-cols-4 gap-3">
+          <UFormField label="MBTI">
+            <UInput v-model="draft.mbti" class="w-full" />
+          </UFormField>
+          <UFormField label="DISC primary">
+            <UInput v-model="draft.disc.primary" class="w-full" />
+          </UFormField>
+          <UFormField label="Enneagram type">
+            <UInput v-model.number="draft.enneagram.type" type="number" :min="1" :max="9" class="w-full" />
+          </UFormField>
+          <UFormField label="Enneagram wing">
+            <UInput v-model.number="draft.enneagram.wing" type="number" :min="1" :max="9" class="w-full" />
+          </UFormField>
+        </div>
+      </fieldset>
+
+      <fieldset class="space-y-3">
+        <legend class="text-xs font-bold uppercase tracking-widest text-muted mb-2">Knowledge</legend>
+        <UFormField label="Mental models" help="comma-separated">
+          <UInput
+            :model-value="draft.mental_models.join(', ')"
+            @update:model-value="(v: string) => draft && (draft.mental_models = v.split(',').map(s => s.trim()).filter(Boolean))"
+            class="w-full"
+          />
+        </UFormField>
+        <UFormField label="Expertise domains" help="comma-separated">
+          <UInput
+            :model-value="draft.expertise_domains.join(', ')"
+            @update:model-value="(v: string) => draft && (draft.expertise_domains = v.split(',').map(s => s.trim()).filter(Boolean))"
+            class="w-full"
+          />
+        </UFormField>
+      </fieldset>
+
+      <fieldset class="space-y-3">
+        <legend class="text-xs font-bold uppercase tracking-widest text-muted mb-2">Save options</legend>
+        <UCheckbox
+          v-model="saveAndClone"
+          label="Also clone to an agent immediately"
+        />
+        <div v-if="saveAndClone" class="grid grid-cols-2 gap-3 pl-6">
+          <UFormField label="Department">
+            <USelect v-model="cloneDept" :items="departmentOptions" class="w-full" />
+          </UFormField>
+          <UFormField label="Tier">
+            <USelect v-model="cloneTier" :items="tierOptions" class="w-full" />
+          </UFormField>
+        </div>
+      </fieldset>
+
+      <div class="flex justify-end gap-2 pt-4">
+        <UButton label="Back" variant="ghost" @click="backToStep1" />
+        <UButton
+          :label="saveAndClone ? 'Save & clone' : 'Save persona'"
+          icon="i-lucide-check"
+          :loading="saving"
+          @click="savePersona"
+        />
+      </div>
+    </div>
+  </UCard>
+</template>

package/dashboard/app/pages/personas.vue

@@ -9,8 +9,30 @@ const { data, status, error, refresh } = fetchApi<{ personas: Persona[]; total:
 
 const personas = computed(() => data.value?.personas ?? [])
 
-// --- Form visibility ---
-const showForm = ref(false)
+// --- Creation mode ---
+// PR62 v2.79.0 — three modes: list (default), wizard (AI builder), manual.
+// The wizard is the new primary path; manual stays as fallback for
+// operators who want to type every DNA field by hand.
+type CreateMode = 'list' | 'wizard' | 'manual'
+const createMode = ref<CreateMode>('list')
+const showForm = computed(() => createMode.value === 'manual')
+
+function startWizard() {
+  createMode.value = 'wizard'
+}
+
+function startManual() {
+  createMode.value = 'manual'
+}
+
+function cancelCreation() {
+  createMode.value = 'list'
+}
+
+async function onWizardComplete() {
+  createMode.value = 'list'
+  await refresh()
+}
 
 // --- Form state ---
 function defaultForm() {
@@ -216,11 +238,29 @@ function discColor(disc: string): string {
 
         <template #right>
           <UButton
-            :label="showForm ? 'Cancel' : 'New Persona'"
-            :icon="showForm ? 'i-lucide-x' : 'i-lucide-plus'"
-            :variant="showForm ? 'ghost' : 'solid'"
+            v-if="createMode === 'list'"
+            label="AI Builder"
+            icon="i-lucide-sparkles"
+            color="primary"
+            size="sm"
+            @click="startWizard"
+          />
+          <UButton
+            v-if="createMode === 'list'"
+            label="Manual"
+            icon="i-lucide-plus"
+            variant="outline"
+            size="sm"
+            class="ml-2"
+            @click="startManual"
+          />
+          <UButton
+            v-else
+            label="Back to list"
+            icon="i-lucide-arrow-left"
+            variant="ghost"
             size="sm"
-            @click="showForm = !showForm"
+            @click="cancelCreation"
           />
         </template>
       </UDashboardNavbar>
@@ -242,7 +282,15 @@ function discColor(disc: string): string {
 
       <!-- Content -->
       <template v-else>
-        <!-- Create Persona Form -->
+        <!-- PR62: AI Persona Wizard -->
+        <PersonaWizard
+          v-if="createMode === 'wizard'"
+          class="mb-8"
+          @completed="onWizardComplete"
+          @cancelled="cancelCreation"
+        />
+
+        <!-- Manual create form (legacy / fallback) -->
         <UCard v-if="showForm" class="mb-8">
           <form @submit.prevent="createPersona" class="space-y-8 p-2">
             <!-- Identity -->

package/departments/ops/skills/update/SKILL.md

@@ -21,15 +21,31 @@ Hybrid sync engine: Python handles deterministic operations (MCPs, settings, des
 
 ## Orchestration (Summary)
 
-1. **Phases 1–3 + 5 (deterministic, Python):** Run the engine:
+1. **One-stop: npm refresh + engine (PR61 v2.78.0 orchestrator).**
    ```bash
-   cd $ARKAOS_ROOT && python -m core.sync.engine --home ~/.arkaos --skills ~/.claude/skills --output json
+   cd $ARKAOS_ROOT && python -m core.sync.update_orchestrator --home ~/.arkaos --skills ~/.claude/skills --output json
    ```
-   Handles manifest, discovery, MCP sync, settings sync, descriptors, and writes `~/.arkaos/sync-state.json`.
+   The orchestrator detects whether the running ArkaOS is behind npm
+   latest. When stale, it shells out to `npx arkaos@latest update`
+   first so the sync engine below reads fresh code; when current, it
+   skips straight to the engine. Either way it runs the
+   deterministic engine (manifest, discovery, MCP sync, settings
+   sync, descriptors, content, agents) and writes
+   `~/.arkaos/sync-state.json`.
+
+   Probe is cached for 1 hour in `~/.arkaos/npm-latest.cache.json`
+   to keep repeat runs cheap. Offline / `npx` missing → orchestrator
+   silently skips the npm step and falls through to the engine.
+
+   Fallback (no orchestrator): the underlying engine still runs the
+   same way via `python -m core.sync.engine ...` for callers that
+   don't need the version-drift gate.
 
 2. **Phase 4 (intelligent, AI subagent):** After the engine completes, dispatch ONE subagent with the engine's JSON report + the feature registry (`core/sync/features/*.yaml`). The subagent injects/removes feature sections in each `~/.claude/skills/arka-{ecosystem}/SKILL.md` while preserving all custom content.
 
-3. **Report:** Display the formatted summary returned by the engine.
+3. **Report:** Display the formatted summary returned by the engine,
+   plus `installed_version_before` / `latest_version_seen` from the
+   orchestrator so the operator sees what got refreshed.
 
 ## Error Handling (Summary)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "2.77.0",
+  "version": "2.79.0",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "2.77.0"
+version = "2.79.0"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}