@1mancompany/onemancompany 0.7.73 → 0.7.76

package/frontend/app.js

@@ -32,6 +32,8 @@ class AppController {
     this._viewingBoardProjectId = null;
     // Unread message counts per channel (channelId → count)
     this._unreadCounts = {};
+    // Cached company defaults for candidate hire warnings/choices
+    this._companyLlmDefaults = null;
     // Initialize plugin system before connecting
     window.pluginLoader.init().then(() => {
       this.connect();
@@ -3903,7 +3905,7 @@ class AppController {
       for (const [batchId, batch] of Object.entries(batches)) {
         const candidates = batch.candidates || [];
         if (candidates.length > 0) {
-          this.showCandidateSelection({
+          await this.showCandidateSelection({
             batch_id: batchId,
             candidates,
             roles: batch.roles || [],
@@ -3916,11 +3918,63 @@ class AppController {
     }
   }
 
-  showCandidateSelection(payload) {
+  async _loadCompanyLlmDefaults(force = false) {
+    if (this._companyLlmDefaults && !force) return this._companyLlmDefaults;
+    try {
+      const data = await fetch('/api/settings/api').then(r => r.json());
+      this._companyLlmDefaults = {
+        provider: data.default_provider || 'openrouter',
+        model: data.default_model || '',
+      };
+    } catch (e) {
+      console.warn('Failed to load company LLM defaults for hiring UI:', e);
+      this._companyLlmDefaults = { provider: 'openrouter', model: '' };
+    }
+    return this._companyLlmDefaults;
+  }
+
+  _getCandidateLlmWarning(candidate) {
+    const defaults = this._companyLlmDefaults;
+    if (!defaults) return null;
+    const hosting = candidate.hosting || 'company';
+    if (hosting === 'self' || hosting === 'remote') return null;
+    const talentProvider = candidate.api_provider || 'openrouter';
+    const talentModel = candidate.llm_model || '';
+    const providerDiffers = talentProvider !== defaults.provider;
+    const modelDiffers = Boolean(defaults.model && talentModel && talentModel !== defaults.model);
+    if (!providerDiffers && !modelDiffers) return null;
+    return {
+      talentProvider,
+      talentModel,
+      companyProvider: defaults.provider,
+      companyModel: defaults.model,
+    };
+  }
+
+  _getCandidateConfigChoice(candidateId) {
+    return Boolean(this._candidateHireConfigChoices?.get(candidateId));
+  }
+
+  _setCandidateConfigChoice(candidateId, enabled) {
+    if (!this._candidateHireConfigChoices) this._candidateHireConfigChoices = new Map();
+    this._candidateHireConfigChoices.set(candidateId, Boolean(enabled));
+    if (this._selectedCandidates?.has(candidateId)) {
+      const selected = this._selectedCandidates.get(candidateId);
+      this._selectedCandidates.set(candidateId, {
+        ...selected,
+        use_talent_llm_config: Boolean(enabled),
+      });
+      this._updateBatchBar();
+    }
+  }
+
+  async showCandidateSelection(payload) {
+    await this._loadCompanyLlmDefaults(true);
     this._candidateBatchId = payload.batch_id;
     this._candidateList = payload.candidates || [];
     this._candidateRoles = payload.roles || [];
     this._selectedCandidates = new Map(); // candidateId -> {candidate, role}
+    this._candidateHireConfigChoices = new Map(); // candidateId -> bool
     this._interviewingCandidate = null;
 
     // If no roles structure, wrap flat candidates into a single role group
@@ -3994,6 +4048,10 @@ class AppController {
         const familyLabels = { company: '🧠 LangChain', self: '🤖 Claude', openclaw: '🦞 OpenClaw' };
         const hostingLabel = esc(familyLabels[hosting] || hosting);
         const authLabel = esc(c.auth_method === 'oauth' ? 'OAuth' : 'API Key');
+        const llmWarning = this._getCandidateLlmWarning(c);
+        const warningBadge = llmWarning
+          ? `<div class="card-config-warning" title="${esc(`Company default: ${llmWarning.companyProvider}${llmWarning.companyModel ? ` / ${llmWarning.companyModel}` : ''}\nTalent prefers: ${llmWarning.talentProvider}${llmWarning.talentModel ? ` / ${llmWarning.talentModel}` : ''}`)}">⚠ Different company defaults</div>`
+          : '';
 
         card.innerHTML = `
           <div class="card-inner">
@@ -4009,6 +4067,7 @@ class AppController {
                 <span class="score-label">${scorePct}%</span>
               </div>
               ${reasoning ? `<div class="card-reasoning" title="${esc(reasoning)}">${esc(reasoning.substring(0, 40))}${reasoning.length > 40 ? '...' : ''}</div>` : ''}
+              ${warningBadge}
               <div class="card-cost">${costPer1m} | ${hiringFee}</div>
               <div class="card-hosting">${hostingLabel}</div>
             </div>
@@ -4063,7 +4122,11 @@ class AppController {
       this._selectedCandidates.delete(candidateId);
       cardEl.classList.remove('selected');
     } else {
-      this._selectedCandidates.set(candidateId, { candidate, role });
+      this._selectedCandidates.set(candidateId, {
+        candidate,
+        role,
+        use_talent_llm_config: this._getCandidateConfigChoice(candidateId),
+      });
       cardEl.classList.add('selected');
     }
     this._updateBatchBar();
@@ -4100,6 +4163,21 @@ class AppController {
     const hostingLabel = esc(familyLabels[hosting] || hosting);
     const authLabel = esc(c.auth_method === 'oauth' ? 'OAuth' : 'API Key');
     const reasoning = c.reasoning || '';
+    const llmWarning = this._getCandidateLlmWarning(c);
+    const useTalentConfig = this._getCandidateConfigChoice(candidateId);
+    const warningSection = llmWarning ? `
+      <div class="detail-section">
+        <div class="detail-label">Config Warning</div>
+        <div class="detail-config-warning-box">
+          <div>Company default: <strong>${esc(llmWarning.companyProvider)}${llmWarning.companyModel ? ` / ${esc(llmWarning.companyModel)}` : ''}</strong></div>
+          <div>Talent prefers: <strong>${esc(llmWarning.talentProvider)}${llmWarning.talentModel ? ` / ${esc(llmWarning.talentModel)}` : ''}</strong></div>
+          <div class="detail-config-warning-note">By default this hire keeps the company setting. Enable the toggle below to hire with the talent's preferred provider/model.</div>
+        </div>
+        <label class="detail-config-toggle">
+          <input id="detail-use-talent-config" type="checkbox" ${useTalentConfig ? 'checked' : ''} />
+          Use talent preferred provider/model for this hire
+        </label>
+      </div>` : '';
 
     content.innerHTML = `
       <div class="detail-header">
@@ -4117,6 +4195,7 @@ class AppController {
       ${tags ? `<div class="detail-section"><div class="detail-label">Personality</div><div class="detail-tags-list">${tags}</div></div>` : ''}
       <div class="detail-section"><div class="detail-label">Skills</div><div class="detail-skills-list">${skills || '<em>N/A</em>'}</div></div>
       ${tools ? `<div class="detail-section"><div class="detail-label">Tools</div><div class="detail-tools-list">${tools}</div></div>` : ''}
+      ${warningSection}
       <div class="detail-section detail-grid">
         <div><div class="detail-label">LLM Model</div><div class="detail-text">🤖 ${esc(llmModel)}</div></div>
         <div><div class="detail-label">Provider</div><div class="detail-text">${esc(c.api_provider || 'openrouter')}</div></div>
@@ -4144,6 +4223,7 @@ class AppController {
     const newInterviewBtn = document.getElementById('detail-interview-btn');
     const newSelectBtn = document.getElementById('detail-select-btn');
     const newCloseBtn = document.getElementById('detail-panel-close');
+    const useTalentConfigCheckbox = document.getElementById('detail-use-talent-config');
     newSelectBtn.textContent = isSelected ? '✗ Deselect' : '✔ Select';
     newSelectBtn.className = isSelected ? 'pixel-btn danger' : 'pixel-btn secondary';
     // Only remote (self-hosted) candidates support interview
@@ -4167,6 +4247,11 @@ class AppController {
       newSelectBtn.textContent = nowSelected ? '✗ Deselect' : '✔ Select';
       newSelectBtn.className = nowSelected ? 'pixel-btn danger' : 'pixel-btn secondary';
     });
+    if (useTalentConfigCheckbox) {
+      useTalentConfigCheckbox.addEventListener('change', () => {
+        this._setCandidateConfigChoice(candidateId, useTalentConfigCheckbox.checked);
+      });
+    }
     newCloseBtn.addEventListener('click', () => {
       panel.classList.add('hidden');
       cardEl.classList.remove('detail-active');
@@ -4183,7 +4268,11 @@ class AppController {
 
     if (count > 0) {
       bar.classList.remove('hidden');
-      countEl.textContent = `${count} selected`;
+      const talentConfigCount = [...this._selectedCandidates.values()]
+        .filter(sel => sel.use_talent_llm_config).length;
+      countEl.textContent = talentConfigCount > 0
+        ? `${count} selected · ${talentConfigCount} using talent config`
+        : `${count} selected`;
       btn.textContent = `RECRUIT PARTY (${count})`;
       btn.disabled = false;
     } else {
@@ -4196,8 +4285,12 @@ class AppController {
 
   batchHireCandidates() {
     const selections = [];
-    for (const [candidateId, { candidate, role }] of this._selectedCandidates) {
-      selections.push({ candidate_id: candidateId, role });
+    for (const [candidateId, { role }] of this._selectedCandidates) {
+      selections.push({
+        candidate_id: candidateId,
+        role,
+        use_talent_llm_config: this._getCandidateConfigChoice(candidateId),
+      });
     }
 
     if (!selections.length) return;
@@ -4402,6 +4495,7 @@ class AppController {
 
     this._interviewingCandidate = null;
     this._selectedCandidates = new Map();
+    this._candidateHireConfigChoices = new Map();
 
     // Reset detail panel state so it doesn't flash stale content on reopen
     const detailPanel = document.getElementById('candidate-detail-panel');
@@ -4421,6 +4515,7 @@ class AppController {
       body: JSON.stringify({
         batch_id: this._candidateBatchId,
         candidate_id: candidate.id,
+        use_talent_llm_config: this._getCandidateConfigChoice(candidate.talent_id || candidate.id),
       }),
     })
       .then(r => r.json())

package/frontend/style.css

@@ -2259,6 +2259,15 @@ h3.pixel-title { font-size: var(--text-label); }
   width: 100%;
   max-width: 105px;
 }
+.card-config-warning {
+  margin-top: 4px;
+  padding: 2px 4px;
+  font-size: var(--text-micro);
+  color: #000;
+  background: var(--pixel-yellow);
+  border: 1px solid #000;
+  text-align: center;
+}
 
 /* ===== Candidate Detail Panel ===== */
 .candidate-detail-panel.hidden { display: none; }
@@ -2297,6 +2306,30 @@ h3.pixel-title { font-size: var(--text-label); }
   flex: 1;
   min-height: 0;
 }
+.detail-config-warning-box {
+  margin-top: 4px;
+  padding: 6px;
+  border: 1px solid var(--pixel-yellow);
+  background: rgba(255, 204, 0, 0.08);
+  color: var(--pixel-white);
+  font-size: var(--text-body);
+  line-height: 1.5;
+}
+.detail-config-warning-note {
+  margin-top: 6px;
+  color: var(--text-dim);
+}
+.detail-config-toggle {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 8px;
+  color: var(--pixel-yellow);
+  font-size: var(--text-body);
+}
+.detail-config-toggle input {
+  margin: 0;
+}
 .detail-header {
   display: flex;
   align-items: center;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mancompany/onemancompany",
-  "version": "0.7.73",
+  "version": "0.7.76",
   "description": "The AI Operating System for One-Person Companies",
   "bin": {
     "onemancompany": "bin/cli.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onemancompany"
-version = "0.7.73"
+version = "0.7.76"
 description = "A one-man company simulation with pixel art visualization and LangChain AI agents"
 requires-python = ">=3.12"
 dependencies = [

package/src/onemancompany/agents/base.py

@@ -45,7 +45,7 @@ from onemancompany.core.config import (
     load_employee_skills,
     read_text_utf,
 )
-from onemancompany.core.models import AuthMethod
+from onemancompany.core.models import AuthMethod, HostingMode
 from onemancompany.core.events import CompanyEvent, event_bus
 from onemancompany.core.state import company_state
 from onemancompany.agents.prompt_builder import PromptBuilder
@@ -60,6 +60,7 @@ _TC_ATTR = "tool_calls"  # AIMessage attribute name
 _UNKNOWN_TOOL = "unknown"
 _NO_OUTPUT = "(no output)"
 _MISSING_API_KEY_SENTINEL = "missing-api-key"
+_COMPANY_HOSTING = HostingMode.COMPANY.value
 
 
 def _extract_text(content) -> str:
@@ -160,6 +161,7 @@ def make_llm(employee_id: str = "", temperature: float | None = None) -> BaseCha
     effective_temp = 0.7
     api_provider = settings.default_api_provider or "openrouter"
     api_key = ""
+    auth_method = ""
 
     if employee_id and employee_id in employee_configs:
         cfg = employee_configs[employee_id]
@@ -168,10 +170,29 @@ def make_llm(employee_id: str = "", temperature: float | None = None) -> BaseCha
         effective_temp = cfg.temperature
         api_provider = cfg.api_provider
         api_key = cfg.api_key
+        auth_method = cfg.auth_method
 
     if temperature is not None:
         effective_temp = temperature
 
+    original_auth_method = auth_method
+    llm_profile = {
+        "hosting": _COMPANY_HOSTING,
+        "api_provider": api_provider,
+        "api_key": api_key,
+        "llm_model": model,
+        "auth_method": auth_method,
+    }
+    _cfg.normalize_llm_profile_defaults(
+        llm_profile,
+        reason=f"employee {employee_id}" if employee_id else "company default",
+    )
+    api_provider = llm_profile.get("api_provider", api_provider)
+    model = llm_profile.get("llm_model", model)
+    auth_method = llm_profile.get("auth_method", auth_method)
+    if not original_auth_method and api_provider == "anthropic":
+        auth_method = settings.anthropic_auth_method
+
     prov = get_provider(api_provider)
 
     # For custom provider, override chat_class from runtime settings
@@ -183,9 +204,6 @@ def make_llm(employee_id: str = "", temperature: float | None = None) -> BaseCha
     if prov and effective_chat_class == CHAT_CLASS_ANTHROPIC:
         from langchain_anthropic import ChatAnthropic
 
-        auth_method = ""
-        if employee_id and employee_id in employee_configs:
-            auth_method = employee_configs[employee_id].auth_method
         if not auth_method:
             auth_method = settings.anthropic_auth_method
 

package/src/onemancompany/agents/onboarding.py

@@ -42,6 +42,7 @@ from onemancompany.core.config import (
     WORKSPACE_DIR_NAME,
     EmployeeConfig,
     ensure_employee_dir,
+    normalize_llm_profile_defaults,
     settings,
     read_text_utf,
     write_text_utf,
@@ -927,11 +928,16 @@ async def execute_hire(
         department, DEFAULT_TOOL_PERMISSIONS_FALLBACK
     ))
 
-    # Default model from settings if not specified
-    if not llm_model:
-        from onemancompany.core.config import load_app_config
-        _settings = load_app_config()
-        llm_model = _settings.get("default_llm_model", "") if isinstance(_settings, dict) else getattr(_settings, "default_llm_model", "")
+    llm_profile = {
+        "hosting": hosting,
+        "api_provider": api_provider,
+        "llm_model": llm_model,
+        "auth_method": auth_method,
+    }
+    normalize_llm_profile_defaults(llm_profile, reason=f"new hire {name}")
+    api_provider = llm_profile.get("api_provider", "")
+    llm_model = llm_profile.get("llm_model", "")
+    auth_method = llm_profile.get("auth_method", "api_key")
 
     # Salary
     salary = compute_salary(llm_model) if llm_model else 0.0

package/src/onemancompany/agents/recruitment.py

@@ -76,6 +76,10 @@ class HireRequest(BaseModel):
     batch_id: str = Field(description="Batch ID from the shortlist")
     candidate_id: str = Field(description="ID of the selected candidate")
     nickname: str = Field(default="", description="Optional nickname")
+    use_talent_llm_config: bool = Field(
+        default=False,
+        description="When true, preserve the talent's provider/model instead of company defaults",
+    )
 
 
 class InterviewRequest(BaseModel):

package/src/onemancompany/api/routes.py

@@ -4217,7 +4217,14 @@ async def hire_candidate(body: HireRequest) -> dict:
 
     # Launch onboarding as background task
     spawn_background(
-        _do_hire_single(body.batch_id, body.candidate_id, body.nickname, candidate, coo_ctx)
+        _do_hire_single(
+            body.batch_id,
+            body.candidate_id,
+            body.nickname,
+            candidate,
+            coo_ctx,
+            use_talent_llm_config=body.use_talent_llm_config,
+        )
     )
 
     return {
@@ -4228,22 +4235,45 @@ async def hire_candidate(body: HireRequest) -> dict:
     }
 
 
-def _fill_talent_defaults(talent_data: dict) -> None:
-    """Fill missing LLM config fields with company defaults.
+def _fill_talent_defaults(talent_data: dict, *, use_talent_llm_config: bool = False) -> None:
+    """Normalize Talent Market LLM config against company defaults.
 
-    Non-self-hosted talents that lack llm_model, api_provider, or auth_method
-    get the company's default values instead of failing validation.
+    Company-hosted hires use the company's provider/model by default so newly
+    hired employees run on the configured company stack. When the CEO
+    explicitly opts in, preserve the talent's preferred provider/model where
+    possible while still repairing missing fields.
     """
     hosting = talent_data.get("hosting", "")
-    if hosting in ("self", HostingMode.SELF):
+    if hosting in ("self", "remote", HostingMode.SELF, HostingMode.REMOTE):
+        return
+
+    from onemancompany.core.config import normalize_llm_profile_defaults, settings as _settings
+
+    if use_talent_llm_config:
+        label = talent_data.get("talent_id") or talent_data.get("id") or talent_data.get("name") or "talent"
+        normalize_llm_profile_defaults(talent_data, reason=f"talent {label}")
         return
-    from onemancompany.core.config import settings as _settings
-    if not talent_data.get("llm_model"):
-        talent_data["llm_model"] = _settings.default_llm_model
-        logger.info("[hiring] Talent missing llm_model — using company default: {}", _settings.default_llm_model)
-    if not talent_data.get("api_provider"):
-        talent_data["api_provider"] = _settings.default_api_provider or "openrouter"
-        logger.info("[hiring] Talent missing api_provider — using default: {}", talent_data["api_provider"])
+
+    company_model = _settings.default_llm_model
+    company_provider = _settings.default_api_provider or "openrouter"
+
+    if company_model:
+        if talent_data.get("llm_model") != company_model:
+            logger.info(
+                "[hiring] Overriding talent llm_model '{}' with company default '{}'",
+                talent_data.get("llm_model", ""),
+                company_model,
+            )
+        talent_data["llm_model"] = company_model
+
+    if talent_data.get("api_provider") != company_provider:
+        logger.info(
+            "[hiring] Overriding talent api_provider '{}' with company default '{}'",
+            talent_data.get("api_provider", ""),
+            company_provider,
+        )
+    talent_data["api_provider"] = company_provider
+
     if not talent_data.get("auth_method"):
         talent_data["auth_method"] = "api_key"
 
@@ -4330,6 +4360,7 @@ async def _cleanup_single_hire_failure(
 async def _do_hire_single(
     batch_id: str, candidate_id: str, nickname: str,
     candidate: dict, coo_ctx: dict,
+    *, use_talent_llm_config: bool = False,
 ) -> None:
     """Background task: execute hire + post-hire notifications."""
     from pathlib import Path
@@ -4378,8 +4409,8 @@ async def _do_hire_single(
             logger.debug("[hiring] No local profile for talent {}, using candidate data", talent_id)
             talent_data = candidate
 
-        # Fill missing LLM config with company defaults
-        _fill_talent_defaults(talent_data)
+        # Default to company config unless the hirer explicitly opts in.
+        _fill_talent_defaults(talent_data, use_talent_llm_config=use_talent_llm_config)
 
         # Validate required fields
         missing = _check_talent_required_fields(talent_data)
@@ -4810,8 +4841,11 @@ async def _do_batch_hire(
                 logger.debug("[batch-hire] No local profile for talent {}, using candidate data", talent_id)
                 talent_data = candidate
 
-            # Fill missing LLM config with company defaults
-            _fill_talent_defaults(talent_data)
+            # Default to company config unless the hirer explicitly opts in.
+            _fill_talent_defaults(
+                talent_data,
+                use_talent_llm_config=bool(sel.get("use_talent_llm_config", False)),
+            )
 
             # Validate required fields
             missing = _check_talent_required_fields(talent_data)

package/src/onemancompany/core/config.py

@@ -406,13 +406,11 @@ ENGINEERING_DEPT = "Engineering"
 # Default tool permissions by department (set during hiring)
 # Note: read, ls, write, edit are now BASE_TOOLS (always available, no permission needed).
 # Only gated tools need to be listed here.
-DEFAULT_TOOL_PERMISSIONS: dict[str, list[str]] = {
-    "Engineering": [
-        "bash", "use_tool",
-    ],
-    "Design": ["use_tool"],
-    "Analytics": ["use_tool"],
-    "Marketing": ["use_tool"],
+DEFAULT_TOOL_PERMISSIONS = {
+    "Engineering": ["bash", "use_tool"],
+    "Design": ["bash", "use_tool"],
+    "Analytics": ["bash", "use_tool"],
+    "Marketing": ["bash", "use_tool"],
     "General": [],
 }
 DEFAULT_TOOL_PERMISSIONS_FALLBACK: list[str] = []
@@ -655,6 +653,98 @@ def sync_founding_defaults(provider: str, model: str) -> int:
     return synced
 
 
+def resolve_provider_key(provider_name: str, employee_api_key: str = "") -> str:
+    """Resolve an API key from employee override first, then company settings."""
+    if employee_api_key:
+        return employee_api_key
+    provider_name = (provider_name or "").strip()
+    if not provider_name:
+        return ""
+    prov = get_provider(provider_name)
+    if prov and prov.env_key:
+        return getattr(settings, prov.env_key, "")
+    return ""
+
+
+def provider_has_credentials(provider_name: str, employee_api_key: str = "") -> bool:
+    """Return whether a provider can be used by this employee/company."""
+    return bool(resolve_provider_key(provider_name, employee_api_key))
+
+
+def normalize_llm_profile_defaults(profile: dict, *, reason: str = "employee") -> bool:
+    """Normalize company-hosted LLM settings in a profile-like dict.
+
+    Imported talents can carry provider-specific defaults such as OpenRouter.
+    If that provider has no credentials in this company, use the configured
+    company default provider/model instead of creating an employee that fails
+    during startup.
+    """
+    hosting = profile.get("hosting", "")
+    if hosting in ("self", "remote"):
+        return False
+
+    changed = False
+    default_provider = settings.default_api_provider or PROVIDER_OPENROUTER
+    default_model = settings.default_llm_model
+
+    provider = (profile.get("api_provider") or "").strip()
+    employee_key = (profile.get("api_key") or "").strip()
+    provider_missing_key = provider and not provider_has_credentials(provider, employee_key)
+    default_has_key = provider_has_credentials(default_provider)
+
+    if not profile.get("api_provider"):
+        profile["api_provider"] = default_provider
+        provider = default_provider
+        changed = True
+        logger.info("[llm-config] {} missing api_provider — using company default: {}", reason, default_provider)
+    elif provider != default_provider and provider_missing_key and default_has_key:
+        logger.info(
+            "[llm-config] {} provider '{}' has no credentials — using company default '{}'",
+            reason,
+            provider,
+            default_provider,
+        )
+        profile["api_provider"] = default_provider
+        provider = default_provider
+        changed = True
+        # Provider-specific model names are not always portable across gateways.
+        if default_model and profile.get("llm_model") != default_model:
+            profile["llm_model"] = default_model
+            changed = True
+
+    if not profile.get("llm_model") and default_model:
+        profile["llm_model"] = default_model
+        changed = True
+        logger.info("[llm-config] {} missing llm_model — using company default: {}", reason, default_model)
+
+    if not profile.get("auth_method"):
+        profile["auth_method"] = "api_key"
+        changed = True
+
+    return changed
+
+
+def sync_company_hosted_llm_defaults() -> int:
+    """Repair existing company-hosted employee profiles with unusable LLM config."""
+    synced = 0
+    if not EMPLOYEES_DIR.exists():
+        return synced
+
+    for emp_dir in sorted(EMPLOYEES_DIR.iterdir()):
+        if not emp_dir.is_dir():
+            continue
+        profile_path = emp_dir / PROFILE_FILENAME
+        if not profile_path.exists():
+            continue
+        data = yaml.safe_load(read_text_utf(profile_path)) or {}
+        if data.get(PF_REMOTE):
+            continue
+        if normalize_llm_profile_defaults(data, reason=f"employee {emp_dir.name}"):
+            write_text_utf(profile_path, yaml.dump(data, default_flow_style=False, allow_unicode=True))
+            synced += 1
+    return synced
+
+
 # ---------------------------------------------------------------------------
 # Application config (config.yaml at project root)
 # ---------------------------------------------------------------------------

package/src/onemancompany/core/task_persistence.py

@@ -16,17 +16,60 @@ import yaml
 from onemancompany.core.config import EMPLOYEES_DIR, PROJECT_YAML_FILENAME, TASK_TREE_FILENAME, read_text_utf
 from onemancompany.core.task_lifecycle import RESOLVED, TaskPhase, NodeType
 
+_CLOSED_PROJECT_STATUSES = {"archived", "completed", "failed", "cancelled"}
+
+
+def _project_metadata_paths(tree_path: Path) -> list[Path]:
+    """Return possible project/iteration metadata files for a task tree."""
+    project_dir = tree_path.parent
+    candidates = [
+        project_dir / PROJECT_YAML_FILENAME,
+    ]
+    if project_dir.parent.name == "iterations":
+        candidates.extend([
+            project_dir.parent / f"{project_dir.name}.yaml",
+            project_dir.parent.parent / PROJECT_YAML_FILENAME,
+        ])
+    else:
+        candidates.extend([
+            project_dir.parent / PROJECT_YAML_FILENAME,
+            project_dir.parent.parent / PROJECT_YAML_FILENAME,
+        ])
+
+    seen: set[Path] = set()
+    unique: list[Path] = []
+    for candidate in candidates:
+        if candidate not in seen:
+            seen.add(candidate)
+            unique.append(candidate)
+    return unique
+
+
+def _project_statuses(tree_path: Path) -> list[str]:
+    """Load all known status values for the tree's project/iteration."""
+    statuses: list[str] = []
+    for metadata_path in _project_metadata_paths(tree_path):
+        if not metadata_path.exists():
+            continue
+        try:
+            doc = yaml.safe_load(read_text_utf(metadata_path)) or {}
+        except Exception as exc:
+            logger.debug("Skipping unreadable project metadata {}: {}", metadata_path, exc)
+            continue
+        status = doc.get("status")
+        if status:
+            statuses.append(str(status))
+    return statuses
+
 
 def _is_project_archived(tree_path: Path) -> bool:
     """Check if the project containing this tree file is archived."""
-    project_yaml = tree_path.parent / PROJECT_YAML_FILENAME
-    if not project_yaml.exists():
-        return False
-    try:
-        doc = yaml.safe_load(read_text_utf(project_yaml)) or {}
-        return doc.get("status") == "archived"
-    except Exception:
-        return False
+    return "archived" in _project_statuses(tree_path)
+
+
+def _is_project_closed(tree_path: Path) -> bool:
+    """Check if the project/iteration is already final and should not recover work."""
+    return any(status in _CLOSED_PROJECT_STATUSES for status in _project_statuses(tree_path))
 
 
 # ---------------------------------------------------------------------------
@@ -59,9 +102,9 @@ def recover_schedule_from_trees(
     # 1. Scan all task_tree.yaml files under projects_dir
     if projects_dir.exists():
         for tree_path in projects_dir.rglob(TASK_TREE_FILENAME):
-            # Skip archived projects — no need to restore tasks
-            if _is_project_archived(tree_path):
-                logger.debug("Skipping archived project tree: {}", tree_path)
+            # Skip closed projects — no need to restore tasks or stale handlers.
+            if _is_project_closed(tree_path):
+                logger.debug("Skipping closed project tree: {}", tree_path)
                 continue
             try:
                 tree = get_tree(tree_path)

package/src/onemancompany/core/task_tree.py

@@ -95,6 +95,15 @@ class TaskNode:
     # (agent promised action but didn't call tools). Capped at MAX_STALL_RETRIES.
     stall_retry_count: int = 0
 
+    # Child failure event ids already surfaced to this parent. This makes
+    # failure notifications edge-triggered instead of repeatedly firing while a
+    # failed child remains in the tree.
+    handled_child_failure_ids: list[str] = field(default_factory=list)
+
+    # Stable key for system-generated notification nodes so callers can dedupe
+    # retries/recovery without relying on prompt text.
+    event_key: str = ""
+
     # --- Content externalization tracking (not part of equality/repr) ---
     _content_dirty: bool = field(default=False, init=False, repr=False, compare=False)
     _content_loaded: bool = field(default=False, init=False, repr=False, compare=False)
@@ -215,6 +224,8 @@ class TaskNode:
             "hold_started_at": self.hold_started_at,
             "retry_count": self.retry_count,
             "stall_retry_count": self.stall_retry_count,
+            "handled_child_failure_ids": list(self.handled_child_failure_ids),
+            "event_key": self.event_key,
             "directives_count": len(self.directives),
         }
 

package/src/onemancompany/core/vessel.py

@@ -1300,6 +1300,107 @@ class EmployeeManager:
 
         return count
 
+    def quiesce_project(self, project_id: str, tree_path: str = "", reason: str = "Project completed") -> int:
+        """Stop stale scheduled/system work for a project that has reached a final state.
+
+        Work results remain in the tree for audit. Only active system nodes
+        (watchdog nudges, reviews, CEO requests, adhoc/system handlers) are
+        cancelled, and all schedule entries for the project are removed so
+        recovery or in-memory dispatch cannot keep old handlers alive.
+        """
+        from onemancompany.core.task_lifecycle import safe_cancel
+        from onemancompany.core.task_tree import get_tree, save_tree_async
+
+        def _matches(candidate: str, tree_project_id: str = "") -> bool:
+            ids = {p for p in (candidate, tree_project_id) if p}
+            for existing in ids:
+                if (
+                    existing == project_id
+                    or existing.startswith(f"{project_id}/")
+                    or project_id.startswith(f"{existing}/")
+                ):
+                    return True
+            return False
+
+        touched_tree_paths: set[str] = {tree_path} if tree_path else set()
+        removed_entries = 0
+
+        for emp_id, entries in list(self._schedule.items()):
+            keep: list[ScheduleEntry] = []
+            for entry in entries:
+                remove_entry = False
+                try:
+                    tree = get_tree(entry.tree_path)
+                    node = tree.get_node(entry.node_id)
+                    if node and _matches(node.project_id, tree.project_id):
+                        remove_entry = True
+                        touched_tree_paths.add(entry.tree_path)
+                except Exception as e:
+                    logger.debug("[quiesce_project] Could not inspect scheduled node {}: {}", entry.node_id, e)
+                if remove_entry:
+                    removed_entries += 1
+                else:
+                    keep.append(entry)
+            self._schedule[emp_id] = keep
+
+        for emp_id, entry in list(self._current_entries.items()):
+            try:
+                tree = get_tree(entry.tree_path)
+                node = tree.get_node(entry.node_id)
+                if not node or not _matches(node.project_id, tree.project_id):
+                    continue
+                touched_tree_paths.add(entry.tree_path)
+                if node.node_type in SYSTEM_NODE_TYPES and TaskPhase(node.status) not in TERMINAL:
+                    running = self._running_tasks.get(emp_id)
+                    if running and not running.done():
+                        running.cancel()
+                        logger.info(
+                            "[quiesce_project] Cancelled running stale system task {} for project {}",
+                            entry.node_id, project_id,
+                        )
+            except Exception as e:
+                logger.debug("[quiesce_project] Could not inspect running node {}: {}", entry.node_id, e)
+
+        cancelled_nodes = 0
+        for tp in touched_tree_paths:
+            if not tp:
+                continue
+            try:
+                tree = get_tree(tp)
+            except Exception as e:
+                logger.debug("[quiesce_project] Could not load tree {}: {}", tp, e)
+                continue
+
+            dirty = False
+            for node in tree.all_nodes():
+                if not _matches(node.project_id, tree.project_id):
+                    continue
+                if node.node_type not in SYSTEM_NODE_TYPES:
+                    continue
+                if TaskPhase(node.status) in TERMINAL:
+                    continue
+                if safe_cancel(node):
+                    node.result = reason
+                    node.completed_at = node.completed_at or datetime.now().isoformat()
+                    cancelled_nodes += 1
+                    dirty = True
+                    for cron_name in (f"reply_{node.id}", f"holding_{node.id}"):
+                        try:
+                            stop_cron(node.employee_id, cron_name)
+                        except Exception as exc:
+                            logger.debug("[quiesce_project] Could not stop cron {}/{}: {}", node.employee_id, cron_name, exc)
+                    self._publish_node_update(node.employee_id, node)
+            if dirty:
+                save_tree_async(tp)
+
+        total = removed_entries + cancelled_nodes
+        if total:
+            logger.info(
+                "[quiesce_project] Quieted project {}: {} schedule entries removed, {} system nodes cancelled",
+                project_id, removed_entries, cancelled_nodes,
+            )
+        return total
+
     def abort_employee(self, employee_id: str) -> int:
         """Cancel all tasks for an employee. Returns count cancelled."""
         from onemancompany.core.task_tree import get_tree, save_tree_async
@@ -2621,11 +2722,14 @@ class EmployeeManager:
                     if c.node_type == NodeType.REVIEW
                     and c.status in (TaskPhase.PENDING.value, TaskPhase.PROCESSING.value)
                 )
-                # Check for failed children when parent is HOLDING — resume parent
-                # so it can react (retry via reject_child, reassign, or escalate).
-                has_failed_child = any(
-                    c for c in non_review_children
-                    if c.status == TaskPhase.FAILED.value
+                # Check whether the CURRENT completing node is a failed
+                # substantive child. Failure notifications must be edge-triggered
+                # per child id; otherwise completed watchdog/review nodes keep
+                # re-notifying about old failed siblings.
+                current_failed_child = (
+                    node.status == TaskPhase.FAILED.value
+                    and node.node_type not in SYSTEM_NODE_TYPES
+                    and node.parent_id == parent_node.id
                 )
                 # Check if the CURRENT completing node was cancelled — resume parent
                 # so it can reassess (e.g. cancelled CEO_REQUEST should unblock parent).
@@ -2633,15 +2737,22 @@ class EmployeeManager:
                 # siblings — otherwise WATCHDOG_NUDGE completions re-trigger the cancelled
                 # branch in an infinite loop.
                 has_cancelled_child = node.status == TaskPhase.CANCELLED.value
-                if has_failed_child and parent_node.status in (TaskPhase.HOLDING.value, TaskPhase.PROCESSING.value):
-                    failed_children = [
-                        c for c in non_review_children
-                        if c.status == TaskPhase.FAILED.value
-                    ]
-                    failure_summary = "; ".join(
-                        f"[{c.employee_id}] {c.description_preview}: {c.result or 'no details'}"
-                        for c in failed_children
+                handled_failures = getattr(parent_node, "handled_child_failure_ids", []) or []
+                failure_event_key = f"child_failure:{parent_node.id}:{node.id}"
+                failure_already_handled = node.id in handled_failures
+                if current_failed_child and failure_already_handled:
+                    logger.debug(
+                        "[ON_CHILD_COMPLETE] child {} failure already handled for parent {} — skipping duplicate notification",
+                        node.id, parent_node.id,
                     )
+
+                if (
+                    current_failed_child
+                    and not failure_already_handled
+                    and parent_node.status in (TaskPhase.HOLDING.value, TaskPhase.PROCESSING.value)
+                ):
+                    parent_node.handled_child_failure_ids = [*handled_failures, node.id]
+                    failure_summary = f"[{node.employee_id}] {node.description_preview}: {node.result or 'no details'}"
                     resume_desc = (
                         f"[Child Task Failure] The following child tasks have failed:\n\n"
                         f"{failure_summary}\n\n"
@@ -2668,19 +2779,39 @@ class EmployeeManager:
                         logger.debug("[TASK LIFECYCLE] parent={} → PROCESSING (child failed, resuming)", parent_node.id)
                     else:
                         logger.debug("[TASK LIFECYCLE] parent={} already PROCESSING (child failed, re-dispatching)", parent_node.id)
-                    # Inject failure context into parent's description for re-execution
-                    notify_node = tree.add_child(
-                        parent_id=parent_node.id,
-                        employee_id=parent_node.employee_id,
-                        description=resume_desc,
-                        acceptance_criteria=[],
+                    # Inject failure context into a short-lived system node. The
+                    # event_key protects against duplicate creation if recovery
+                    # or a concurrent callback sees the same failure event.
+                    notify_node = next(
+                        (
+                            c for c in children
+                            if c.node_type == NodeType.WATCHDOG_NUDGE
+                            and getattr(c, "event_key", "") == failure_event_key
+                            and TaskPhase(c.status) not in TERMINAL
+                        ),
+                        None,
                     )
-                    notify_node.node_type = NodeType.WATCHDOG_NUDGE
-                    notify_node.project_id = project_id
-                    notify_node.project_dir = parent_node.project_dir or str(Path(entry.tree_path).parent)
+                    if notify_node:
+                        logger.debug(
+                            "[ON_CHILD_COMPLETE] failure notification {} already exists for event {}",
+                            notify_node.id, failure_event_key,
+                        )
+                    else:
+                        notify_node = tree.add_child(
+                            parent_id=parent_node.id,
+                            employee_id=parent_node.employee_id,
+                            description=resume_desc,
+                            acceptance_criteria=[],
+                            timeout_seconds=180,
+                        )
+                        notify_node.node_type = NodeType.WATCHDOG_NUDGE
+                        notify_node.event_key = failure_event_key
+                        notify_node.project_id = project_id
+                        notify_node.project_dir = parent_node.project_dir or str(Path(entry.tree_path).parent)
                     save_tree_async(entry.tree_path)
-                    self.schedule_node(parent_node.employee_id, notify_node.id, entry.tree_path)
-                    self._schedule_next(parent_node.employee_id)
+                    if notify_node.status == TaskPhase.PENDING.value:
+                        self.schedule_node(parent_node.employee_id, notify_node.id, entry.tree_path)
+                        self._schedule_next(parent_node.employee_id)
 
                 elif has_cancelled_child and parent_node.status in (TaskPhase.HOLDING.value, TaskPhase.PROCESSING.value):
                     cancelled_children = [
@@ -3204,6 +3335,9 @@ class EmployeeManager:
                 await _store.save_project_status(project_id, ITER_STATUS_FAILED)
             else:
                 complete_project(project_id, label)
+            tree_path = str(Path(node.project_dir) / TASK_TREE_FILENAME) if node.project_dir else ""
+            quiet_reason = "Superseded: project failed" if agent_error else "Superseded: project completed"
+            self.quiesce_project(project_id, tree_path=tree_path, reason=quiet_reason)
 
         # --- Resource cleanup: evict tree cache, task logs, Claude sessions ---
         self._release_project_resources(employee_id, node, project_id)

package/src/onemancompany/main.py

@@ -489,7 +489,15 @@ async def lifespan(app: FastAPI):
         logger.warning("Talent Market connection failed (configure in Settings): {}", e)
 
     from onemancompany.core.vessel_config import load_vessel_config
-    from onemancompany.core.config import EMPLOYEES_DIR as _EMPLOYEES_DIR, employee_configs as _emp_cfgs
+    from onemancompany.core.config import (
+        EMPLOYEES_DIR as _EMPLOYEES_DIR,
+        employee_configs as _emp_cfgs,
+        sync_company_hosted_llm_defaults,
+    )
+
+    _synced_llm_profiles = sync_company_hosted_llm_defaults()
+    if _synced_llm_profiles:
+        logger.info("[startup] Repaired {} employee LLM profile(s) to use available company defaults", _synced_llm_profiles)
 
     # Founding employees — hosting-aware registration
     from onemancompany.core.vessel import register_founding_employee