@foggy-projects/deepseek-harness-plugin 0.4.0-beta.2 → 0.4.0-beta.4

package/README.md

@@ -8,7 +8,7 @@ only when the user selects **Initialize Foggy**.
 ## Local beta installation
 
 ```powershell
-dsh plugin --profile web add --workspace-root ./foggy-projects-deepseek-harness-plugin-0.4.0-beta.2.tgz
+dsh plugin --profile web add --workspace-root ./foggy-projects-deepseek-harness-plugin-0.4.0-beta.4.tgz
 ```
 
 Restart `dsh web`, open Settings → Plugins → Foggy Data Analysis, and initialize
@@ -27,6 +27,21 @@ asset-cache directories. Neither variable is required for a normal install.
 Database credentials are deliberately outside the ordinary DSH settings
 document. The database and semantic-layer wizard is the next Bundle milestone.
 
+## Managed workspace contract
+
+Initialization writes a non-secret discovery document at
+`.foggy/deepseek-harness/context.json` in the selected project. It points agents
+to the authoritative global install state, the managed CLI's absolute command,
+the Runtime state, and the two workspace Skills. The managed CLI is intentionally
+isolated and does not need to be on `PATH`.
+
+Both `foggy-deepseek-onboarding` and `foggy-ai-analysis` carry a
+`.foggy-managed-skill.json` marker. **Re-download / Repair** verifies their
+managed content, backs up a modified or outdated Skill under
+`.foggy/onboarding-backups`, restores missing content, and regenerates the
+project context. If a Skill is restored while Harness is already running, start
+a new task or restart Harness so its Skill registry can reload it.
+
 ## Linux and WSL2 experience
 
 Ubuntu and WSL2 users can use the checked-in preflighted installer under

package/experience/linux/prepare.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 DSH_VERSION="0.1.1-rc.2"
 PNPM_VERSION="11.7.0"
-PLUGIN_VERSION="0.4.0-beta.2"
+PLUGIN_VERSION="0.4.0-beta.4"
 PLUGIN_REF="v${PLUGIN_VERSION}"
 PLUGIN_REPOSITORY="https://github.com/foggy-projects/foggy-deepseek-harness-plugin.git"
 

package/lib/client.js

