DeepSeek Harness: Four Running Modes

🤖 Agent: 
🔍 Using tool: search
  → Searching for src/utils/format.ts

🔍 Using tool: file_edit (read)
  → Reading src/utils/format.ts

📝 Using tool: file_edit (create)
  → Creating src/utils/date-format.ts

📝 Using tool: file_edit (edit)
  → Updating src/utils/format.ts (removing date functions)

📝 Using tool: file_edit (edit)
  → Updating imports in src/index.ts

✅ Done! Date formatting function extracted to src/utils/date-format.ts

👤 Bob: Add a user authentication system to the project, supporting JWT

🤖 Agent (Plan Phase):
📋 Execution Plan:
  1. Install dependencies: jsonwebtoken, bcryptjs
  2. Create src/auth/jwt.ts — JWT signing and verification
  3. Create src/auth/middleware.ts — Authentication middleware
  4. Create src/routes/auth.ts — Login/register routes
  5. Modify src/app.ts — Register routes and middleware
  6. Add environment variable JWT_SECRET

Estimated: 5 files modified, 3 files created.
Execute this plan?

👤 Bob: Execute, but skip step 1 — dependencies are already installed

🤖 Agent (Code Phase):
📝 Step 2: Creating src/auth/jwt.ts...
📝 Step 3: Creating src/auth/middleware.ts...
📝 Step 4: Creating src/routes/auth.ts...
📝 Step 5: Editing src/app.ts...
📝 Step 6: Adding JWT_SECRET to .env.example...

✅ Authentication system added!

interface PTCPlan {
  steps: PlanStep[];
  estimatedFiles: { created: number; modified: number; deleted: number };
  riskLevel: 'low' | 'medium' | 'high';
  reversible: boolean;
}

interface PlanStep {
  id: number;
  description: string;
  tool: string;           // Tool to use
  files: string[];        // Files involved
  dependsOn: number[];    // Prerequisite steps
}

🤖 Agent: 
Promise is an object representation of async operations; async/await is syntactic sugar for Promises:

1. Promise uses .then() chaining:
   fetchData().then(data => process(data)).catch(err => handle(err));

2. async/await uses synchronous-looking syntax:
   const data = await fetchData();
   process(data);

Key differences:
- Promise is an object; async/await is syntax
- await can only be used inside async functions
- async functions always return Promises
- Error handling: .catch() vs try/catch

👤 Alice: Design a unique 404 page for me

🤖 Agent: 
🎨 I'll design an interactive 404 page — using Canvas to draw an asteroid field where users can move the mouse to dodge meteors!

📝 Using tool: file_edit (create)
  → Creating src/pages/404.html

🎨 Features:
- Canvas-rendered dynamic starfield background
- Mouse-controlled spaceship movement
- Random meteor generation and collision detection
- Increasing difficulty over time
- After collision, shows "You found 404!" and redirects to home

🔧 Additional ideas:
- Add sound effects using Web Audio API
- Mobile touch support
- Score leaderboard (localStorage)

Top control bar → Mode dropdown → Select target mode

# Specify at startup
npx @deepseek-ai/dsh cli --mode ptc

# Switch during session
/mode creative

# dsh.config.yaml
default_mode: ptc

Project Planning Phase → PTC Mode (plan first)
  ↓
Implementation Phase → Standard Mode (autonomous execution)
  ↓
Troubleshooting → Minimal Mode (quick Q&A)
  ↓
UI Design → Creative Mode (explore ideas)

interface ModeConfig {
  name: string;
  allowTools: boolean;
  requirePlan: boolean;
  temperature: number;
  maxToolCalls: number | null;
  systemPromptExtra: string;
}

const MODES: Record<string, ModeConfig> = {
  standard: {
    name: 'standard',
    allowTools: true,
    requirePlan: false,
    temperature: 0.7,
    maxToolCalls: null,
    systemPromptExtra: 'You have full autonomy to use tools as needed.'
  },
  ptc: {
    name: 'ptc',
    allowTools: true,
    requirePlan: true,
    temperature: 0.3,
    maxToolCalls: null,
    systemPromptExtra: 'Always create a plan first. Do not execute until the user confirms.'
  },
  minimal: {
    name: 'minimal',
    allowTools: true,
    requirePlan: false,
    temperature: 0.2,
    maxToolCalls: 1,
    systemPromptExtra: 'Minimize tool usage. Prefer answering from knowledge.'
  },
  creative: {
    name: 'creative',
    allowTools: true,
    requirePlan: false,
    temperature: 1.0,
    maxToolCalls: null,
    systemPromptExtra: 'Be creative, explore unusual approaches, think beyond the obvious.'
  }
};

Standard mode appends:
"Use tools freely when they help accomplish the task."

PTC mode appends:
"Before any action, output a numbered plan. Wait for user confirmation before executing."

Minimal mode appends:
"Answer from your knowledge first. Only use tools when absolutely necessary."

Creative mode appends:
"Think creatively and explore novel approaches. Offer additional ideas beyond the request."