atris 3.15.51 → 3.15.53

package/atris/features/README.md

@@ -79,17 +79,20 @@ cp atris/features/_templates/validate.md.template atris/features/your-feature-na
 
 ### Active Features
 
-#### audit-gaps
-Close remaining audit gaps from self-audit
-- **Files:** atris/team/*.md, atris/features/README.md
-- **Status:** complete
-- **Keywords:** audit, persona, cleanup
-- **What:** Add PERSONA.md reference to all 5 agent specs, clean up stale feature statuses
+None.
 
 ---
 
 ### Completed Features
 
+#### audit-gaps
+Close remaining audit gaps from self-audit
+- **Files:** atris/team/*/MEMBER.md, atris/features/README.md, atris/features/audit-gaps/*
+- **Status:** complete
+- **Keywords:** audit, persona, cleanup
+- **What:** Agent member specs reference PERSONA.md for communication style, and stale feature statuses are cleaned up
+- **Completed:** 2026-05-19
+
 #### endstate
 Public benchmark for proving a coordinated stack beats a pinned single-model baseline
 - **Files:** atris/features/endstate/*, commands/autopilot.js, commands/experiments.js, commands/loop.js, lib/wiki.js
@@ -116,7 +119,7 @@ Local-first project wiki with cloud opt-in
 
 #### self-improving-loop
 Make Atris recursive — validate.md lessons feed back into the next idea.md
-- **Files:** atris/lessons.md (new), atris.md, atris/team/navigator.md, atris/team/validator.md, atris/MAP.md
+- **Files:** atris/lessons.md (new), atris.md, atris/team/navigator/MEMBER.md, atris/team/validator/MEMBER.md, atris/MAP.md
 - **Status:** complete
 - **Keywords:** recursion, lessons, feedback-loop, self-improving, lessons.md
 - **What:** lessons.md accumulates validated learnings; navigator reads them before planning; validator harvests them after validating

package/commands/business.js

@@ -909,6 +909,7 @@ function renderBusinessShareHandoff(state, options = {}) {
     `Local path: ${workspacePath}`,
     `Ready to share: ${state.ready ? 'yes' : 'no'}`,
     `Remote pull: ${state.remoteReady ? 'available' : 'local-only'}`,
+    `Agent setup: ${(state.missingRootAgentAdapters && state.missingRootAgentAdapters.length) ? 'missing root agent adapters' : 'ready'}`,
     '',
     '## Get The Workspace',
     '',
@@ -946,9 +947,9 @@ function renderBusinessShareHandoff(state, options = {}) {
     '',
     '## What To Read',
     '',
+    `- Protocol: atris/atris.md`,
     `- Map: atris/MAP.md`,
     `- Queue: atris/TODO.md`,
-    `- Agent adapters: ${state.rootAgentAdapters && state.rootAgentAdapters.length ? state.rootAgentAdapters.join(', ') : 'missing'}`,
     `- Team start: ${state.teamStart || 'missing'}`,
     `- Starter brief: ${state.starterBrief || 'missing'}`,
     `- First loop: ${state.firstLoop || 'missing'}`,
@@ -1014,11 +1015,12 @@ function renderBusinessStartCard(state, options = {}) {
     `Workspace: ${workspacePath}`,
     `Ready: ${state.ready ? 'yes' : 'no'}`,
     `Remote pull: ${state.remoteReady ? 'available' : 'local-only'}`,
+    `Agent setup: ${(state.missingRootAgentAdapters && state.missingRootAgentAdapters.length) ? 'missing root agent adapters' : 'ready'}`,
     '',
     'Read:',
+    `- atris/atris.md`,
     `- atris/MAP.md`,
     `- atris/TODO.md`,
-    `- ${(state.rootAgentAdapters && state.rootAgentAdapters.length === 3) ? state.rootAgentAdapters.join(', ') : 'missing root agent adapters'}`,
     `- ${state.teamStart || 'missing team start guide'}`,
     `- ${state.starterBrief || 'missing starter brief'}`,
     `- ${state.firstLoop || 'missing first loop'}`,

package/commands/computer.js

@@ -1260,6 +1260,18 @@ function formatWorkspaceRef(workspace) {
   return workspace.name ? `${workspace.name} (${workspace.id})` : workspace.id;
 }
 
+function workspaceMatchesInput(workspace, input) {
+  if (!workspace || !input) return false;
+  const wanted = String(input).trim().toLowerCase();
+  if (!wanted) return false;
+  return String(workspace.id || '').toLowerCase() === wanted
+    || String(workspace.name || '').toLowerCase() === wanted;
+}
+
+function resolveWorkspaceFromList(workspaces, input) {
+  return (workspaces || []).find((workspace) => workspaceMatchesInput(workspace, input)) || null;
+}
+
 function formatLeaseAge(seconds) {
   const value = Number(seconds);
   if (!Number.isFinite(value) || value < 0) return '-';
@@ -1519,7 +1531,11 @@ async function computerStatus(token, ctx = null) {
     if (d.endpoint) console.log(`    Endpoint: ${d.endpoint}`);
     const workspaces = await listBusinessWorkspaces(token, ctx);
     const defaultWorkspace = workspaces.find((workspace) => workspace.is_default);
-    const targetWorkspace = workspaces.find((workspace) => workspace.id === ctx.workspaceId) || (ctx.workspaceId ? { id: ctx.workspaceId } : null);
+    const resolvedTargetWorkspace = resolveWorkspaceFromList(workspaces, ctx.workspaceId);
+    const targetWorkspace = resolvedTargetWorkspace || (ctx.workspaceId ? { id: ctx.workspaceId } : null);
+    const probeCtx = resolvedTargetWorkspace?.id
+      ? { ...ctx, workspaceId: resolvedTargetWorkspace.id }
+      : ctx;
     console.log(`    Default workspace:  ${formatWorkspaceRef(defaultWorkspace)}`);
     console.log(`    Target workspace:   ${formatWorkspaceRef(targetWorkspace)}`);
     const attachedFromStatus = d.attached_workspace_id
@@ -1534,8 +1550,8 @@ async function computerStatus(token, ctx = null) {
       console.log(`    Lease age:          ${formatLeaseAge(d.lease_age_seconds)}`);
       if (d.takeover_hint) console.log(`    Takeover hint:      ${d.takeover_hint}`);
     }
-    if (status === 'running' && d.endpoint && ctx.workspaceId) {
-      const attached = await probeAttachedWorkspace(token, ctx);
+    if (status === 'running' && d.endpoint && probeCtx.workspaceId) {
+      const attached = await probeAttachedWorkspace(token, probeCtx);
       if (!attachedFromStatus) {
         const attachedWorkspace = workspaces.find((workspace) => workspace.id === attached.workspaceId) || (attached.workspaceId ? { id: attached.workspaceId } : null);
         console.log(`    Attached workspace: ${formatWorkspaceRef(attachedWorkspace)}`);

package/commands/mission.js

@@ -748,12 +748,18 @@ function missionVerifierPassed(mission) {
 
 function missionDueAt(mission, now = new Date()) {
   const cadenceSeconds = parseCadenceSeconds(mission.cadence);
-  if (!mission.last_tick_at || cadenceSeconds === 0) return true;
+  if (!mission.last_tick_at) return true;
+  if (cadenceSeconds === 0) return !(mission.always_on && missionVerifierPassed(mission));
   const lastTickAt = Date.parse(mission.last_tick_at);
   if (!Number.isFinite(lastTickAt)) return true;
   return now.getTime() - lastTickAt >= cadenceSeconds * 1000;
 }
 
+function missionSelectableForLoop(mission, now = new Date()) {
+  return missionIsRunnable(mission)
+    && !(mission.always_on && missionVerifierPassed(mission) && !missionDueAt(mission, now));
+}
+
 function secondsUntilMissionDue(mission, now = new Date()) {
   const cadenceSeconds = parseCadenceSeconds(mission?.cadence);
   if (!mission || !mission.last_tick_at || cadenceSeconds === 0) return 0;
@@ -763,8 +769,15 @@ function secondsUntilMissionDue(mission, now = new Date()) {
   return Math.max(0, Math.ceil((dueAt - now.getTime()) / 1000));
 }
 
+function missionHasHumanAsks(mission) {
+  return Array.isArray(mission?.human_asks)
+    && mission.human_asks.some((ask) => String(ask || '').trim());
+}
+
 function missionIsRunnable(mission) {
-  return mission && GOAL_LOOP_STATUSES.has(String(mission.status || ''));
+  return mission
+    && GOAL_LOOP_STATUSES.has(String(mission.status || ''))
+    && !missionHasHumanAsks(mission);
 }
 
 function missionSortTime(mission) {
@@ -773,7 +786,7 @@ function missionSortTime(mission) {
 
 function selectDueMission(root = process.cwd(), now = new Date()) {
   const candidates = listMissions(root)
-    .filter(missionIsRunnable)
+    .filter((mission) => missionSelectableForLoop(mission, now))
     .filter((mission) => mission.verifier)
     .filter((mission) => mission.always_on || !missionVerifierPassed(mission))
     .filter((mission) => missionDueAt(mission, now));
@@ -792,7 +805,7 @@ function selectDueMission(root = process.cwd(), now = new Date()) {
 
 function selectCodexGoalMission(root = process.cwd(), now = new Date()) {
   const candidates = listMissions(root)
-    .filter(missionIsRunnable);
+    .filter((mission) => missionSelectableForLoop(mission, now));
 
   candidates.sort((a, b) => {
     const aCaller = runnerUsesCallerSession(a.runner) ? 1 : 0;
@@ -1176,7 +1189,8 @@ function spawnClaudeTick(mission, opts) {
         exitCode: code,
         sessionIds: Array.from(observedSessionIds),
         result: finalText,
-        summary: (finalText || '').split('\n').filter(Boolean)[0]?.slice(0, 240) || (ok ? 'no-text' : 'error'),
+        summary: usefulClaudeReceiptSummary(finalText, ok ? 'no-text' : 'error'),
+        receipt_text: cappedClaudeReceiptText(finalText),
         api_equivalent_estimate: costEstimate,
         duration_api_ms: durationApiMs,
         duration_total_ms: Date.now() - startedAt,
@@ -1196,6 +1210,33 @@ function spawnClaudeTick(mission, opts) {
   });
 }
 
+function stripClaudeReceiptLine(line) {
+  return String(line || '')
+    .trim()
+    .replace(/^#{1,6}\s+/, '')
+    .replace(/^[-*]\s+/, '')
+    .replace(/^\d+[.)]\s+/, '')
+    .trim();
+}
+
+function usefulClaudeReceiptSummary(text, fallback = 'no-text') {
+  const lines = String(text || '').split(/\r?\n/);
+  for (const line of lines) {
+    const clean = stripClaudeReceiptLine(line);
+    if (!clean) continue;
+    if (/^(receipt|summary|final|final answer|result)$/i.test(clean)) continue;
+    return clean.slice(0, 240);
+  }
+  return fallback;
+}
+
+function cappedClaudeReceiptText(text, limit = 4000) {
+  const clean = String(text || '').trim();
+  if (!clean) return '';
+  if (clean.length <= limit) return clean;
+  return clean.slice(0, limit - 16).trimEnd() + '\n...[truncated]';
+}
+
 async function runMission(args) {
   const asJson = wantsJson(args);
   const dueMode = hasFlag(args, '--due');
@@ -1323,7 +1364,7 @@ async function runMission(args) {
       if (mission.verifier !== frozen.verifier) { pauseReason = 'verifier-mutated'; break; }
       if ((mission.lane || 'workspace') !== frozen.lane) { pauseReason = 'lane-mutated'; break; }
 
-      const tickIdx = ticks.length + 1;
+      const tickIdx = Number(mission.last_tick_index || 0) + 1;
       const tickStart = stampIso();
       const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
       let result = { status: 'skipped', reason: 'unknown', tick_index: tickIdx, ran: false, started_at: tickStart };
@@ -1358,6 +1399,7 @@ async function runMission(args) {
         result.claude = {
           ok: claudeResult.ok,
           summary: claudeResult.summary,
+          receipt_text: claudeResult.receipt_text,
           stop_reason: claudeResult.stop_reason,
           api_equivalent_estimate: claudeResult.api_equivalent_estimate,
           duration_total_ms: claudeResult.duration_total_ms,
@@ -1424,7 +1466,7 @@ async function runMission(args) {
       });
 
       const xpReadyAction = missionXpReadyAction(mission, receiptPath);
-      const newStatus = (verifierResult?.passed && mission.always_on) ? 'running' :
+      const newStatus = (verifierResult?.passed && mission.always_on) ? 'ready' :
                         (verifierResult?.passed && xpReadyAction) ? 'ready' :
                         (verifierResult?.passed && completeOnPass) ? 'complete' :
                         (verifierResult?.passed ? 'ready' :
@@ -1448,6 +1490,7 @@ async function runMission(args) {
         last_tick_at: finishedAt,
         last_tick_status: result.status,
         last_tick_reason: result.reason,
+        last_tick_index: tickIdx,
         verifier_result: verifierResult || mission.verifier_result || null,
         receipt_path: receiptPath,
         next_action: nextAction,
@@ -1915,4 +1958,6 @@ module.exports = {
   renderMissionStatus,
   selectDueMission,
   selectCodexGoalMission,
+  usefulClaudeReceiptSummary,
+  cappedClaudeReceiptText,
 };

package/commands/play.js

@@ -327,7 +327,7 @@ function playWorkspaceRoot(taskDb, workspaceArg) {
 }
 
 function nextCommands(task, player) {
-  const helper = 'game-manager';
+  const helper = player || 'player';
   if (!task) {
     return [
       `atris task delegate "AgentXP first rep: one proof-backed mission" --to ${player} --tag agent-xp`,

package/commands/radar.js

@@ -114,18 +114,26 @@ function loadTasks(root, deps) {
   if (!deps.exists(file)) return [];
   const payload = safeJson(deps.readFile(file, 'utf8'), {});
   const tasks = Array.isArray(payload.tasks) ? payload.tasks : [];
-  return tasks.map(task => ({
-    id: task.id,
-    display_id: task.display_id,
-    legacy_ref: task.legacy_ref,
-    title: task.title,
-    status: task.status,
-    tag: task.tag,
-    workspace_root: task.workspace_root,
-    claimed_by: task.claimed_by,
-    assigned_to: task.metadata?.assigned_to || task.assigned_to || null,
-    metadata: task.metadata || {},
-  }));
+  return tasks.map(task => {
+    const messages = Array.isArray(task.messages) ? task.messages : [];
+    const row = {
+      id: task.id,
+      display_id: task.display_id,
+      legacy_ref: task.legacy_ref,
+      title: task.title,
+      status: task.status,
+      tag: task.tag,
+      workspace_root: task.workspace_root,
+      claimed_by: task.claimed_by,
+      assigned_to: task.metadata?.assigned_to || task.assigned_to || null,
+      metadata: task.metadata || {},
+    };
+    Object.defineProperty(row, 'routing_text', {
+      enumerable: false,
+      value: messages.map(message => message && message.content).filter(Boolean).join(' '),
+    });
+    return row;
+  });
 }
 
 function findTaskWorkspaceRoot(cwd, deps) {
@@ -424,6 +432,31 @@ function ownerForTask(task) {
   return task.assigned_to || task.claimed_by || task.metadata?.assigned_to || '-';
 }
 
+function taskSessionReason(task) {
+  if (!task) return null;
+  if (task.status === 'review') return task.metadata?.agent_certified ? 'certified review' : 'review task';
+  if (ownerActionRequired(task)) return 'owner action required';
+  return null;
+}
+
+function taskSessionAction(agent, task, taskWorkspaceRoot) {
+  if (!task) return null;
+  const ref = taskRef(task);
+  const pid = agent?.pid || '?';
+  const actor = agent?.agent || 'agent';
+  const reviewCommand = taskWorkspaceRoot
+    ? `cd ${shellQuote(taskWorkspaceRoot)} && atris task reviews --limit 5`
+    : 'atris task reviews --limit 5';
+  if (task.status === 'review') {
+    if (task.metadata?.agent_certified) {
+      return `handoff complete for ${ref}; close pid ${pid} or claim fresh work as ${actor}`;
+    }
+    return `review or hand off ${ref}: ${reviewCommand}`;
+  }
+  if (ownerActionRequired(task)) return `owner-gated ${ref}; close pid ${pid} or wait for owner action`;
+  return null;
+}
+
 function summarize(tasks, missions, worktrees, agents) {
   const count = (rows, pred) => rows.filter(pred).length;
   return {
@@ -439,9 +472,31 @@ function summarize(tasks, missions, worktrees, agents) {
   };
 }
 
+function ownerActionRequired(task) {
+  const metadata = task?.metadata || {};
+  if (metadata.owner_action_required === true || metadata.agent_executable === false) return true;
+  if (String(metadata.agent_executable || '').toLowerCase() === 'false') return true;
+  const text = [
+    task?.title,
+    task?.tag,
+    metadata.status,
+    metadata.blocker,
+    metadata.human_revision_note,
+    metadata.latest_agent_proof,
+    metadata.latest_agent_lesson,
+    task?.routing_text,
+  ].filter(Boolean).join(' ').toLowerCase();
+  if (text.includes('owner_action_required') || text.includes('agent_executable=false')) return true;
+  if (text.includes('owner-only') || text.includes('owner only') || text.includes('not agent-executable')) return true;
+  return text.includes('owner') && text.includes('billing') && (text.includes('spending limit') || text.includes('failed payments'));
+}
+
 function nextAction(tasks, missions, worktrees, agents, os = {}) {
-  const activeTask = tasks.find(t => t.status === 'claimed' || t.status === 'open');
+  const activeTasks = tasks.filter(t => t.status === 'claimed' || t.status === 'open');
+  const activeTask = activeTasks.find(t => !ownerActionRequired(t));
   if (activeTask) return `work ${taskRef(activeTask)}: ${activeTask.title || 'active task'}`;
+  const ownerTask = activeTasks.find(ownerActionRequired);
+  if (ownerTask) return `owner action required ${taskRef(ownerTask)}: ${ownerTask.title || 'owner-only task'}`;
   const needsReview = tasks.find(t => t.status === 'review' && !(t.metadata && t.metadata.agent_certified));
   if (needsReview) return `review ${taskRef(needsReview)}: ${needsReview.title || 'uncertified review task'}`;
   const certified = tasks.find(t => t.status === 'review' && t.metadata && t.metadata.agent_certified);
@@ -475,7 +530,7 @@ function collectRadar(options = {}) {
     const taskWorkspaceRoot = findTaskWorkspaceRoot(agent.cwd, deps);
     const agentTasks = taskWorkspaceRoot ? loadTasksCached(taskWorkspaceRoot, deps, taskCache) : [];
     const task = taskForCwd(agentTasks, agent.cwd, taskWorkspaceRoot);
-    const taskReason = task ? null : untaskedReason(agent, taskWorkspaceRoot, agentTasks);
+    const taskReason = task ? taskSessionReason(task) : untaskedReason(agent, taskWorkspaceRoot, agentTasks);
     return {
       ...agent,
       task: taskRef(task),
@@ -483,7 +538,7 @@ function collectRadar(options = {}) {
       owner: ownerForTask(task),
       task_workspace: taskWorkspaceRoot ? repoLabel(taskWorkspaceRoot) : null,
       task_reason: taskReason,
-      task_action: task ? null : untaskedAction(agent, taskWorkspaceRoot, agentTasks),
+      task_action: task ? taskSessionAction(agent, task, taskWorkspaceRoot) : untaskedAction(agent, taskWorkspaceRoot, agentTasks),
     };
   });
   const osState = {
@@ -594,6 +649,11 @@ function sortedAgents(agents = []) {
 function agentProcessNextAction(agents = [], fallback = 'no obvious process action') {
   const stopped = agents.filter(agent => agent.status !== 'active').length;
   if (stopped > 0) return `inspect ${stopped} stopped agent session${stopped === 1 ? '' : 's'}`;
+  const ownerGated = agents.filter(agent => agent.task_reason === 'owner action required');
+  if (ownerGated.length > 0) {
+    const tasks = [...new Set(ownerGated.map(agent => agent.task).filter(Boolean))].slice(0, 3).join(', ');
+    return `owner gate blocks ${ownerGated.length} session${ownerGated.length === 1 ? '' : 's'}${tasks ? ` on ${tasks}` : ''}; wait for owner action or close idle sessions`;
+  }
   const taskLoad = summarizeTaskLoad(agents);
   const reviewBound = taskLoad.find(row => row.status.split(/,\s*/).includes('review'));
   if (reviewBound) return `close or hand off ${reviewBound.sessions} session${reviewBound.sessions === 1 ? '' : 's'} still bound to review task ${reviewBound.task}`;
