groove-dev 0.27.103 → 0.27.106

package/node_modules/@groove-dev/gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.103",
+  "version": "0.27.106",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/gui/src/components/onboarding/setup-wizard.jsx

@@ -131,7 +131,13 @@ function ProjectFolderStep({ selectedDir, onSelectDir }) {
   const remoteHomedir = useGrooveStore((s) => s.remoteHomedir);
   const [browsing, setBrowsing] = useState(false);
 
+  const isRemote = new URLSearchParams(window.location.search).has('instance');
+
   async function handleBrowse() {
+    if (isRemote) {
+      setBrowsing(true);
+      return;
+    }
     const dir = await selectFolder({
       title: 'Choose your project folder',
       defaultPath: selectedDir || undefined,

package/node_modules/@groove-dev/gui/src/components/settings/ProviderSetupWizard.jsx

@@ -145,9 +145,9 @@ function InstallStep({ providerId, meta }) {
 
       {hasError && (
         <div className="space-y-3">
-          {typeof hasError === 'string' && hasError.length > 40 && (
-            <div className="p-3 bg-surface-0 border border-border-subtle rounded-md max-h-24 overflow-y-auto">
-              <p className="text-2xs font-mono text-danger/80 whitespace-pre-wrap break-all">{hasError}</p>
+          {typeof hasError === 'string' && (
+            <div className="p-3 bg-danger/5 border border-danger/20 rounded-md max-h-32 overflow-y-auto">
+              <p className="text-2xs font-mono text-danger whitespace-pre-wrap break-all">{hasError}</p>
             </div>
           )}
           <p className="text-xs text-text-2 font-sans">Check that npm is in your PATH and try again.</p>
@@ -172,6 +172,8 @@ function AuthenticateStep({ providerId, meta, onSaveKey }) {
   const [showKey, setShowKey] = useState(false);
   const [saving, setSaving] = useState(false);
   const [loginStarted, setLoginStarted] = useState(false);
+  const [verifying, setVerifying] = useState(false);
+  const [verifyError, setVerifyError] = useState('');
   const [authMode, setAuthMode] = useState(meta.authType === 'subscription' ? 'subscription' : 'apikey');
 
   async function handleSaveKey() {
@@ -261,9 +263,33 @@ function AuthenticateStep({ providerId, meta, onSaveKey }) {
                 <ExternalLink size={12} className="text-accent" />
                 <span className="text-xs text-accent font-sans">Sign-in opened in your browser</span>
               </div>
-              <Button variant="primary" size="sm" onClick={onSaveKey} className="gap-1.5">
-                <Check size={11} /> I've signed in
+              <Button
+                variant="primary"
+                size="sm"
+                disabled={verifying}
+                onClick={async () => {
+                  setVerifying(true);
+                  setVerifyError('');
+                  try {
+                    const res = await api.post(`/providers/${providerId}/verify`);
+                    if (res.authenticated) {
+                      onSaveKey();
+                    } else {
+                      setVerifyError('Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                    }
+                  } catch {
+                    setVerifyError('Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                  } finally {
+                    setVerifying(false);
+                  }
+                }}
+                className="gap-1.5"
+              >
+                {verifying ? <Loader2 size={11} className="animate-spin" /> : <Check size={11} />} I've signed in
               </Button>
+              {verifyError && (
+                <p className="text-2xs text-danger font-sans">{verifyError}</p>
+              )}
             </div>
           )}
           <p className="text-2xs text-text-4 font-sans">
@@ -287,9 +313,33 @@ function AuthenticateStep({ providerId, meta, onSaveKey }) {
                 <ExternalLink size={12} className="text-accent" />
                 <span className="text-xs text-accent font-sans">Sign-in opened in your browser</span>
               </div>
-              <Button variant="primary" size="sm" onClick={onSaveKey} className="gap-1.5">
-                <Check size={11} /> I've signed in
+              <Button
+                variant="primary"
+                size="sm"
+                disabled={verifying}
+                onClick={async () => {
+                  setVerifying(true);
+                  setVerifyError('');
+                  try {
+                    const res = await api.post(`/providers/codex/verify`);
+                    if (res.authenticated) {
+                      onSaveKey();
+                    } else {
+                      setVerifyError('Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                    }
+                  } catch {
+                    setVerifyError('Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                  } finally {
+                    setVerifying(false);
+                  }
+                }}
+                className="gap-1.5"
+              >
+                {verifying ? <Loader2 size={11} className="animate-spin" /> : <Check size={11} />} I've signed in
               </Button>
+              {verifyError && (
+                <p className="text-2xs text-danger font-sans">{verifyError}</p>
+              )}
             </div>
           )}
         </div>

package/node_modules/@groove-dev/gui/src/views/settings.jsx

@@ -454,10 +454,43 @@ function ProviderCard({ provider, onKeyChange }) {
                   <Button
                     variant="primary"
                     size="sm"
-                    onClick={() => { setLoginPending(false); if (onKeyChange) onKeyChange(); }}
+                    disabled={checking}
+                    onClick={async () => {
+                      if (provider.id === 'codex') {
+                        setChecking(true);
+                        try {
+                          const res = await api.post(`/providers/codex/verify`);
+                          if (res.authenticated) {
+                            setLoginPending(false);
+                            if (onKeyChange) onKeyChange();
+                          } else {
+                            addToast('error', 'Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                          }
+                        } catch {
+                          addToast('error', 'Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                        } finally {
+                          setChecking(false);
+                        }
+                      } else {
+                        setChecking(true);
+                        try {
+                          const res = await api.post(`/providers/claude-code/verify`);
+                          if (res.authenticated) {
+                            setLoginPending(false);
+                            if (onKeyChange) onKeyChange();
+                          } else {
+                            addToast('error', 'Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                          }
+                        } catch {
+                          addToast('error', 'Authentication not detected yet. Please complete sign-in in your browser and try again.');
+                        } finally {
+                          setChecking(false);
+                        }
+                      }
+                    }}
                     className="w-full h-8 text-xs gap-1.5"
                   >
-                    <Check size={12} /> I've signed in
+                    {checking ? <Loader2 size={12} className="animate-spin" /> : <Check size={12} />} I've signed in
                   </Button>
                   <button
                     onClick={() => setLoginPending(false)}

package/node_modules/moe-training/client/index.js

@@ -8,3 +8,4 @@ export { TransmissionQueue } from './transmission-queue.js';
 export { EnvelopeBuilder } from './envelope-builder.js';
 export { StepClassifier } from './step-classifier.js';
 export { getParser } from './parsers/index.js';
+export { DomainTagger } from './domain-tagger.js';

package/node_modules/moe-training/client/step-classifier.js

@@ -38,7 +38,7 @@ export class StepClassifier {
 
     const content = step.content || '';
 
-    if ((step.type === 'action' || step.type === 'observation') && ERROR_SIGNAL_RE.test(content)) {
+    if ((step.type === 'action' || step.type === 'observation') && step.is_error !== false && ERROR_SIGNAL_RE.test(content)) {
       step.type = 'error';
     }
 

package/node_modules/moe-training/client/trajectory-capture.js

@@ -8,6 +8,7 @@ import { StepClassifier } from './step-classifier.js';
 import { EnvelopeBuilder } from './envelope-builder.js';
 import { SessionAttestation } from './session-attestation.js';
 import { TransmissionQueue } from './transmission-queue.js';
+import { DomainTagger } from './domain-tagger.js';
 import {
   CHUNK_TIMEOUT_MS,
   CENTRAL_COMMAND_URL,
@@ -33,7 +34,7 @@ export class TrajectoryCapture {
     this._contexts = new Map();
   }
 
-  init() {
+  async init() {
     if (!ConsentManager.isCaptureEnabled()) {
       this._enabled = false;
       return;
@@ -43,6 +44,8 @@ export class TrajectoryCapture {
     this._attestation = new SessionAttestation(this._centralCommandUrl);
     this._transmissionQueue = new TransmissionQueue(this._centralCommandUrl);
     this._transmissionQueue.start();
+    this._domainTagger = new DomainTagger();
+    await this._domainTagger.init();
     this._offlineRetryTimer = setInterval(() => {
       this._retryOfflineQueue();
     }, OFFLINE_RETRY_INTERVAL_MS);
@@ -126,10 +129,6 @@ export class TrajectoryCapture {
       if (resolved) ctx.metadata.model_engine = resolved;
     }
 
-    const tokens = ctx.parser.extractTokens(jsonEvent);
-    if (tokens) {
-      ctx.totalTokens += (tokens.input || 0) + (tokens.output || 0);
-    }
   }
 
   onUserMessage(agentId, text) {
@@ -155,6 +154,42 @@ export class TrajectoryCapture {
     this._processStep(agentId, ctx, classified);
   }
 
+  onParsedOutput(agentId, output) {
+    if (!this._enabled) return;
+    const ctx = this._contexts.get(agentId);
+    if (!ctx || !output || !output.type) return;
+
+    if (output.type === 'activity') {
+      if (output.subtype === 'assistant') {
+        this._processStep(agentId, ctx, { type: 'thought', content: output.data || '' });
+      } else if (output.subtype === 'tool_use' && Array.isArray(output.data)) {
+        for (const item of output.data) {
+          this._processStep(agentId, ctx, {
+            type: 'action',
+            tool: item.name || '',
+            arguments: item.input || {},
+            content: `Using ${item.name || 'tool'}`,
+          });
+        }
+      } else if (output.subtype === 'tool_result' && Array.isArray(output.data)) {
+        for (const item of output.data) {
+          const isError = item.success === false;
+          this._processStep(agentId, ctx, {
+            type: isError ? 'error' : 'observation',
+            content: item.output || '',
+            tool: item.name || '',
+            is_error: isError,
+          });
+        }
+      }
+    } else if (output.type === 'result') {
+      this._processStep(agentId, ctx, {
+        type: 'resolution',
+        content: typeof output.data === 'string' ? output.data : '',
+      });
+    }
+  }
+
   async onAgentComplete(agentId, outcome) {
     await this._closeAgent(agentId, outcome?.status || 'SUCCESS', outcome);
   }
@@ -198,6 +233,7 @@ export class TrajectoryCapture {
       ...ev,
     };
 
+    ctx.totalTokens += ev.token_count;
     if (ev.type === 'error') ctx.errorsEncountered++;
     ctx.allSteps.push(step);
 
@@ -254,6 +290,14 @@ export class TrajectoryCapture {
     const userInterventions = StepClassifier.countUserInterventions(ctx.allSteps);
     const durationSeconds = Math.round((Date.now() - ctx.startTime) / 1000);
 
+    if (this._domainTagger) {
+      const role = ctx.metadata.agent_role || '';
+      const firstPrompt = ctx.allSteps.find((s) => s.type === 'thought')?.content || '';
+      const thoughtSteps = ctx.allSteps.filter((s) => s.type === 'thought');
+      const routingText = DomainTagger.buildRoutingText(role, firstPrompt, thoughtSteps);
+      ctx.metadata.domain_tags = await this._domainTagger.tag(routingText);
+    }
+
     const { tier, reason: tierReason } = this._computeQualityTier(ctx, status, userInterventions);
     const { eligible, exclusionReason } = this._computeTrainingEligibility(ctx, durationSeconds);
 
@@ -296,8 +340,9 @@ export class TrajectoryCapture {
 
   _computeQualityTier(ctx, status, userInterventions) {
     const quality = ctx.metadata.session_quality;
-    if (quality >= TIER_A_MIN_QUALITY && ctx.errorsEncountered === 0 && userInterventions === 0 && status === 'SUCCESS') {
-      return { tier: 'TIER_A', reason: 'high_quality_no_errors' };
+    if (quality >= TIER_A_MIN_QUALITY && (ctx.errorsEncountered === 0 || ctx.errorsEncountered <= ctx.errorsRecovered) && userInterventions === 0 && status === 'SUCCESS') {
+      const reason = ctx.errorsEncountered > 0 ? 'high_quality_errors_recovered' : 'high_quality_no_errors';
+      return { tier: 'TIER_A', reason };
     }
     if (status !== 'SUCCESS') {
       return { tier: 'TIER_C', reason: 'non_success_status' };

package/node_modules/moe-training/test/client/step-classifier.test.js

@@ -132,4 +132,46 @@ describe('StepClassifier', () => {
     assert.ok(result);
     assert.equal(result.type, 'action');
   });
+
+  it('preserves observation type when is_error is false despite error keywords', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'observation', content: 'Cannot find module foo', is_error: false };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'observation');
+  });
+
+  it('preserves observation type when is_error:false and content has TypeError', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'observation', content: 'TypeError: something failed', is_error: false };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'observation');
+  });
+
+  it('still reclassifies observation to error when is_error is true', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'observation', content: 'Command failed with exit code 1', is_error: true };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'error');
+  });
+
+  it('still reclassifies observation to error when is_error is undefined', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'observation', content: 'ENOENT: no such file or directory' };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'error');
+  });
+
+  it('preserves action type when is_error is false', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'action', content: 'Command failed with exit code 1', is_error: false };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'action');
+  });
+
+  it('still reclassifies action to error when is_error is not set', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'action', content: 'Command failed with exit code 1' };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'error');
+  });
 });

package/node_modules/moe-training/test/client/trajectory-capture.test.js

@@ -292,6 +292,101 @@ describe('TrajectoryCapture — user feedback emission', () => {
   });
 });
 
+describe('TrajectoryCapture — token counting via _processStep', () => {
+  it('accumulates token_count from every step type', () => {
+    const tc = makeTc();
+    tc._scrubber = { scrub: (s) => s };
+    const ctx = makeCtx();
+    ctx.totalTokens = 0;
+    ctx.stepCount = 0;
+    ctx.allSteps = [];
+    ctx.builder = { addStep: () => null };
+    ctx.classifier = {
+      onStep: (s) => s,
+    };
+
+    tc._processStep('agent-1', ctx, { type: 'thought', content: 'thinking about it', token_count: 50 });
+    tc._processStep('agent-1', ctx, { type: 'action', content: 'run test', token_count: 30 });
+    tc._processStep('agent-1', ctx, { type: 'observation', content: 'test passed', token_count: 100 });
+    tc._processStep('agent-1', ctx, { type: 'thought', content: 'next step', token_count: 20 });
+
+    assert.equal(ctx.totalTokens, 200);
+    assert.equal(ctx.stepCount, 4);
+  });
+
+  it('estimates token_count when not provided', () => {
+    const tc = makeTc();
+    tc._scrubber = { scrub: (s) => s };
+    const ctx = makeCtx();
+    ctx.totalTokens = 0;
+    ctx.stepCount = 0;
+    ctx.allSteps = [];
+    ctx.builder = { addStep: () => null };
+    ctx.classifier = {
+      onStep: (s) => s,
+    };
+
+    tc._processStep('agent-1', ctx, { type: 'thought', content: 'a'.repeat(100) });
+    assert.equal(ctx.totalTokens, 25);
+  });
+
+  it('does not double-count tokens from onStdoutLine', () => {
+    const tc = makeTc();
+    tc._scrubber = { scrub: (s) => s };
+    tc._enabled = true;
+
+    const ctx = makeCtx();
+    ctx.totalTokens = 0;
+    ctx.stepCount = 0;
+    ctx.allSteps = [];
+    ctx.builder = { addStep: () => null };
+    ctx.classifier = {
+      onStep: (s) => s,
+    };
+    ctx.parser = {
+      parseEvent: () => ({ type: 'thought', content: 'hello', token_count: 10 }),
+      extractModel: () => null,
+    };
+    tc._contexts.set('agent-x', ctx);
+
+    tc.onStdoutLine('agent-x', '{"type":"assistant"}');
+    assert.equal(ctx.totalTokens, 10);
+  });
+});
+
+describe('TrajectoryCapture — TIER_A with recovered errors', () => {
+  it('TIER_A when all errors are recovered', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 80, errorsEncountered: 2, errorsRecovered: 2 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_A');
+    assert.equal(result.reason, 'high_quality_errors_recovered');
+  });
+
+  it('TIER_A when errors recovered exceed errors encountered', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 75, errorsEncountered: 1, errorsRecovered: 2 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_A');
+    assert.equal(result.reason, 'high_quality_errors_recovered');
+  });
+
+  it('not TIER_A when errors exceed recoveries', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 80, errorsEncountered: 3, errorsRecovered: 1 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.notEqual(result.tier, 'TIER_A');
+  });
+
+  it('TIER_A with zero errors still uses original reason', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 80, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_A');
+    assert.equal(result.reason, 'high_quality_no_errors');
+  });
+});
+
 describe('TrajectoryCapture — _computeQuality', () => {
   it('base score is 50', () => {
     const tc = makeTc();
@@ -343,3 +438,107 @@ describe('TrajectoryCapture — _computeQuality', () => {
     assert.equal(quality, 100);
   });
 });
+
+describe('TrajectoryCapture — onParsedOutput', () => {
+  function makeEnabledTc() {
+    const tc = makeTc();
+    tc._enabled = true;
+    tc._scrubber = { scrub: (s) => s };
+    const ctx = makeCtx();
+    ctx.totalTokens = 0;
+    ctx.stepCount = 0;
+    ctx.allSteps = [];
+    ctx.builder = { addStep: () => null };
+    ctx.classifier = { onStep: (s) => s };
+    tc._contexts.set('agent-loop-1', ctx);
+    return { tc, ctx };
+  }
+
+  it('converts assistant activity to thought step', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', { type: 'activity', subtype: 'assistant', data: 'I will fix the bug' });
+    assert.equal(ctx.stepCount, 1);
+    assert.equal(ctx.allSteps[0].type, 'thought');
+    assert.equal(ctx.allSteps[0].content, 'I will fix the bug');
+  });
+
+  it('converts tool_use activity to action step', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', {
+      type: 'activity', subtype: 'tool_use',
+      data: [{ type: 'tool_use', name: 'Edit', input: { path: 'foo.js' } }],
+    });
+    assert.equal(ctx.stepCount, 1);
+    assert.equal(ctx.allSteps[0].type, 'action');
+    assert.equal(ctx.allSteps[0].tool, 'Edit');
+  });
+
+  it('converts successful tool_result to observation step', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', {
+      type: 'activity', subtype: 'tool_result',
+      data: [{ type: 'tool_result', name: 'Bash', success: true, output: 'tests passed' }],
+    });
+    assert.equal(ctx.stepCount, 1);
+    assert.equal(ctx.allSteps[0].type, 'observation');
+    assert.equal(ctx.allSteps[0].content, 'tests passed');
+  });
+
+  it('converts failed tool_result to error step', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', {
+      type: 'activity', subtype: 'tool_result',
+      data: [{ type: 'tool_result', name: 'Bash', success: false, output: 'command not found' }],
+    });
+    assert.equal(ctx.stepCount, 1);
+    assert.equal(ctx.allSteps[0].type, 'error');
+    assert.equal(ctx.allSteps[0].is_error, true);
+  });
+
+  it('converts result to resolution step', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', { type: 'result', subtype: 'assistant', data: 'Task complete' });
+    assert.equal(ctx.stepCount, 1);
+    assert.equal(ctx.allSteps[0].type, 'resolution');
+    assert.equal(ctx.allSteps[0].content, 'Task complete');
+  });
+
+  it('ignores stream activity (partial deltas)', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', { type: 'activity', subtype: 'stream', data: 'partial' });
+    assert.equal(ctx.stepCount, 0);
+  });
+
+  it('ignores token-only activity', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', { type: 'activity', tokensUsed: 500, inputTokens: 400, outputTokens: 100 });
+    assert.equal(ctx.stepCount, 0);
+  });
+
+  it('silently returns for unknown agent', () => {
+    const { tc } = makeEnabledTc();
+    tc.onParsedOutput('unknown-agent', { type: 'activity', subtype: 'assistant', data: 'hello' });
+  });
+
+  it('silently returns when disabled', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc._enabled = false;
+    tc.onParsedOutput('agent-loop-1', { type: 'activity', subtype: 'assistant', data: 'hello' });
+    assert.equal(ctx.stepCount, 0);
+  });
+
+  it('accumulates tokens across multiple outputs', () => {
+    const { tc, ctx } = makeEnabledTc();
+    tc.onParsedOutput('agent-loop-1', { type: 'activity', subtype: 'assistant', data: 'thinking about the problem' });
+    tc.onParsedOutput('agent-loop-1', {
+      type: 'activity', subtype: 'tool_use',
+      data: [{ type: 'tool_use', name: 'Bash', input: { command: 'ls' } }],
+    });
+    tc.onParsedOutput('agent-loop-1', {
+      type: 'activity', subtype: 'tool_result',
+      data: [{ type: 'tool_result', name: 'Bash', success: true, output: 'file1.js\nfile2.js' }],
+    });
+    assert.equal(ctx.stepCount, 3);
+    assert.ok(ctx.totalTokens > 0);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.103",
+  "version": "0.27.106",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.103",
+  "version": "0.27.106",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.103",
+  "version": "0.27.106",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/src/api.js

@@ -631,9 +631,8 @@ export function createApi(app, daemon) {
 
     write({ status: 'installing', output: `Installing ${pkg}...`, progress: 0 });
 
-    const proc = spawn('npm', ['install', '-g', pkg], {
+    const proc = spawn('bash', ['-lc', `npm install -g ${pkg}`], {
       stdio: ['ignore', 'pipe', 'pipe'],
-      shell: true,
       env: { ...process.env, NODE_ENV: undefined },
     });
 
@@ -758,9 +757,25 @@ export function createApi(app, daemon) {
 
           proc.on('close', (code) => {
             clearTimeout(timeout);
-            respond(code === 0
-              ? { status: 'authenticated' }
-              : { status: 'error', error: stderr.slice(-200) || `Login failed (exit ${code})` });
+            if (code === 0) {
+              let hasKey = false;
+              try {
+                const authPath = resolve(homedir(), '.codex', 'auth.json');
+                if (existsSync(authPath)) {
+                  const auth = JSON.parse(readFileSync(authPath, 'utf8'));
+                  const token = auth.OPENAI_API_KEY
+                    || (auth.auth_mode === 'chatgpt' && auth.tokens?.id_token)
+                    || null;
+                  if (token) {
+                    daemon.credentials.setKey('codex', token);
+                    hasKey = true;
+                  }
+                }
+              } catch { /* auth.json missing or malformed — login still succeeded */ }
+              respond({ status: 'authenticated', hasKey });
+            } else {
+              respond({ status: 'error', error: stderr.slice(-200) || `Login failed (exit ${code})` });
+            }
           });
 
           proc.on('error', (err) => {
@@ -4713,9 +4728,8 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
     write({ status: 'installing', output: `Installing ${pkg}...`, progress: 0 });
 
-    const proc = spawn('npm', ['install', '-g', pkg], {
+    const proc = spawn('bash', ['-lc', `npm install -g ${pkg}`], {
       stdio: ['ignore', 'pipe', 'pipe'],
-      shell: true,
       env: { ...process.env, NODE_ENV: undefined },
     });