@@ -41,6 +41,8 @@ window.__ModuleLoader__.load({
       cli: 'CLI',
       launcher: 'Launcher',
       analysisSkill: '分析 Skill',
+      onboardingSkill: '引导 Skill',
+      projectContext: '项目安装上下文',
       python: 'Python',
       java: 'Java',
       installed: '已安装',
@@ -52,6 +54,15 @@ window.__ModuleLoader__.load({
       start: '启动 Runtime',
       stop: '停止 Runtime',
       working: '操作进行中…',
+      progressWorking: '正在初始化 Foggy…',
+      progressPreflight: '检查运行环境',
+      progressCli: '准备 CLI',
+      progressLauncher: '准备 Launcher',
+      progressAnalysis: '准备分析 Skill',
+      progressSkills: '安装工作区 Skills',
+      progressState: '写入安装状态',
+      progressComplete: '初始化完成',
+      progressFiles: '文件',
       accepted: '操作已开始；页面会自动刷新状态。',
       actionFailed: '操作失败',
       roots: '本地目录',
@@ -59,8 +70,9 @@ window.__ModuleLoader__.load({
       dataRoot: '数据目录',
       runtimeUrl: 'Runtime 地址',
       projectRoot: 'Skill 目标工作区',
+      contextPath: '对话发现文件',
       nextTitle: '后续配置',
-      nextCopy: 'Runtime 启动成功后，将继续进入数据库连接与语义层向导。数据库密码不会写入 DSH 普通设置。',
+      nextCopy: '对话会从项目内固定的 context.json 读取 CLI、Runtime 与 Skill 安装状态，不再依赖 PATH 猜测。Runtime 启动成功后，将继续进入数据库连接与语义层向导。',
       beta: 'Beta',
     }
 
@@ -79,6 +91,8 @@ window.__ModuleLoader__.load({
       cli: 'CLI',
       launcher: 'Launcher',
       analysisSkill: 'Analysis Skill',
+      onboardingSkill: 'Onboarding Skill',
+      projectContext: 'Project install context',
       python: 'Python',
       java: 'Java',
       installed: 'Installed',
@@ -90,6 +104,15 @@ window.__ModuleLoader__.load({
       start: 'Start Runtime',
       stop: 'Stop Runtime',
       working: 'Operation in progress…',
+      progressWorking: 'Initializing Foggy…',
+      progressPreflight: 'Checking prerequisites',
+      progressCli: 'Preparing CLI',
+      progressLauncher: 'Preparing Launcher',
+      progressAnalysis: 'Preparing analysis Skill',
+      progressSkills: 'Installing workspace Skills',
+      progressState: 'Writing install state',
+      progressComplete: 'Initialization complete',
+      progressFiles: 'files',
       accepted: 'The operation started; this page will refresh automatically.',
       actionFailed: 'Operation failed',
       roots: 'Local directories',
@@ -97,8 +120,9 @@ window.__ModuleLoader__.load({
       dataRoot: 'Data',
       runtimeUrl: 'Runtime URL',
       projectRoot: 'Skill target workspace',
+      contextPath: 'Conversation discovery file',
       nextTitle: 'Next configuration',
-      nextCopy: 'After the Runtime starts, the database connection and semantic-layer wizard comes next. Database passwords are never stored in ordinary DSH settings.',
+      nextCopy: 'Conversations discover the installed CLI, Runtime, and Skills from the fixed project context.json instead of guessing from PATH. After Runtime starts, the database connection and semantic-layer wizard comes next.',
       beta: 'Beta',
     }
 
@@ -110,6 +134,7 @@ window.__ModuleLoader__.load({
       .foggy-state{display:flex;align-items:center;gap:8px;font-size:14px;font-weight:600}.foggy-dot{width:9px;height:9px;border-radius:50%;background:var(--dsw-alias-label-tertiary)}.foggy-dot[data-state=ready],.foggy-dot[data-state=running]{background:var(--dsw-alias-state-success-primary)}.foggy-dot[data-state=degraded]{background:var(--dsw-alias-state-error-primary)}
       .foggy-actions{display:flex;gap:8px;flex-wrap:wrap}.foggy-button{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);font:inherit;border-radius:8px;padding:7px 12px;cursor:pointer}.foggy-button:hover{background:var(--dsw-alias-interactive-bg-hover)}.foggy-button:disabled{opacity:.55;cursor:not-allowed}.foggy-button-primary{border-color:var(--dsw-alias-state-business-primary);background:var(--dsw-alias-state-business-primary);color:white}
       .foggy-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}.foggy-card{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);border-radius:10px;padding:13px 14px}.foggy-card-head{display:flex;justify-content:space-between;gap:8px}.foggy-card strong{font-size:13px}.foggy-badge{font-size:11px;color:var(--dsw-alias-label-secondary)}.foggy-card code{display:block;margin-top:8px;color:var(--dsw-alias-label-tertiary);font-size:11px;overflow-wrap:anywhere}
+      .foggy-progress{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);border-radius:10px;padding:13px 14px}.foggy-progress-head{display:flex;align-items:center;justify-content:space-between;gap:12px;font-size:13px}.foggy-progress-head strong{font-weight:600}.foggy-progress-percent{color:var(--dsw-alias-label-secondary);font-variant-numeric:tabular-nums}.foggy-progress-track{height:8px;margin-top:10px;border-radius:999px;background:var(--dsw-alias-bg-layer-1);overflow:hidden}.foggy-progress-fill{height:100%;border-radius:inherit;background:var(--dsw-alias-state-business-primary);transition:width .25s ease}.foggy-progress-meta{display:flex;justify-content:space-between;gap:12px;margin-top:8px;color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px}.foggy-progress-file{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
       .foggy-message{margin:0;font-size:13px;line-height:20px;color:var(--dsw-alias-label-secondary)}.foggy-message[data-error=true]{color:var(--dsw-alias-state-error-primary)}.foggy-paths,.foggy-next{border-top:1px solid var(--dsw-alias-border-l2);padding-top:14px}.foggy-paths h4,.foggy-next h4{margin:0 0 8px;font-size:13px}.foggy-paths dl{display:grid;grid-template-columns:100px minmax(0,1fr);gap:6px 10px;margin:0}.foggy-paths dt{color:var(--dsw-alias-label-tertiary);font-size:12px}.foggy-paths dd{margin:0;min-width:0;overflow-wrap:anywhere;font-family:var(--ds-font-family-code);font-size:11px}.foggy-next p{margin:0;color:var(--dsw-alias-label-secondary);font-size:13px;line-height:20px}
       @media (width<=680px){.foggy-grid{grid-template-columns:minmax(0,1fr)}}
     `
@@ -146,6 +171,52 @@ window.__ModuleLoader__.load({
       })
     }
 
+    function progressPanel(progress, t) {
+      if (!progress) return null
+      const percent = Math.max(0, Math.min(100, Number(progress.percent) || 0))
+      const phaseKeys = {
+        preflight: 'progressPreflight',
+        cli: 'progressCli',
+        launcher: 'progressLauncher',
+        'analysis-skill': 'progressAnalysis',
+        'workspace-skills': 'progressSkills',
+        state: 'progressState',
+        complete: 'progressComplete',
+      }
+      const phase = t(phaseKeys[progress.phase] || 'progressWorking')
+      const step = progress.step?.index && progress.step?.total
+        ? `${progress.step.index}/${progress.step.total}`
+        : ''
+      const files = progress.files?.total
+        ? `${progress.files.completed || 0}/${progress.files.total} ${t('progressFiles')}`
+        : ''
+      return jsxs('div', {
+        className: 'foggy-progress',
+        role: 'status',
+        'aria-live': 'polite',
+        children: [
+          jsxs('div', { className: 'foggy-progress-head', children: [
+            jsx('strong', { children: progress.message || phase }),
+            jsx('span', { className: 'foggy-progress-percent', children: `${percent}%` }),
+          ] }),
+          jsx('div', {
+            className: 'foggy-progress-track',
+            role: 'progressbar',
+            'aria-valuemin': 0,
+            'aria-valuemax': 100,
+            'aria-valuenow': percent,
+            'aria-label': phase,
+            children: jsx('div', { className: 'foggy-progress-fill', style: { width: `${percent}%` } }),
+          }),
+          jsxs('div', { className: 'foggy-progress-meta', children: [
+            jsx('span', { children: phase }),
+            jsx('span', { children: [step, files].filter(Boolean).join(' · ') }),
+          ] }),
+          progress.currentFile ? jsx('div', { className: 'foggy-progress-meta foggy-progress-file', title: progress.currentFile, children: progress.currentFile }) : null,
+        ],
+      })
+    }
+
     function FoggySettingsTab({ api, t }) {
       const [view, setView] = useState({ phase: 'loading', status: null, message: '', error: false })
 
@@ -188,6 +259,7 @@ window.__ModuleLoader__.load({
       const operationError = status.operation?.state === 'failed'
         ? status.operation.error || status.operation.result?.error?.message || t('actionFailed')
         : ''
+      const progress = busy ? progressPanel(status.operation?.progress, t) : null
       const stateLabels = { 'not-installed': 'notInstalled', degraded: 'degraded', ready: 'ready', running: 'running' }
       return jsxs('section', { className: 'foggy-settings', children: [
         jsxs('div', { className: 'foggy-hero', children: [
@@ -198,12 +270,13 @@ window.__ModuleLoader__.load({
           jsxs('div', { className: 'foggy-state', children: [jsx('span', { className: 'foggy-dot', 'data-state': status.state }), jsx('span', { children: t(stateLabels[status.state] || 'notInstalled') })] }),
           jsxs('div', { className: 'foggy-actions', children: [
             jsx('button', { className: 'foggy-button', type: 'button', disabled: busy, onClick: refresh, children: t('refresh') }),
-            !status.installed ? jsx('button', { className: 'foggy-button foggy-button-primary', type: 'button', disabled: busy, onClick: () => run('initialize'), children: t('initialize') }) : null,
-            status.installed ? jsx('button', { className: 'foggy-button', type: 'button', disabled: busy, onClick: () => run('repair'), children: t('repair') }) : null,
+            status.state === 'not-installed' ? jsx('button', { className: 'foggy-button foggy-button-primary', type: 'button', disabled: busy, onClick: () => run('initialize'), children: t('initialize') }) : null,
+            status.state !== 'not-installed' ? jsx('button', { className: 'foggy-button', type: 'button', disabled: busy, onClick: () => run('repair'), children: t('repair') }) : null,
             status.installed && !status.running && status.components.java.available ? jsx('button', { className: 'foggy-button foggy-button-primary', type: 'button', disabled: busy, onClick: () => run('runtimeStart'), children: t('start') }) : null,
             status.running ? jsx('button', { className: 'foggy-button', type: 'button', disabled: busy, onClick: () => run('runtimeStop'), children: t('stop') }) : null,
           ] }),
         ] }),
+        progress,
         busy || operationError || view.message ? jsx('p', { className: 'foggy-message', 'data-error': operationError || view.error ? 'true' : undefined, children: busy ? t('working') : operationError || view.message }) : null,
         jsxs('div', { className: 'foggy-grid', children: [
           componentCard(t('python'), status.components.python, 'tool', t),
@@ -211,6 +284,8 @@ window.__ModuleLoader__.load({
           componentCard(t('cli'), status.components.cli, 'runtime', t),
           componentCard(t('launcher'), status.components.launcher, 'runtime', t),
           componentCard(t('analysisSkill'), status.components.analysisSkill, 'runtime', t),
+          componentCard(t('onboardingSkill'), status.components.onboardingSkill, 'runtime', t),
+          componentCard(t('projectContext'), status.components.projectContext, 'runtime', t),
         ] }),
         jsxs('div', { className: 'foggy-paths', children: [
           jsx('h4', { children: t('roots') }),
@@ -218,6 +293,7 @@ window.__ModuleLoader__.load({
             jsx('dt', { children: t('installRoot') }), jsx('dd', { children: status.roots.installRoot }),
             jsx('dt', { children: t('dataRoot') }), jsx('dd', { children: status.roots.dataRoot }),
             jsx('dt', { children: t('projectRoot') }), jsx('dd', { children: status.projectRoot }),
+            jsx('dt', { children: t('contextPath') }), jsx('dd', { children: status.contextPath }),
             status.runtimeUrl ? jsx('dt', { children: t('runtimeUrl') }) : null,
             status.runtimeUrl ? jsx('dd', { children: status.runtimeUrl }) : null,
           ] }),

package/lib/index.js

@@ -46,6 +46,14 @@ async function readJson(path) {
   return JSON.parse(await readFile(path, 'utf8'))
 }
 
+async function readOptionalJson(path) {
+  try {
+    return await readJson(path)
+  } catch {
+    return null
+  }
+}
+
 async function commandVersion(command, args) {
   try {
     const { stdout, stderr } = await execFileAsync(command, args, {
@@ -121,8 +129,11 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
 
   async status() {
     const roots = defaultRoots()
+    const projectRoot = process.env.FOGGY_PROJECT_ROOT || process.cwd()
     const statePath = join(roots.installRoot, 'install-state.json')
     const runtimeStatePath = join(roots.dataRoot, 'runtime-state.json')
+    const progressPath = join(roots.dataRoot, 'operation-progress.json')
+    const contextPath = join(projectRoot, '.foggy', 'deepseek-harness', 'context.json')
     const manifest = await readJson(versionsFile)
     let pythonProbe
     try {
@@ -134,10 +145,16 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
     const java = compatible(await commandVersion(process.env.JAVA_EXE || 'java', ['-version']), '17.0')
     let state = null
     let runtime = null
+    let context = null
     try { state = await readJson(statePath) } catch {}
     try { runtime = await readJson(runtimeStatePath) } catch {}
+    try { context = await readJson(contextPath) } catch {}
     const cliPath = state?.cli?.command
     const launcherPath = state?.launcher?.path
+    const analysisSkillPath = state?.skills?.analysis?.path || join(projectRoot, '.agents', 'skills', 'foggy-ai-analysis')
+    const onboardingSkillPath = state?.skills?.onboarding?.path || join(projectRoot, '.agents', 'skills', 'foggy-deepseek-onboarding')
+    const analysisMarker = await readOptionalJson(join(analysisSkillPath, '.foggy-managed-skill.json'))
+    const onboardingMarker = await readOptionalJson(join(onboardingSkillPath, '.foggy-managed-skill.json'))
     const components = {
       python,
       java,
@@ -150,12 +167,53 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
         version: state?.launcher?.version ?? manifest.components.launcher.version,
       },
       analysisSkill: {
-        installed: Boolean(state?.skills?.analysis?.path && await exists(state.skills.analysis.path)),
+        installed: Boolean(
+          await exists(join(analysisSkillPath, 'SKILL.md'))
+          && analysisMarker?.schemaVersion === 'foggy-managed-skill/v1'
+          && analysisMarker?.componentVersion === manifest.components.analysisSkill.version
+        ),
         version: state?.skills?.analysis?.version ?? manifest.components.analysisSkill.version,
       },
+      onboardingSkill: {
+        installed: Boolean(
+          await exists(join(onboardingSkillPath, 'SKILL.md'))
+          && onboardingMarker?.schemaVersion === 'foggy-managed-skill/v1'
+          && onboardingMarker?.packageVersion === manifest.packageVersion
+        ),
+        version: state?.skills?.onboarding?.version ?? state?.packageVersion ?? manifest.packageVersion,
+      },
+      projectContext: {
+        installed: Boolean(
+          context?.schemaVersion === 'foggy-deepseek-harness-context/v1'
+          && context?.packageVersion === manifest.packageVersion
+          && context?.projectRoot === projectRoot
+          && context?.installStatePath === statePath
+        ),
+        version: context?.schemaVersion ?? 'foggy-deepseek-harness-context/v1',
+      },
     }
-    const installed = components.cli.installed && components.launcher.installed && components.analysisSkill.installed
+    const installed = components.cli.installed
+      && components.launcher.installed
+      && components.analysisSkill.installed
+      && components.onboardingSkill.installed
+      && components.projectContext.installed
     const running = Boolean(runtime && processRunning(Number(runtime.pid)))
+    const progress = await readOptionalJson(progressPath)
+    let operation = operationView(this.operation)
+    if (operation.state === 'running' && progress?.operationId === operation.id) {
+      operation = { ...operation, progress }
+    } else if (!this.operation && progress?.state === 'running' && progress.operationId) {
+      operation = {
+        id: progress.operationId,
+        kind: progress.kind || 'initialize',
+        state: 'running',
+        startedAt: progress.startedAt || null,
+        finishedAt: null,
+        result: null,
+        error: null,
+        progress,
+      }
+    }
     return {
       success: true,
       packageVersion: manifest.packageVersion,
@@ -164,9 +222,10 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
       running,
       runtimeUrl: running ? runtime.runtimeUrl ?? null : null,
       roots,
-      projectRoot: process.env.FOGGY_PROJECT_ROOT || process.cwd(),
+      projectRoot,
+      contextPath,
       components,
-      operation: operationView(this.operation),
+      operation,
       next: installed ? (running ? 'configure-database' : 'start-runtime') : 'initialize',
     }
   }
@@ -183,7 +242,7 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
         'create isolated Python environment',
         'download and verify pinned CLI and Launcher assets',
         'install Foggy analysis and onboarding Skills into the workspace',
-        'write local install state',
+        'write global install state and project-relative discovery context',
       ],
       secretsInDshSettings: false,
     }
@@ -211,6 +270,10 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
     }
     const id = `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`
     const args = explicitArgs ?? ['install', '--project-root', process.env.FOGGY_PROJECT_ROOT || process.cwd()]
+    if (!explicitArgs) {
+      const roots = defaultRoots()
+      args.push('--progress-file', join(roots.dataRoot, 'operation-progress.json'), '--operation-id', id, '--operation-kind', kind)
+    }
     if (replaceSkill) args.push('--replace-skill')
     for (const cacheDir of (process.env.FOGGY_ASSET_CACHE_DIRS || '').split(delimiter).filter(Boolean)) {
       args.push('--asset-cache-dir', cacheDir)
@@ -223,6 +286,17 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
       finishedAt: null,
       result: null,
       error: null,
+      progress: !explicitArgs ? {
+        schemaVersion: 'foggy-deepseek-onboarding-progress/v1',
+        operationId: id,
+        kind,
+        state: 'running',
+        phase: 'preflight',
+        message: 'Starting Foggy initialization',
+        currentFile: null,
+        percent: 0,
+        step: { index: 1, total: 6 },
+      } : null,
       promise: null,
     }
     operation.promise = runOnboarding(args)
@@ -230,11 +304,27 @@ export class FoggyIntegrationGateway extends TypertRemoteService {
         operation.state = result.success === false ? 'failed' : 'succeeded'
         operation.result = result
         operation.finishedAt = new Date().toISOString()
+        if (operation.progress) {
+          operation.progress = {
+            ...operation.progress,
+            state: operation.state,
+            phase: operation.state === 'succeeded' ? 'complete' : operation.progress.phase,
+            message: operation.state === 'succeeded' ? 'Foggy initialization completed' : 'Foggy initialization failed',
+            percent: operation.state === 'succeeded' ? 100 : operation.progress.percent,
+          }
+        }
       })
       .catch((error) => {
         operation.state = 'failed'
         operation.error = String(error.message ?? error)
         operation.finishedAt = new Date().toISOString()
+        if (operation.progress) {
+          operation.progress = {
+            ...operation.progress,
+            state: 'failed',
+            message: 'Foggy initialization failed',
+          }
+        }
       })
     this.operation = operation
     return { success: true, accepted: true, operation: operationView(operation) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foggy-projects/deepseek-harness-plugin",
-  "version": "0.4.0-beta.2",
+  "version": "0.4.0-beta.4",
   "description": "Foggy Java data analysis engine integration for DeepSeek Harness",
   "type": "module",
   "main": "./lib/index.js",

package/skills/foggy-deepseek-onboarding/SKILL.md

@@ -7,6 +7,23 @@ description: Install and operate a pinned Foggy CLI-first dev/test environment f
 
 Set up Foggy through shell and `foggy-runtime` CLI. Do not configure Foggy MCP for this local workflow.
 
+## Installed-context gate
+
+Before deciding that Foggy, its CLI, or either Skill is missing, look for the project-relative file
+`.foggy/deepseek-harness/context.json` from the current workspace root:
+
+- Treat a valid `foggy-deepseek-harness-context/v1` document as the discovery pointer to the global
+  install state, absolute managed CLI command, Runtime state, and both installed Skills.
+- Confirm the installation with this Skill's `doctor` wrapper. The absence of `foggy-runtime` from
+  `PATH` is not evidence that the managed CLI is missing; the plugin intentionally installs it in an
+  isolated environment and records its absolute command in the context and install-state files.
+- Do not independently download or reinstall the CLI when valid project context exists. If the
+  context, a managed marker, or a Skill is missing or invalid, ask the user to open the Foggy plugin
+  settings and use **Re-download / Repair**. That operation regenerates context and restores managed
+  Skills, preserving a backup of modified or outdated Skill directories.
+- If the plugin reports ready but this Skill was restored during the current Harness task, tell the
+  user that a new task or Harness restart may be needed for the Skill registry to reload.
+
 ## Mandatory orchestration boundary
 
 For every new-database onboarding session, this Skill is the orchestration authority until
@@ -42,10 +59,11 @@ For every new-database onboarding session, this Skill is the orchestration autho
 
 ## Workflow
 
-1. Run `scripts/doctor.ps1 --project-root <root>` on Windows or
+1. Read `.foggy/deepseek-harness/context.json`, then run `scripts/doctor.ps1 --project-root <root>` on Windows or
    `bash scripts/doctor.sh --project-root <root>` on Linux.
-2. If the pinned CLI, Launcher, or analysis Skill is missing, run the matching `install` script. Use
-   `--dry-run` first when paths or permissions are uncertain.
+2. If the pinned CLI, Launcher, project context, or either managed Skill is missing, use the Foggy
+   plugin's Repair action. Use the matching install script only when the plugin UI is unavailable;
+   use `--dry-run` first when paths or permissions are uncertain.
 3. Run `runtime-start` and require successful `wait-ready` plus `capabilities`. Record engine,
    Runtime API version, schema version, security mode, URL, namespace, PID, and evidence path.
 4. Confirm the project contains `.agents/skills/foggy-ai-analysis/SKILL.md`.

package/skills/foggy-deepseek-onboarding/assets/versions.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "foggy-deepseek-onboarding-versions/v1",
-  "packageVersion": "0.4.0-beta.2",
+  "packageVersion": "0.4.0-beta.4",
   "validatedAt": "2026-08-28",
   "components": {
     "deepseekHarness": {

package/skills/foggy-deepseek-onboarding/scripts/onboarding.py

@@ -25,6 +25,10 @@ import zipfile
 STATE_SCHEMA = "foggy-deepseek-onboarding-install/v1"
 RUNTIME_STATE_SCHEMA = "foggy-deepseek-onboarding-runtime/v1"
 ONBOARDING_STATE_SCHEMA = "foggy-deepseek-onboarding-state/v1"
+CONTEXT_SCHEMA = "foggy-deepseek-harness-context/v1"
+MANAGED_SKILL_SCHEMA = "foggy-managed-skill/v1"
+MANAGED_SKILL_MARKER = ".foggy-managed-skill.json"
+LEGACY_SKILL_MARKER = ".foggy-onboarding-install.json"
 CONNECTION_SCHEMA = "foggy-deepseek-connection/v1"
 SEMANTIC_PLAN_SCHEMA = "foggy-deepseek-semantic-plan/v1"
 PROFILE_PATTERN = re.compile(r"^[a-z0-9][a-z0-9._-]{0,62}$")
@@ -38,6 +42,93 @@ class OnboardingError(RuntimeError):
     pass
 
 
+PROGRESS_SCHEMA = "foggy-deepseek-onboarding-progress/v1"
+ACTIVE_PROGRESS: "ProgressReporter | None" = None
+
+
+class ProgressReporter:
+    total_steps = 6
+
+    def __init__(self, path: str | None, operation_id: str | None, kind: str) -> None:
+        self.path = Path(path).expanduser() if path else None
+        self.operation_id = operation_id
+        self.kind = kind
+        self.started_at = now_utc()
+        self.phase = "preflight"
+        self.step_index = 0
+        self.fraction = 0.0
+        self.message = ""
+        self.current_file: str | None = None
+        self.completed_files: int | None = None
+        self.total_files: int | None = None
+
+    @property
+    def enabled(self) -> bool:
+        return self.path is not None
+
+    def _write(self, state: str, *, finished_at: str | None = None, error: str | None = None) -> None:
+        if not self.path:
+            return
+        bounded_step = max(0, min(self.step_index, self.total_steps))
+        bounded_fraction = max(0.0, min(float(self.fraction), 1.0))
+        percent = 100 if state == "succeeded" else round(((bounded_step + bounded_fraction) / self.total_steps) * 100)
+        payload = {
+            "schemaVersion": PROGRESS_SCHEMA,
+            "operationId": self.operation_id,
+            "kind": self.kind,
+            "state": state,
+            "phase": self.phase,
+            "message": self.message,
+            "currentFile": self.current_file,
+            "percent": percent,
+            "step": {"index": min(bounded_step + 1, self.total_steps), "total": self.total_steps},
+            "startedAt": self.started_at,
+            "updatedAt": now_utc(),
+        }
+        if self.completed_files is not None and self.total_files is not None:
+            payload["files"] = {"completed": self.completed_files, "total": self.total_files}
+        if finished_at:
+            payload["finishedAt"] = finished_at
+        if error:
+            payload["error"] = error
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_json(self.path, payload)
+
+    def update(
+        self,
+        phase: str,
+        step_index: int,
+        message: str,
+        *,
+        fraction: float = 0.0,
+        current_file: str | None = None,
+        completed_files: int | None = None,
+        total_files: int | None = None,
+    ) -> None:
+        self.phase = phase
+        self.step_index = step_index
+        self.fraction = fraction
+        self.message = message
+        self.current_file = current_file
+        self.completed_files = completed_files
+        self.total_files = total_files
+        self._write("running")
+
+    def finish(self) -> None:
+        self.phase = "complete"
+        self.step_index = self.total_steps
+        self.fraction = 0.0
+        self.message = "Foggy initialization completed"
+        self.current_file = None
+        self.completed_files = None
+        self.total_files = None
+        self._write("succeeded", finished_at=now_utc())
+
+    def fail(self, error: object) -> None:
+        self.message = "Foggy initialization failed"
+        self._write("failed", finished_at=now_utc(), error=str(error))
+
+
 def now_utc() -> str:
     return dt.datetime.now(dt.timezone.utc).isoformat()
 
@@ -182,7 +273,18 @@ def cached_asset(name: str, expected: str, cache_dirs: list[Path]) -> Path | Non
     return None
 
 
-def materialize(asset: dict, destination: Path, cache_dirs: list[Path]) -> dict:
+def materialize(
+    asset: dict,
+    destination: Path,
+    cache_dirs: list[Path],
+    *,
+    progress: ProgressReporter | None = None,
+    progress_phase: str = "",
+    progress_step: int = 0,
+    progress_index: int = 0,
+    progress_total: int = 1,
+    progress_message: str = "Downloading and verifying asset",
+) -> dict:
     destination.parent.mkdir(parents=True, exist_ok=True)
     if destination.is_file():
         verify_asset(destination, asset["sha256"])
@@ -196,7 +298,18 @@ def materialize(asset: dict, destination: Path, cache_dirs: list[Path]) -> dict:
         if temporary.exists():
             temporary.unlink()
         try:
-            urllib.request.urlretrieve(asset["url"], temporary)
+            def reporthook(block_count: int, block_size: int, total_size: int) -> None:
+                if progress is None or not progress_phase or total_size <= 0:
+                    return
+                downloaded = min(block_count * block_size, total_size)
+                fraction = (progress_index + downloaded / total_size) / max(progress_total, 1)
+                progress.update(
+                    progress_phase, progress_step, progress_message,
+                    fraction=fraction, current_file=asset["file"],
+                    completed_files=progress_index, total_files=progress_total,
+                )
+
+            urllib.request.urlretrieve(asset["url"], temporary, reporthook=reporthook)
             verify_asset(temporary, asset["sha256"])
             os.replace(temporary, destination)
         finally:
@@ -222,6 +335,145 @@ def atomic_json(path: Path, payload: dict) -> None:
     os.replace(temporary, path)
 
 
+def skill_tree_digest(root: Path) -> str:
+    """Hash managed Skill content while ignoring generated and management files."""
+    digest = hashlib.sha256()
+    ignored_names = {MANAGED_SKILL_MARKER, LEGACY_SKILL_MARKER}
+    files = sorted(
+        path for path in root.rglob("*")
+        if path.is_file()
+        and path.name not in ignored_names
+        and "__pycache__" not in path.parts
+        and path.suffix != ".pyc"
+    )
+    for path in files:
+        relative = path.relative_to(root).as_posix().encode("utf-8")
+        digest.update(len(relative).to_bytes(4, "big"))
+        digest.update(relative)
+        with path.open("rb") as stream:
+            for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(chunk)
+    return digest.hexdigest()
+
+
+def read_skill_marker(destination: Path) -> dict | None:
+    for name in (MANAGED_SKILL_MARKER, LEGACY_SKILL_MARKER):
+        marker = destination / name
+        if marker.is_file():
+            try:
+                payload = json.loads(marker.read_text(encoding="utf-8"))
+                if isinstance(payload, dict):
+                    return payload
+            except (OSError, json.JSONDecodeError):
+                return None
+    return None
+
+
+def managed_skill_status(destination: Path, kind: str, expected_version: str) -> dict:
+    marker = read_skill_marker(destination)
+    present = (destination / "SKILL.md").is_file()
+    actual_digest = skill_tree_digest(destination) if destination.is_dir() else None
+    marker_digest = marker.get("installedDigest") if marker else None
+    managed = bool(
+        marker
+        and marker.get("schemaVersion") == MANAGED_SKILL_SCHEMA
+        and marker.get("kind") == kind
+    )
+    version = marker.get("componentVersion") if marker else None
+    return {
+        "path": str(destination),
+        "present": present,
+        "markerPresent": bool(marker),
+        "managed": managed,
+        "version": version,
+        "versionMatches": version == expected_version,
+        "integrityValid": bool(marker_digest and actual_digest == marker_digest),
+        "valid": bool(present and managed and version == expected_version and marker_digest and actual_digest == marker_digest),
+    }
+
+
+def write_skill_marker(
+    destination: Path,
+    *,
+    kind: str,
+    package_version: str,
+    component_version: str,
+    source_digest: str,
+    archive_sha256: str | None = None,
+) -> dict:
+    marker = {
+        "schemaVersion": MANAGED_SKILL_SCHEMA,
+        "kind": kind,
+        "managedBy": "@foggy-projects/deepseek-harness-plugin",
+        "packageVersion": package_version,
+        "componentVersion": component_version,
+        "sourceDigest": source_digest,
+        "installedDigest": skill_tree_digest(destination),
+        "installedAt": now_utc(),
+    }
+    if archive_sha256:
+        marker["archiveSha256"] = archive_sha256
+    atomic_json(destination / MANAGED_SKILL_MARKER, marker)
+    legacy = destination / LEGACY_SKILL_MARKER
+    if legacy.is_file():
+        legacy.unlink()
+    return marker
+
+
+def backup_skill(destination: Path, project_root: Path) -> Path:
+    backup_root = project_root / ".foggy" / "onboarding-backups"
+    backup_root.mkdir(parents=True, exist_ok=True)
+    backup = backup_root / f"{destination.name}-{dt.datetime.now().strftime('%Y%m%d-%H%M%S-%f')}"
+    shutil.move(str(destination), str(backup))
+    return backup
+
+
+def project_context_path(project_root: Path) -> Path:
+    return project_root / ".foggy" / "deepseek-harness" / "context.json"
+
+
+def project_relative(path: Path, project_root: Path) -> str:
+    try:
+        return path.resolve(strict=False).relative_to(project_root.resolve(strict=False)).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def write_project_context(state: dict) -> Path:
+    project_root = normalized(state["projectRoot"])
+    install_root = normalized(state["installRoot"])
+    data_root = normalized(state["dataRoot"])
+    context_path = project_context_path(project_root)
+    skills = {}
+    for kind in ("onboarding", "analysis"):
+        item = state["skills"][kind]
+        skill_path = normalized(item["path"])
+        skills[kind] = {
+            "version": item.get("version"),
+            "path": project_relative(skill_path, project_root),
+            "absolutePath": str(skill_path),
+            "markerPath": project_relative(skill_path / MANAGED_SKILL_MARKER, project_root),
+            "managed": bool(item.get("managed")),
+        }
+    payload = {
+        "schemaVersion": CONTEXT_SCHEMA,
+        "managedBy": "@foggy-projects/deepseek-harness-plugin",
+        "packageVersion": state["packageVersion"],
+        "generatedAt": now_utc(),
+        "projectRoot": str(project_root),
+        "installStatePath": str(install_root / "install-state.json"),
+        "runtimeStatePath": str(data_root / "runtime-state.json"),
+        "operationProgressPath": str(data_root / "operation-progress.json"),
+        "cli": state["cli"],
+        "launcher": state["launcher"],
+        "skills": skills,
+        "securityMode": state["securityMode"],
+        "productionReady": False,
+    }
+    atomic_json(context_path, payload)
+    return context_path
+
+
 def read_json_object(path: Path, label: str) -> dict:
     if not path.is_file():
         raise OnboardingError(f"{label} not found: {path}")
@@ -512,22 +764,16 @@ def safe_extract(zip_path: Path, destination: Path) -> None:
         archive.extractall(destination)
 
 
-def install_analysis_skill(zip_path: Path, project_root: Path, version: str, expected_hash: str, replace: bool) -> dict:
+def install_analysis_skill(
+    zip_path: Path,
+    project_root: Path,
+    version: str,
+    expected_hash: str,
+    package_version: str,
+    replace: bool,
+) -> dict:
     skills_root = project_root / ".agents" / "skills"
     destination = skills_root / "foggy-ai-analysis"
-    marker = destination / ".foggy-onboarding-install.json"
-    if destination.exists():
-        if marker.is_file():
-            installed = json.loads(marker.read_text(encoding="utf-8"))
-            if installed.get("archiveSha256") == expected_hash:
-                return {"path": str(destination), "version": version, "action": "kept-matching"}
-        if not replace:
-            raise OnboardingError(f"Analysis Skill already exists and is not managed at {destination}; rerun with --replace-skill to back it up")
-        backup_root = project_root / ".foggy" / "onboarding-backups"
-        backup_root.mkdir(parents=True, exist_ok=True)
-        backup = backup_root / f"foggy-ai-analysis-{dt.datetime.now().strftime('%Y%m%d-%H%M%S')}"
-        shutil.move(str(destination), str(backup))
-    skills_root.mkdir(parents=True, exist_ok=True)
     with tempfile.TemporaryDirectory(prefix="foggy-skill-") as temporary:
         extract_root = Path(temporary)
         safe_extract(zip_path, extract_root)
@@ -535,21 +781,81 @@ def install_analysis_skill(zip_path: Path, project_root: Path, version: str, exp
         if len(candidates) != 1:
             raise OnboardingError(f"Expected exactly one SKILL.md in analysis Skill archive, found {len(candidates)}")
         source = candidates[0].parent
+        source_digest = skill_tree_digest(source)
+        if destination.exists():
+            installed = read_skill_marker(destination)
+            actual_digest = skill_tree_digest(destination)
+            marker_matches = bool(
+                installed
+                and installed.get("schemaVersion") in (MANAGED_SKILL_SCHEMA, "foggy-installed-skill/v1")
+                and installed.get("archiveSha256") == expected_hash
+                and (installed.get("sourceDigest") or installed.get("installedDigest") or actual_digest) == source_digest
+                and actual_digest == source_digest
+            )
+            if marker_matches:
+                marker = write_skill_marker(
+                    destination,
+                    kind="analysis",
+                    package_version=package_version,
+                    component_version=version,
+                    source_digest=source_digest,
+                    archive_sha256=expected_hash,
+                )
+                return {"path": str(destination), "version": version, "digest": marker["installedDigest"], "managed": True, "action": "kept-matching"}
+            if not replace:
+                raise OnboardingError(f"Analysis Skill is missing, modified, or outdated at {destination}; use the plugin Repair action to back it up and restore it")
+            backup_skill(destination, project_root)
+        skills_root.mkdir(parents=True, exist_ok=True)
         shutil.copytree(source, destination)
-    atomic_json(marker, {"schemaVersion": "foggy-installed-skill/v1", "version": version, "archiveSha256": expected_hash})
-    return {"path": str(destination), "version": version, "action": "installed"}
+    marker = write_skill_marker(
+        destination,
+        kind="analysis",
+        package_version=package_version,
+        component_version=version,
+        source_digest=source_digest,
+        archive_sha256=expected_hash,
+    )
+    return {"path": str(destination), "version": version, "digest": marker["installedDigest"], "managed": True, "action": "installed"}
 
 
-def install_onboarding_skill(project_root: Path) -> dict:
+def install_onboarding_skill(project_root: Path, package_version: str, replace: bool) -> dict:
     destination = project_root / ".agents" / "skills" / "foggy-deepseek-onboarding"
     source = skill_root()
+    source_digest = skill_tree_digest(source)
     if source.resolve() == destination.resolve(strict=False):
-        return {"path": str(destination), "action": "already-running-from-target"}
+        return {"path": str(destination), "version": package_version, "digest": source_digest, "managed": True, "action": "already-running-from-target"}
     if destination.exists():
-        return {"path": str(destination), "action": "kept-existing"}
+        marker = read_skill_marker(destination)
+        actual_digest = skill_tree_digest(destination)
+        if (
+            marker
+            and marker.get("schemaVersion") == MANAGED_SKILL_SCHEMA
+            and marker.get("kind") == "onboarding"
+            and actual_digest == source_digest
+            and marker.get("sourceDigest") in (None, source_digest)
+            and marker.get("installedDigest") in (None, source_digest)
+        ):
+            written = write_skill_marker(
+                destination,
+                kind="onboarding",
+                package_version=package_version,
+                component_version=package_version,
+                source_digest=source_digest,
+            )
+            return {"path": str(destination), "version": package_version, "digest": written["installedDigest"], "managed": True, "action": "kept-matching"}
+        if not replace:
+            raise OnboardingError(f"Onboarding Skill is missing, modified, or outdated at {destination}; use the plugin Repair action to back it up and restore it")
+        backup_skill(destination, project_root)
     destination.parent.mkdir(parents=True, exist_ok=True)
     shutil.copytree(source, destination)
-    return {"path": str(destination), "action": "installed"}
+    marker = write_skill_marker(
+        destination,
+        kind="onboarding",
+        package_version=package_version,
+        component_version=package_version,
+        source_digest=source_digest,
+    )
+    return {"path": str(destination), "version": package_version, "digest": marker["installedDigest"], "managed": True, "action": "installed"}
 
 
 def read_install_state(install_root: Path, required: bool = True) -> dict | None:
@@ -574,6 +880,7 @@ def java_probe() -> dict:
 
 
 def install_command(args: argparse.Namespace) -> dict:
+    global ACTIVE_PROGRESS
     versions = load_versions()
     install_root = normalized(args.install_root or default_install_root())
     data_root = normalized(args.data_root or default_data_root())
@@ -595,6 +902,13 @@ def install_command(args: argparse.Namespace) -> dict:
     }
     if args.dry_run:
         return {"success": True, "dryRun": True, "plan": plan}
+    progress = ProgressReporter(
+        getattr(args, "progress_file", None),
+        getattr(args, "operation_id", None),
+        getattr(args, "operation_kind", "initialize"),
+    )
+    ACTIVE_PROGRESS = progress
+    progress.update("preflight", 0, "Checking prerequisites")
     if sys.version_info < (3, 11):
         raise OnboardingError(f"Python 3.11+ required, got {sys.version.split()[0]}")
     if not project_root.is_dir():
@@ -605,20 +919,37 @@ def install_command(args: argparse.Namespace) -> dict:
     verified: list[dict] = []
 
     cli_component = components["cli"]
-    for role in ("wheel", "checksums"):
-        asset = cli_component[role]
-        verified.append(materialize(asset, downloads / "cli" / asset["file"], cache_dirs))
+    cli_assets = [cli_component[role] for role in ("wheel", "checksums")]
+    for index, asset in enumerate(cli_assets):
+        progress.update(
+            "cli", 1, "Downloading and verifying CLI",
+            fraction=index / len(cli_assets), current_file=asset["file"],
+            completed_files=index, total_files=len(cli_assets),
+        )
+        verified.append(materialize(
+            asset, downloads / "cli" / asset["file"], cache_dirs,
+            progress=progress, progress_phase="cli", progress_step=1,
+            progress_index=index, progress_total=len(cli_assets),
+            progress_message="Downloading and verifying CLI",
+        ))
+        progress.update(
+            "cli", 1, "Downloading and verifying CLI",
+            fraction=(index + 1) / len(cli_assets), current_file=asset["file"],
+            completed_files=index + 1, total_files=len(cli_assets),
+        )
     checksum_lines = (downloads / "cli" / cli_component["checksums"]["file"]).read_text(encoding="utf-8").splitlines()
     checksum_entries = {line.split(maxsplit=1)[1].strip(): line.split(maxsplit=1)[0].lower() for line in checksum_lines if len(line.split(maxsplit=1)) == 2}
     wheel_asset = cli_component["wheel"]
     if checksum_entries.get(wheel_asset["file"]) != wheel_asset["sha256"]:
         raise OnboardingError("Pinned CLI SHA256SUMS does not match the pinned wheel hash")
     if args.skip_cli_install:
+        progress.update("cli", 1, "Using existing CLI", fraction=0.65, current_file="foggy-runtime")
         cli_command = normalized(args.cli_command or shutil.which("foggy-runtime") or "")
         if not cli_command.is_file():
             raise OnboardingError("--skip-cli-install requires --cli-command or foggy-runtime on PATH")
         cli_mode = "external"
     else:
+        progress.update("cli", 1, "Installing CLI", fraction=0.65, current_file="Python virtual environment")
         python_path = venv_python(install_root)
         if not python_path.is_file():
             venv.EnvBuilder(with_pip=True).create(install_root / "venv")
@@ -633,27 +964,66 @@ def install_command(args: argparse.Namespace) -> dict:
         )
         cli_command = venv_cli(install_root)
         cli_mode = "managed-venv"
+    progress.update("cli", 1, "Verifying CLI version", fraction=0.9, current_file="foggy-runtime")
     cli_version = command_result([str(cli_command), "--version"], check=True)
     actual_cli_version = version_tuple(cli_version["stdout"])[:3]
     pinned_cli_version = version_tuple(cli_component["version"])[:3]
     version_matches = actual_cli_version >= pinned_cli_version if cli_mode == "external" else actual_cli_version == pinned_cli_version
     if not version_matches:
         raise OnboardingError(f"Unexpected CLI version: {cli_version['stdout']}")
+    progress.update("cli", 1, "CLI ready", fraction=1.0)
 
     launcher_dir = install_root / "launcher"
-    for asset in components["launcher"]["assets"]:
-        verified.append(materialize(asset, launcher_dir / asset["file"], cache_dirs))
+    launcher_assets = components["launcher"]["assets"]
+    for index, asset in enumerate(launcher_assets):
+        progress.update(
+            "launcher", 2, "Downloading and verifying Launcher",
+            fraction=index / len(launcher_assets), current_file=asset["file"],
+            completed_files=index, total_files=len(launcher_assets),
+        )
+        verified.append(materialize(
+            asset, launcher_dir / asset["file"], cache_dirs,
+            progress=progress, progress_phase="launcher", progress_step=2,
+            progress_index=index, progress_total=len(launcher_assets),
+            progress_message="Downloading and verifying Launcher",
+        ))
+        progress.update(
+            "launcher", 2, "Downloading and verifying Launcher",
+            fraction=(index + 1) / len(launcher_assets), current_file=asset["file"],
+            completed_files=index + 1, total_files=len(launcher_assets),
+        )
     if os.name != "nt":
         (launcher_dir / "start-foggy-runtime.sh").chmod(0o755)
+    progress.update("launcher", 2, "Launcher ready", fraction=1.0)
 
     analysis_assets = components["analysisSkill"]["assets"]
-    for asset in analysis_assets:
-        verified.append(materialize(asset, downloads / "skill" / asset["file"], cache_dirs))
+    for index, asset in enumerate(analysis_assets):
+        progress.update(
+            "analysis-skill", 3, "Downloading and verifying analysis Skill",
+            fraction=index / len(analysis_assets), current_file=asset["file"],
+            completed_files=index, total_files=len(analysis_assets),
+        )
+        verified.append(materialize(
+            asset, downloads / "skill" / asset["file"], cache_dirs,
+            progress=progress, progress_phase="analysis-skill", progress_step=3,
+            progress_index=index, progress_total=len(analysis_assets),
+            progress_message="Downloading and verifying analysis Skill",
+        ))
+        progress.update(
+            "analysis-skill", 3, "Downloading and verifying analysis Skill",
+            fraction=(index + 1) / len(analysis_assets), current_file=asset["file"],
+            completed_files=index + 1, total_files=len(analysis_assets),
+        )
     zip_asset = next(item for item in analysis_assets if item["role"] == "zip")
+    progress.update("analysis-skill", 3, "Installing analysis Skill", fraction=0.9, current_file=zip_asset["file"])
     analysis_skill = install_analysis_skill(
-        downloads / "skill" / zip_asset["file"], project_root, components["analysisSkill"]["version"], zip_asset["sha256"], args.replace_skill
+        downloads / "skill" / zip_asset["file"], project_root, components["analysisSkill"]["version"],
+        zip_asset["sha256"], versions["packageVersion"], args.replace_skill,
     )
-    onboarding_skill = install_onboarding_skill(project_root)
+    progress.update("analysis-skill", 3, "Analysis Skill ready", fraction=1.0)
+    progress.update("workspace-skills", 4, "Installing onboarding Skill", fraction=0.1)
+    onboarding_skill = install_onboarding_skill(project_root, versions["packageVersion"], args.replace_skill)
+    progress.update("workspace-skills", 4, "Workspace Skills ready", fraction=1.0)
     state = {
         "schemaVersion": STATE_SCHEMA,
         "installedAt": now_utc(),
@@ -661,6 +1031,7 @@ def install_command(args: argparse.Namespace) -> dict:
         "installRoot": str(install_root),
         "dataRoot": str(data_root),
         "projectRoot": str(project_root),
+        "contextPath": str(project_context_path(project_root)),
         "cli": {"version": cli_component["version"], "command": str(cli_command), "mode": cli_mode},
         "launcher": {"version": components["launcher"]["version"], "path": str(launcher_dir)},
         "skills": {"onboarding": onboarding_skill, "analysis": analysis_skill},
@@ -668,7 +1039,12 @@ def install_command(args: argparse.Namespace) -> dict:
         "securityMode": versions["defaults"]["securityMode"],
         "productionReady": False,
     }
+    progress.update("state", 5, "Writing install state", fraction=0.2, current_file="install-state.json")
     atomic_json(install_root / "install-state.json", state)
+    progress.update("state", 5, "Writing project context", fraction=0.7, current_file=".foggy/deepseek-harness/context.json")
+    context_path = write_project_context(state)
+    progress.finish()
+    ACTIVE_PROGRESS = None
     return {
         "success": True,
         "schemaVersion": "foggy-deepseek-onboarding-install-result/v1",
@@ -676,6 +1052,7 @@ def install_command(args: argparse.Namespace) -> dict:
         "installRoot": str(install_root),
         "dataRoot": str(data_root),
         "projectRoot": str(project_root),
+        "contextPath": str(context_path),
         "cliVersion": cli_component["version"],
         "launcherVersion": components["launcher"]["version"],
         "analysisSkill": analysis_skill,
@@ -1857,8 +2234,24 @@ def doctor_command(args: argparse.Namespace) -> dict:
             path = launcher_dir / asset["file"]
             launcher_checks.append({"file": asset["file"], "present": path.is_file(), "sha256Valid": path.is_file() and sha256(path) == asset["sha256"]})
     launcher_ok = bool(launcher_checks) and all(item["present"] and item["sha256Valid"] for item in launcher_checks)
-    analysis_skill = project_root / ".agents" / "skills" / "foggy-ai-analysis" / "SKILL.md"
-    onboarding_skill = project_root / ".agents" / "skills" / "foggy-deepseek-onboarding" / "SKILL.md"
+    analysis_skill_root = project_root / ".agents" / "skills" / "foggy-ai-analysis"
+    onboarding_skill_root = project_root / ".agents" / "skills" / "foggy-deepseek-onboarding"
+    analysis_skill = managed_skill_status(analysis_skill_root, "analysis", versions["components"]["analysisSkill"]["version"])
+    onboarding_skill = managed_skill_status(onboarding_skill_root, "onboarding", versions["packageVersion"])
+    context_path = project_context_path(project_root)
+    context = None
+    if context_path.is_file():
+        try:
+            context = json.loads(context_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            context = None
+    context_ok = bool(
+        context
+        and context.get("schemaVersion") == CONTEXT_SCHEMA
+        and context.get("packageVersion") == versions["packageVersion"]
+        and normalized(context.get("projectRoot", "")) == project_root
+        and normalized(context.get("installStatePath", "")) == install_root / "install-state.json"
+    )
     runtime = {"status": "stopped"}
     if state:
         data_root = normalized(state["dataRoot"])
@@ -1872,7 +2265,9 @@ def doctor_command(args: argparse.Namespace) -> dict:
         "java": java_ok,
         "cli": cli_ok,
         "launcher": launcher_ok,
-        "analysisSkill": analysis_skill.is_file(),
+        "analysisSkill": analysis_skill["valid"],
+        "onboardingSkill": onboarding_skill["valid"],
+        "projectContext": context_ok,
     }
     if args.strict_runtime:
         required["runtime"] = runtime["status"] == "running"
@@ -1886,7 +2281,8 @@ def doctor_command(args: argparse.Namespace) -> dict:
         "java": java,
         "cli": cli,
         "launcherAssets": launcher_checks,
-        "skills": {"analysis": str(analysis_skill), "onboarding": str(onboarding_skill), "onboardingPresent": onboarding_skill.is_file()},
+        "skills": {"analysis": analysis_skill, "onboarding": onboarding_skill},
+        "projectContext": {"path": str(context_path), "valid": context_ok},
         "runtime": runtime,
         "environmentPresence": {name: bool(os.environ.get(name)) for name in ("DEEPSEEK_API_KEY", "ALIYUN_TOKEN_PLAN_API_KEY", "FOGGY_RUNTIME_API_AUTH_CODE", "FOGGY_RUNTIME_AUTHORIZATION")},
         "productionReady": False,
@@ -1945,6 +2341,9 @@ def build_parser() -> argparse.ArgumentParser:
     install.add_argument("--replace-skill", action="store_true")
     install.add_argument("--skip-cli-install", action="store_true")
     install.add_argument("--cli-command")
+    install.add_argument("--progress-file")
+    install.add_argument("--operation-id")
+    install.add_argument("--operation-kind", default="initialize")
     install.add_argument("--dry-run", action="store_true")
     install.set_defaults(handler=install_command)
 
@@ -2104,8 +2503,12 @@ def main() -> None:
             exit_code = 1
         emit(result, exit_code)
     except OnboardingError as exc:
+        if ACTIVE_PROGRESS is not None:
+            ACTIVE_PROGRESS.fail(exc)
         emit({"success": False, "error": {"code": "ONBOARDING_ERROR", "message": str(exc)}, "productionReady": False}, 1)
     except Exception as exc:
+        if ACTIVE_PROGRESS is not None:
+            ACTIVE_PROGRESS.fail(exc)
         emit({"success": False, "error": {"code": "UNEXPECTED_ERROR", "message": str(exc)}, "productionReady": False}, 1)