@@ -714,6 +774,22 @@ function renderAgentTop(data) {
       lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'}: ${agent.task_reason || 'unmapped'} -> ${agent.task_action || 'inspect session'}`);
     }
   }
+  const ownerGatedAgents = payload.agents.filter(row => row.task_reason === 'owner action required').slice(0, 8);
+  if (ownerGatedAgents.length) {
+    lines.push('');
+    lines.push(`Owner-gated: ${ownerGatedAgents.length} session${ownerGatedAgents.length === 1 ? '' : 's'} waiting on owner-only tasks.`);
+    for (const agent of ownerGatedAgents) {
+      lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'} ${agent.task}: ${agent.task_action || 'wait for owner action'}`);
+    }
+  }
+  const reviewBoundAgents = payload.agents.filter(row => row.task_status === 'review').slice(0, 8);
+  if (reviewBoundAgents.length) {
+    lines.push('');
+    lines.push(`Review-bound: ${reviewBoundAgents.length} session${reviewBoundAgents.length === 1 ? '' : 's'} still tied to Review tasks.`);
+    for (const agent of reviewBoundAgents) {
+      lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'} ${agent.task}: ${agent.task_reason || 'review'} -> ${agent.task_action || 'close or hand off session'}`);
+    }
+  }
   const taskLoadRows = payload.task_load.filter(row => row.attention).slice(0, 8);
   if (taskLoadRows.length) {
     lines.push('');

package/commands/task.js

@@ -1708,7 +1708,7 @@ function cmdReady(args) {
     next_action: agentCertified ? 'continue_work' : 'agent_review_again',
     rule: agentCertified
       ? 'Agent double-check complete; continue work. AgentXP waits for human accept.'
-      : 'Proof is in Review; one more agent review pass certifies continuation. AgentXP waits for human accept.',
+      : 'Proof is in Review; human accept can award AgentXP now. A second agent review only certifies autonomous continuation.',
   };
   if (wantsJson(args)) {
     printJson({

package/commands/worktree.js

@@ -285,6 +285,12 @@ function createOrFindPr(root, branch, targetRef, title, dryRun) {
   return created.stdout.trim();
 }
 
+function prMergeRef(prOutput) {
+  const text = String(prOutput || '').trim();
+  if (!text || text.startsWith('dry-run:')) return '';
+  return text.split(/\s+/)[0];
+}
+
 function shipWorktree(args) {
   const root = repoRoot();
   const dryRun = hasFlag(args, '--dry-run');
@@ -359,8 +365,20 @@ function shipWorktree(args) {
     if (merge) {
       console.log('merge: requested');
       if (!dryRun) {
-        const merged = spawnSync('gh', ['pr', 'merge', '--merge', '--delete-branch'], { cwd: root, encoding: 'utf8' });
+        const mergeRef = prMergeRef(pr);
+        const mergeArgs = ['pr', 'merge'];
+        if (mergeRef) mergeArgs.push(mergeRef);
+        mergeArgs.push('--merge');
+        const merged = spawnSync('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
         if (merged.status !== 0) throw new Error((merged.stderr || merged.stdout || 'gh pr merge failed').trim());
+        console.log('merge: merged');
+        const deleted = runGit(['push', 'origin', '--delete', branch], { cwd: root, check: false });
+        if (deleted.status === 0) {
+          console.log(`merge: remote branch deleted ${branch}`);
+        } else {
+          const deleteOutput = (deleted.stderr || deleted.stdout || 'remote branch delete failed').trim();
+          console.log(`merge: remote branch delete skipped: ${deleteOutput}`);
+        }
       }
     }
   } else {
@@ -461,6 +479,7 @@ module.exports = {
   defaultWorktreePath,
   parseWorktrees,
   normalizeTargetRef,
+  prMergeRef,
   slugify,
   statusCounts,
   swarloClaim,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.15.51",
+  "version": "3.15.53",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",