@soleri/core 9.7.2 → 9.9.0

package/src/planning/evidence-collector.test.ts

@@ -340,6 +340,101 @@ describe('collectGitEvidence', () => {
   });
 });
 
+describe('collectGitEvidence — rework tracking', () => {
+  it('includes fixIterations in task evidence when present', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          fixIterations: 2,
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.taskEvidence[0].fixIterations).toBe(2);
+  });
+
+  it('omits fixIterations when task has zero rework', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.taskEvidence[0].fixIterations).toBeUndefined();
+  });
+
+  it('includes rework count in summary when tasks were reworked', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\nM\tsrc/auth/login.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          fixIterations: 1,
+          updatedAt: Date.now(),
+        },
+        {
+          id: 'task-2',
+          title: 'Add login endpoint',
+          description: 'Login endpoint',
+          status: 'completed',
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.summary).toContain('1 required rework');
+  });
+
+  it('does not include rework in summary when no tasks were reworked', () => {
+    mockExecFileSync
+      .mockReturnValueOnce('feature/auth\n')
+      .mockReturnValueOnce('M\tsrc/auth/middleware.ts\n');
+
+    const plan = makePlan({
+      tasks: [
+        {
+          id: 'task-1',
+          title: 'Add auth middleware',
+          description: 'Auth middleware',
+          status: 'completed',
+          updatedAt: Date.now(),
+        },
+      ],
+    });
+    const report = collectGitEvidence(plan, '/project', 'main');
+
+    expect(report.summary).not.toContain('rework');
+  });
+});
+
 describe('collectVerificationGaps', () => {
   it('returns empty array when no tasks have verification', () => {
     const tasks: PlanTask[] = [makeTask()];

package/src/planning/evidence-collector.ts

@@ -19,6 +19,8 @@ export interface GitTaskEvidence {
   plannedStatus: string;
   matchedFiles: FileChange[];
   verdict: 'DONE' | 'PARTIAL' | 'MISSING' | 'SKIPPED';
+  /** Number of rework cycles this task went through (0 = first pass). */
+  fixIterations?: number;
 }
 
 export interface UnplannedChange {
@@ -72,6 +74,8 @@ export function collectGitEvidence(
       plannedStatus: task.status,
       matchedFiles: matches,
       verdict,
+      ...(task.fixIterations !== undefined &&
+        task.fixIterations > 0 && { fixIterations: task.fixIterations }),
     });
   }
 
@@ -93,12 +97,17 @@ export function collectGitEvidence(
       ? Math.round(((doneTasks + partialTasks * 0.5 + skippedTasks * 0.25) / totalTasks) * 100)
       : 100;
 
+  const reworkedTasks = taskEvidence.filter(
+    (te) => te.fixIterations && te.fixIterations > 0,
+  ).length;
+
   const summary = buildSummary(
     totalTasks,
     doneTasks,
     partialTasks,
     missingWork.length,
     unplannedChanges.length,
+    reworkedTasks,
   );
 
   const verificationGaps = collectVerificationGaps(plan.tasks, taskEvidence);
@@ -284,11 +293,13 @@ function buildSummary(
   partial: number,
   missing: number,
   unplanned: number,
+  reworked: number = 0,
 ): string {
   const parts: string[] = [];
   parts.push(`${done}/${total} tasks verified by git evidence`);
   if (partial > 0) parts.push(`${partial} partially done`);
   if (missing > 0) parts.push(`${missing} with no file evidence`);
   if (unplanned > 0) parts.push(`${unplanned} unplanned file changes`);
+  if (reworked > 0) parts.push(`${reworked} required rework`);
   return parts.join(', ');
 }

package/src/planning/gap-patterns.ts

@@ -172,12 +172,16 @@ export function analyzeStructure(plan: Plan): PlanGap[] {
   }
 
   if (plan.tasks.length === 0) {
+    const hasApproachSteps =
+      plan.approach && /(?:step\s+\d|task\s+\d|\d\.\s|\d\)\s)/i.test(plan.approach);
     gaps.push(
       gap(
-        'critical',
+        hasApproachSteps ? 'major' : 'critical',
         'structure',
-        'Plan has no tasks.',
-        'Add at least one task to make the plan actionable.',
+        hasApproachSteps
+          ? 'Plan has no tasks but approach contains steps. Use `addTasks` in `plan_iterate` or pass `tasks` in `create_plan` to promote them.'
+          : 'Plan has no tasks.',
+        'Add tasks via `create_plan` (tasks param) or `plan_iterate` (addTasks param).',
         'tasks',
         'no_tasks',
       ),

package/src/planning/plan-lifecycle.test.ts

@@ -342,6 +342,55 @@ describe('plan-lifecycle', () => {
       expect(task.completedAt).toBeGreaterThan(0);
       expect(task.status).toBe('failed');
     });
+
+    it('increments fixIterations on completed → in_progress rework', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      applyTaskStatusUpdate(task, 'completed');
+      expect(task.fixIterations).toBeUndefined();
+      // Rework: send back from completed to in_progress
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.fixIterations).toBe(1);
+      expect(task.completedAt).toBeUndefined();
+    });
+
+    it('increments fixIterations on failed → in_progress rework', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      applyTaskStatusUpdate(task, 'failed');
+      // Rework from failed
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.fixIterations).toBe(1);
+      expect(task.completedAt).toBeUndefined();
+    });
+
+    it('accumulates fixIterations across multiple rework cycles', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      applyTaskStatusUpdate(task, 'completed');
+      applyTaskStatusUpdate(task, 'in_progress'); // rework 1
+      applyTaskStatusUpdate(task, 'completed');
+      applyTaskStatusUpdate(task, 'in_progress'); // rework 2
+      expect(task.fixIterations).toBe(2);
+    });
+
+    it('does not increment fixIterations on pending → in_progress', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.fixIterations).toBeUndefined();
+    });
+
+    it('resets completedAt on rework but preserves startedAt', () => {
+      const task = makeTask();
+      applyTaskStatusUpdate(task, 'in_progress');
+      const originalStartedAt = task.startedAt;
+      applyTaskStatusUpdate(task, 'completed');
+      expect(task.completedAt).toBeGreaterThan(0);
+      // Rework
+      applyTaskStatusUpdate(task, 'in_progress');
+      expect(task.completedAt).toBeUndefined();
+      expect(task.startedAt).toBe(originalStartedAt);
+    });
   });
 
   describe('createPlanObject', () => {

package/src/planning/plan-lifecycle.ts

@@ -338,6 +338,11 @@ export function applyIteration(plan: Plan, changes: IterateChanges): number {
  */
 export function applyTaskStatusUpdate(task: PlanTask, status: TaskStatus): void {
   const now = Date.now();
+  // Rework detection: completed/failed → in_progress means a fix iteration
+  if (status === 'in_progress' && (task.status === 'completed' || task.status === 'failed')) {
+    task.fixIterations = (task.fixIterations ?? 0) + 1;
+    task.completedAt = undefined;
+  }
   if (status === 'in_progress' && !task.startedAt) task.startedAt = now;
   if (status === 'completed' || status === 'skipped' || status === 'failed') {
     task.completedAt = now;

package/src/planning/planner-types.ts

@@ -88,6 +88,8 @@ export interface PlanTask {
   deliverables?: TaskDeliverable[];
   /** Verification findings for tasks that modify existing code. Advisory only. */
   verification?: TaskVerification;
+  /** Number of times this task was sent back for rework (completed → in_progress). */
+  fixIterations?: number;
   updatedAt: number;
 }
 

package/src/runtime/capture-ops.test.ts

@@ -14,12 +14,14 @@ vi.mock('../vault/scope-detector.js', () => ({
   })),
 }));
 
+const mockSyncEntryToMarkdown = vi.fn(() => Promise.resolve({ written: true }));
 vi.mock('../vault/vault-markdown-sync.js', () => ({
-  syncEntryToMarkdown: vi.fn(() => Promise.resolve()),
+  syncEntryToMarkdown: (...args: unknown[]) => mockSyncEntryToMarkdown(...args),
 }));
 
 vi.mock('../paths.js', () => ({
   agentKnowledgeDir: vi.fn(() => '/mock/knowledge'),
+  projectKnowledgeDir: vi.fn((p: string) => `/mock/project/${p}/knowledge`),
 }));
 
 // ─── Mock Runtime Factory ──────────────────────────────────────────────
@@ -213,6 +215,32 @@ describe('createCaptureOps', () => {
       const results = result.results as Array<Record<string, unknown>>;
       expect((results[0].scope as Record<string, unknown>).tier).toBe('agent');
     });
+
+    it('triggers markdown file write on successful capture', async () => {
+      mockSyncEntryToMarkdown.mockClear();
+      await findOp(ops, 'capture_knowledge').handler({
+        entries: [
+          { type: 'pattern', domain: 'testing', title: 'Sync Test', description: 'test', tags: [] },
+        ],
+      });
+      // fire-and-forget: allow microtask to flush
+      await new Promise((r) => setTimeout(r, 10));
+      expect(mockSyncEntryToMarkdown).toHaveBeenCalledWith(
+        expect.objectContaining({ domain: 'testing', title: 'Sync Test' }),
+        '/mock/knowledge',
+      );
+    });
+
+    it('does not block capture response when sync fails', async () => {
+      mockSyncEntryToMarkdown.mockClear();
+      mockSyncEntryToMarkdown.mockRejectedValueOnce(new Error('disk full'));
+      const result = (await findOp(ops, 'capture_knowledge').handler({
+        entries: [{ type: 'pattern', domain: 'a', title: 'A', description: 'a', tags: [] }],
+      })) as Record<string, unknown>;
+      // Capture should still succeed despite sync error
+      expect(result.captured).toBe(1);
+      expect(result.rejected).toBe(0);
+    });
   });
 
   describe('capture_quick', () => {
@@ -323,6 +351,35 @@ describe('createCaptureOps', () => {
       expect(result.captured).toBe(false);
       expect((result.governance as Record<string, unknown>).action).toBe('error');
     });
+
+    it('triggers markdown file write on successful capture', async () => {
+      mockSyncEntryToMarkdown.mockClear();
+      await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Quick Sync Test',
+        description: 'quick test',
+      });
+      // fire-and-forget: allow microtask to flush
+      await new Promise((r) => setTimeout(r, 10));
+      expect(mockSyncEntryToMarkdown).toHaveBeenCalledWith(
+        expect.objectContaining({ domain: 'testing', title: 'Quick Sync Test' }),
+        '/mock/knowledge',
+      );
+    });
+
+    it('does not block capture response when sync fails', async () => {
+      mockSyncEntryToMarkdown.mockClear();
+      mockSyncEntryToMarkdown.mockRejectedValueOnce(new Error('disk full'));
+      const result = (await findOp(ops, 'capture_quick').handler({
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Quick Fail',
+        description: 'test',
+      })) as Record<string, unknown>;
+      // Capture should still succeed despite sync error
+      expect(result.captured).toBe(true);
+    });
   });
 
   describe('search_intelligent', () => {

package/src/runtime/capture-ops.ts

@@ -11,7 +11,7 @@ import type { AgentRuntime } from './types.js';
 import { detectScope } from '../vault/scope-detector.js';
 import type { ScopeTier, ScopeDetectionResult } from '../vault/scope-detector.js';
 import { syncEntryToMarkdown } from '../vault/vault-markdown-sync.js';
-import { agentKnowledgeDir } from '../paths.js';
+import { agentKnowledgeDir, projectKnowledgeDir } from '../paths.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 
 /**
@@ -189,6 +189,7 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
                         origin: 'user',
                       },
                       config.agentId,
+                      projectPath,
                     );
                   }
                 } catch (err) {
@@ -417,6 +418,7 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
                     origin: 'user',
                   },
                   config.agentId,
+                  projectPath,
                 );
                 return result;
               } catch (err) {
@@ -629,9 +631,18 @@ function mapType(type: string): 'pattern' | 'anti-pattern' | 'rule' | 'playbook'
 }
 
 /** Fire-and-forget markdown sync — never blocks capture, logs errors silently. */
-function fireAndForgetSync(entry: IntelligenceEntry, agentId: string): void {
-  const knowledgeDir = agentKnowledgeDir(agentId);
-  syncEntryToMarkdown(entry, knowledgeDir).catch(() => {
+function fireAndForgetSync(entry: IntelligenceEntry, agentId: string, projectPath?: string): void {
+  // Always sync to agent home dir
+  const agentDir = agentKnowledgeDir(agentId);
+  syncEntryToMarkdown(entry, agentDir).catch(() => {
     /* non-blocking — markdown sync is best-effort */
   });
+
+  // Also sync to project-local knowledge dir if a real project path is provided
+  if (projectPath && projectPath !== '.') {
+    const projDir = projectKnowledgeDir(projectPath);
+    syncEntryToMarkdown(entry, projDir).catch(() => {
+      /* non-blocking — markdown sync is best-effort */
+    });
+  }
 }

package/src/runtime/facades/curator-facade.test.ts

@@ -3,24 +3,43 @@ import { createCuratorFacadeOps } from './curator-facade.js';
 import type { OpDefinition } from '../../facades/types.js';
 import type { AgentRuntime } from '../types.js';
 
+interface MockLinkManager {
+  backfillLinks: ReturnType<typeof vi.fn>;
+  getOrphans: ReturnType<typeof vi.fn>;
+}
+
+function getLinkManager(rt: AgentRuntime): MockLinkManager {
+  return (rt as unknown as { linkManager: MockLinkManager }).linkManager;
+}
+
 function mockRuntime(): AgentRuntime {
   return {
     curator: {
-      getStatus: vi.fn().mockReturnValue({ initialized: true, entriesGroomed: 5 }),
+      getStatus: vi
+        .fn()
+        .mockReturnValue({ initialized: true, entriesGroomed: 5, tables: { entries: 100 } }),
       detectDuplicates: vi.fn().mockReturnValue([]),
       detectContradictions: vi.fn(),
       getContradictions: vi.fn().mockReturnValue([]),
       resolveContradiction: vi.fn().mockReturnValue({ resolved: true }),
       groomEntry: vi.fn().mockReturnValue({ groomed: true }),
       groomAll: vi.fn().mockReturnValue({ groomed: 10 }),
-      consolidate: vi.fn().mockReturnValue({ duplicates: 0, stale: 0 }),
-      healthAudit: vi.fn().mockReturnValue({ score: 85 }),
+      consolidate: vi.fn().mockReturnValue({ duplicates: 0, stale: 0, durationMs: 10 }),
+      healthAudit: vi.fn().mockReturnValue({
+        score: 85,
+        metrics: { coverage: 1, freshness: 1, quality: 1, tagHealth: 1 },
+        recommendations: [],
+      }),
       getVersionHistory: vi.fn().mockReturnValue([]),
       recordSnapshot: vi.fn().mockReturnValue({ recorded: true }),
       getQueueStats: vi.fn().mockReturnValue({ total: 20, groomed: 15 }),
       enrichMetadata: vi.fn().mockReturnValue({ enriched: true }),
       detectContradictionsHybrid: vi.fn().mockReturnValue([]),
     },
+    linkManager: {
+      backfillLinks: vi.fn().mockReturnValue({ processed: 5, linksCreated: 3, durationMs: 50 }),
+      getOrphans: vi.fn().mockReturnValue([]),
+    },
     jobQueue: {
       enqueue: vi.fn().mockImplementation((_type, _params) => `job-${Date.now()}`),
       getStats: vi.fn().mockReturnValue({ pending: 0, running: 0 }),
@@ -91,7 +110,7 @@ describe('createCuratorFacadeOps', () => {
   describe('curator_status', () => {
     it('returns curator status', async () => {
       const result = await findOp(ops, 'curator_status').handler({});
-      expect(result).toEqual({ initialized: true, entriesGroomed: 5 });
+      expect(result).toEqual({ initialized: true, entriesGroomed: 5, tables: { entries: 100 } });
     });
   });
 
@@ -168,15 +187,18 @@ describe('createCuratorFacadeOps', () => {
   });
 
   describe('curator_consolidate', () => {
-    it('consolidates with default params', async () => {
+    it('consolidates with default params and includes linksCreated', async () => {
       const result = await findOp(ops, 'curator_consolidate').handler({});
-      expect(result).toEqual({ duplicates: 0, stale: 0 });
+      expect(result).toEqual({ duplicates: 0, stale: 0, durationMs: 10, linksCreated: 3 });
       expect(runtime.curator.consolidate).toHaveBeenCalledWith({
         dryRun: undefined,
         staleDaysThreshold: undefined,
         duplicateThreshold: undefined,
         contradictionThreshold: undefined,
       });
+      expect(getLinkManager(runtime).backfillLinks).toHaveBeenCalledWith({
+        dryRun: undefined,
+      });
     });
 
     it('consolidates with custom params', async () => {
@@ -193,12 +215,68 @@ describe('createCuratorFacadeOps', () => {
         contradictionThreshold: 0.3,
       });
     });
+
+    it('returns linksCreated: 0 when linkManager throws', async () => {
+      const lm = getLinkManager(runtime);
+      vi.mocked(lm.backfillLinks).mockImplementation(() => {
+        throw new Error('link module unavailable');
+      });
+      const result = (await findOp(ops, 'curator_consolidate').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.linksCreated).toBe(0);
+    });
   });
 
   describe('curator_health_audit', () => {
-    it('returns audit result', async () => {
-      const result = await findOp(ops, 'curator_health_audit').handler({});
-      expect(result).toEqual({ score: 85 });
+    it('returns audit result with orphan metrics', async () => {
+      const result = (await findOp(ops, 'curator_health_audit').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.score).toBe(85);
+      expect(result.orphanCount).toBe(0);
+      expect(result.orphanPercentage).toBe(0);
+    });
+
+    it('reduces quality when orphan percentage > 10%', async () => {
+      const lm = getLinkManager(runtime);
+      // 15 orphans out of 100 entries = 15%
+      vi.mocked(lm.getOrphans).mockReturnValue(
+        Array.from({ length: 15 }, (_, i) => ({
+          id: `orphan-${i}`,
+          title: `o${i}`,
+          type: 'pattern',
+          domain: 'test',
+        })),
+      );
+      const result = (await findOp(ops, 'curator_health_audit').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.orphanCount).toBe(15);
+      expect(result.orphanPercentage).toBe(15);
+      const metrics = result.metrics as Record<string, number>;
+      expect(metrics.quality).toBe(0.7); // 1 * 0.7
+      expect(
+        (result.recommendations as string[]).some(
+          (r: string) => r.includes('orphan entries') && r.includes('no links'),
+        ),
+      ).toBe(true);
+    });
+
+    it('succeeds when linkManager throws', async () => {
+      const lm = getLinkManager(runtime);
+      vi.mocked(lm.getOrphans).mockImplementation(() => {
+        throw new Error('link module unavailable');
+      });
+      const result = (await findOp(ops, 'curator_health_audit').handler({})) as Record<
+        string,
+        unknown
+      >;
+      expect(result.orphanCount).toBe(0);
+      expect(result.orphanPercentage).toBe(0);
     });
   });
 

package/src/runtime/facades/curator-facade.ts

@@ -108,7 +108,7 @@ export function createCuratorFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     {
       name: 'curator_consolidate',
       description:
-        'Consolidate vault — find duplicates, stale entries, contradictions. Dry-run by default.',
+        'Consolidate vault — find duplicates, stale entries, contradictions, and backfill Zettelkasten links for orphan entries. Dry-run by default.',
       auth: 'write',
       schema: z.object({
         dryRun: z.boolean().optional().describe('Default true. Set false to apply mutations.'),
@@ -126,21 +126,77 @@ export function createCuratorFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           .describe('Contradiction threshold. Default 0.4.'),
       }),
       handler: async (params) => {
-        return curator.consolidate({
+        const result = curator.consolidate({
           dryRun: params.dryRun as boolean | undefined,
           staleDaysThreshold: params.staleDaysThreshold as number | undefined,
           duplicateThreshold: params.duplicateThreshold as number | undefined,
           contradictionThreshold: params.contradictionThreshold as number | undefined,
         });
+
+        // Backfill Zettelkasten links for orphan entries
+        let linksCreated = 0;
+        try {
+          const { linkManager } = runtime;
+          if (linkManager) {
+            const backfillResult = linkManager.backfillLinks({
+              dryRun: params.dryRun as boolean | undefined,
+            });
+            linksCreated = backfillResult.linksCreated;
+          }
+        } catch {
+          // Link module unavailable — degrade gracefully
+        }
+
+        return { ...result, linksCreated };
       },
     },
     {
       name: 'curator_health_audit',
       description:
-        'Audit vault health — score (0-100), coverage, freshness, quality, tag health, recommendations.',
+        'Audit vault health — score (0-100), coverage, freshness, quality, tag health, orphan count, recommendations.',
       auth: 'read',
       handler: async () => {
-        return curator.healthAudit();
+        const result = curator.healthAudit();
+
+        // Enrich with orphan statistics from link manager
+        let orphanCount = 0;
+        let orphanPercentage = 0;
+        try {
+          const { linkManager } = runtime;
+          if (linkManager) {
+            // getOrphans returns up to limit entries; use a high limit to count all
+            const orphans = linkManager.getOrphans(10000);
+            orphanCount = orphans.length;
+            // Compute percentage against total entries via curator status
+            const status = curator.getStatus();
+            const totalEntries = Object.values(status.tables).reduce(
+              (sum, count) => sum + count,
+              0,
+            );
+            orphanPercentage =
+              totalEntries > 0 ? Math.round((orphanCount / totalEntries) * 100) : 0;
+          }
+        } catch {
+          // Link module unavailable — degrade gracefully
+        }
+
+        // Apply quality penalty if orphan percentage > 10%
+        const metrics = { ...result.metrics };
+        const recommendations = [...result.recommendations];
+        if (orphanPercentage > 10) {
+          metrics.quality = Math.round(metrics.quality * 0.7 * 100) / 100;
+          recommendations.push(
+            `${orphanCount} orphan entries (${orphanPercentage}%) have no links — run consolidation to backfill.`,
+          );
+        }
+
+        return {
+          ...result,
+          metrics,
+          recommendations,
+          orphanCount,
+          orphanPercentage,
+        };
       },
     },