@kadaliao/dsh-bots 0.7.1 → 0.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +255 -45
- package/README.zh-CN.md +182 -31
- package/client.js +2622 -246
- package/index.js +2472 -133
- package/lib/activity.mjs +221 -0
- package/lib/cards.mjs +582 -0
- package/lib/channels/discord.mjs +91 -11
- package/lib/channels/feishu.mjs +37 -9
- package/lib/channels/slack.mjs +26 -8
- package/lib/channels/telegram.mjs +37 -6
- package/lib/channels.mjs +399 -89
- package/lib/memory.mjs +37 -0
- package/lib/prompt.mjs +221 -20
- package/lib/settings.mjs +41 -2
- package/lib/store.mjs +60 -6
- package/lib/threads.mjs +460 -0
- package/lib/tickets.mjs +726 -0
- package/lib/usage.mjs +53 -7
- package/lib/watchdog.mjs +216 -0
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -4,7 +4,10 @@ English | [简体中文](README.zh-CN.md)
|
|
|
4
4
|
|
|
5
5
|
Grok-style bots inside DeepSeek Harness: a team of bots that work together. Each bot has its own **avatar,
|
|
6
6
|
persona, model, skills, abilities, apps, scheduled tasks and memory**, and its own conversation. Bots **message each
|
|
7
|
-
other**, and one of them, the **dispatcher**, splits the work, hands it out, follows up and reports back.
|
|
7
|
+
other**, and one of them, the **dispatcher**, splits the work, hands it out, follows up and reports back. Each piece
|
|
8
|
+
of work handed out is a **task** that the bot works on in a conversation of its own, so one bot can work on several
|
|
9
|
+
at once. You chat with a bot as in a Feishu group: send messages whenever you like, and each one gets its answers in a
|
|
10
|
+
**topic** of its own.
|
|
8
11
|
|
|
9
12
|
It is built for two situations:
|
|
10
13
|
|
|
@@ -34,7 +37,7 @@ Hiring:
|
|
|
34
37
|
- imports role skills from [anthropics/skills](https://github.com/anthropics/skills) (webapp-testing,
|
|
35
38
|
frontend-design, brand-guidelines, …) with their scripts;
|
|
36
39
|
- adds the apps the role needs (GitHub, Stripe, HubSpot, …), whose keys you fill in later;
|
|
37
|
-
-
|
|
40
|
+
- adds the team's scheduled tasks and makes its lead the dispatcher;
|
|
38
41
|
- offers to send the lead a kickoff message, so the team starts working right away.
|
|
39
42
|
|
|
40
43
|

|
|
@@ -56,9 +59,153 @@ Hiring:
|
|
|
56
59
|
Bots answer in the language you write in, so the same team works in Chinese and English
|
|
57
60
|
([中文示例](README.zh-CN.md#一段示例一人公司)).
|
|
58
61
|
|
|
62
|
+
Each message from Atlas to a teammate opens a task, the three tasks run at the same time, and Forge's message is the
|
|
63
|
+
report on its task.
|
|
64
|
+
|
|
65
|
+
## The chat: one topic per request
|
|
66
|
+
|
|
67
|
+
Talk to a bot as you would in a Feishu group: send as many messages as you like, whenever you like, and each one gets
|
|
68
|
+
its answers in a thread of its own.
|
|
69
|
+
|
|
70
|
+
<!-- screenshot: chat with topics -->
|
|
71
|
+
|
|
72
|
+
- **Every message is a topic.** What you send shows at once, marked **Queued** until the bot takes it. The answers to
|
|
73
|
+
it, and everything said about the work it started, collect under it. A bar under the message shows how many replies
|
|
74
|
+
there are, the latest one, the task working on it (with its live status) and a dot for anything you haven't read;
|
|
75
|
+
click it to open the topic beside the chat. When a topic out of sight gets a reply, **N topics have new replies**
|
|
76
|
+
shows above the box and takes you there.
|
|
77
|
+
- **Reply to any message.** Hover over a message and click **Reply**: what you write goes into that message's topic.
|
|
78
|
+
In a topic whose task is still open (or finished in the last day), it goes straight to the bot doing the task; the
|
|
79
|
+
dispatcher only gets a note, which doesn't wake it.
|
|
80
|
+
- **The dispatcher answers every message within a step or two**, because it doesn't do the work in its own
|
|
81
|
+
conversation: it hands it to the teammate that fits, or to itself as a task of its own when none does, and is free
|
|
82
|
+
again at once. Two requests sent back to back run side by side, and neither is dropped for the other. A message that
|
|
83
|
+
continues something already under way is added to that task and filed under its topic (**Filed under "…"**).
|
|
84
|
+
- **The bot doing the work answers you itself**, in the topic the request came from, with the whole result. Only when
|
|
85
|
+
the dispatcher splits one request between several bots and has to put the results together does it ask for their
|
|
86
|
+
reports back and answer you itself.
|
|
87
|
+
- Messages from before 0.9 stay in the main timeline as they were.
|
|
88
|
+
|
|
89
|
+
## Tasks: delegated work in conversations of their own
|
|
90
|
+
|
|
91
|
+
When a bot hands work to a teammate, the work becomes a **task**. The teammate works on each task in a conversation
|
|
92
|
+
of its own, so one bot can take on several tasks at once without mixing them up, and its own conversation stays free
|
|
93
|
+
for you. You don't open tasks yourself: you ask the dispatcher (or any bot), and it opens them.
|
|
94
|
+
|
|
95
|
+
<!-- screenshot: tasks view -->
|
|
96
|
+
|
|
97
|
+
- **Reports**: the bot doing a task reports with a status: **done** with the result, **question** when it needs an
|
|
98
|
+
answer, **blocked** when it cannot go on, or **progress**, which is kept on the task without interrupting anyone.
|
|
99
|
+
Done, question and blocked go to you as they are, in the topic or chat the request came from, and the bot that asked
|
|
100
|
+
gets a note that doesn't wake it. When the bot that asked wants the reports back (to put several results together),
|
|
101
|
+
they reach it at once instead and it passes them on; so do a sub-task's reports, and those of a task that came from
|
|
102
|
+
no chat (a scheduled run). A report from a task that has already ended, or from a sub-task whose task has ended, is
|
|
103
|
+
only kept on the task. Anything else the working bot writes stays in the task's conversation.
|
|
104
|
+
- **Sub-tasks**: a bot working on a task can ask a teammate for help; that opens a sub-task, whose report comes back
|
|
105
|
+
to the task that asked for it.
|
|
106
|
+
- **How many at once**: 4 tasks are worked on at the same time; more wait in line and start as others finish. A
|
|
107
|
+
person's message to a task that has already started (a follow-up, an answer) may use one place more, so new work
|
|
108
|
+
cannot hold it up; a bot's message to it, the dispatcher's too, waits for a free place, and the task shows as
|
|
109
|
+
**Queued** until then. A task that waits for an answer, is stuck or has failed gives its place back once its
|
|
110
|
+
conversation is idle.
|
|
111
|
+
- **Stages**: **Working**, **Queued**, **Needs your answer** (it asked a question), **Stuck** (see the watchdog
|
|
112
|
+
below), **Failed** (an error, or a blocked report nobody has answered yet), **Done** and **Stopped**.
|
|
113
|
+
- **Tasks** in the sidebar groups them into **Needs you** (needs your answer, stuck or failed), **In progress**
|
|
114
|
+
(working or queued) and **Recently done** (done or stopped). A task's page shows the bot doing it, who asked, where
|
|
115
|
+
the request came from, what was asked, the reports, related tasks and the task's usage, with **Open conversation**,
|
|
116
|
+
**Retry**, **Mark done**, **Stop** and a box for a message to the task (to answer its question, for instance);
|
|
117
|
+
**Mark done** and **Stop** both end the task and stop its bot's work on it at once. Each bot's **Tasks** tab lists
|
|
118
|
+
what it is working on.
|
|
119
|
+
- **What bots say to each other stays out of your way**: in a bot's chat, hand-offs, reports and messages between
|
|
120
|
+
bots run together as one quiet group under your conversation with it; those about a task that came from a topic show
|
|
121
|
+
in that topic. **Settings → Chat → Messages between bots**
|
|
122
|
+
sets how much of them shows, the same on every device: **One line** (the default: who hands what to whom, its
|
|
123
|
+
stage and time; a click opens the task), **Short** (and the first two lines of the message) or **Full** (the whole
|
|
124
|
+
message, with the task's card). The bot's replies to you read like the main conversation, without a box.
|
|
125
|
+
- **Live status**: while a bot works, its chat says what it is doing right now and for how long ("Running
|
|
126
|
+
`npm test` · 42s", "Thinking · 8s", then the step and the time since it started), and so do the bot's line in
|
|
127
|
+
the list, its tasks in **Tasks** and on the task's page, and a hand-off whose task is running ("Searching for
|
|
128
|
+
“indoor venues” · 12s"). It moves on its own: the panel checks every second or two while something runs. Only the
|
|
129
|
+
tool and a short, clipped summary of what it works on show (a command's first line, a file's name, the words
|
|
130
|
+
searched for), with keys and tokens taken out; never what a tool returned.
|
|
131
|
+
- **Removing a bot** stops the tasks it was doing, which are archived, and the tasks it asked for, which stay in
|
|
132
|
+
**Tasks**, stopped, where you can still retry one.
|
|
133
|
+
- **Settings → Tasks**: how many tasks are worked on at once (4), the minutes before a quiet task counts as stuck
|
|
134
|
+
(20), and the hours before a finished task's conversation is archived (24).
|
|
135
|
+
|
|
136
|
+
### The dispatcher as a router
|
|
137
|
+
|
|
138
|
+
The dispatcher works in one of two ways, chosen under **How it works** on its **Profile** tab, for the whole team:
|
|
139
|
+
|
|
140
|
+
- **Router** (the default): it understands the request, hands the work out and keeps track of it. It does not run
|
|
141
|
+
commands, write or edit files, search the web, use sub-agents and workflows, draw images or make Office files; it can
|
|
142
|
+
still read files and use its skills. Work that needs any of those, when no teammate fits, it hands to itself: it
|
|
143
|
+
then does it in a task of its own, with all its tools, while its own conversation stays free for you. Its **Abilities** section marks what Router mode turns off, and **Turn
|
|
144
|
+
back on** gives an ability back (even then it may not `sleep`, and a command must finish within 30 seconds or run in
|
|
145
|
+
the background). It never waits for a teammate: it ends its turn and is woken when something needs it, so a new
|
|
146
|
+
request is not stuck behind work in progress, and messages that arrive while it is busy are taken together at its
|
|
147
|
+
next step, each answered in its own topic. Since it only routes, a light, fast model is enough for it; its **Model** section says so, and Bots does
|
|
148
|
+
not change the model for you. In Router mode every bot that hands work to a teammate opens a task, not only the
|
|
149
|
+
dispatcher.
|
|
150
|
+
- **Hands-on**: how 0.7 worked. The dispatcher also does small jobs itself, and a message from one bot's own
|
|
151
|
+
conversation to another bot goes into that bot's own conversation instead of opening a task. Tasks already open keep
|
|
152
|
+
going and report as before.
|
|
153
|
+
|
|
154
|
+
Router mode takes effect once the team has at least one bot besides the dispatcher; a dispatcher on its own does the
|
|
155
|
+
work itself.
|
|
156
|
+
|
|
157
|
+
### Chats and threads
|
|
158
|
+
|
|
159
|
+
A task remembers the chat it was asked from: a private chat, a Slack or Discord thread, a Feishu topic or reply chain,
|
|
160
|
+
a Telegram topic, or the panel.
|
|
161
|
+
|
|
162
|
+
- **Answers go back where the request came from.** The bot doing a task answers in that task's chat itself, signed
|
|
163
|
+
with its name (`【Forge】`) when the chat app belongs to another bot, so two requests from two chats are answered each
|
|
164
|
+
in its own chat. When one turn of the dispatcher involves more than one chat or topic, it answers each with
|
|
165
|
+
`bot_reply`, and a task it opens there has to say which one it is for. Plain text left over from such a turn stays in
|
|
166
|
+
the panel, marked **Not sent**, unless each chat and topic has its answer already.
|
|
167
|
+
- **A follow-up in a thread goes straight to the task.** In a Slack or Discord thread, a Feishu topic or reply chain,
|
|
168
|
+
or a Telegram topic, what you write later in the same thread goes to the tasks started there; the dispatcher only
|
|
169
|
+
gets a note, which does not wake it. Until its conversation is archived, a done task also takes such a message and
|
|
170
|
+
goes on; a stopped task does not. In Slack, Discord and Feishu groups the bot answers under your message, so each
|
|
171
|
+
request there starts a thread of its own.
|
|
172
|
+
- **A follow-up in a private chat goes to the dispatcher.** A private chat (and a group without threads) is one long
|
|
173
|
+
conversation where new requests arrive too, so a new message there goes to the dispatcher, unless one task asked a
|
|
174
|
+
question there and is still waiting for the answer: then that task takes it. With two or more waiting, it goes to
|
|
175
|
+
the dispatcher, which works out which one it answers.
|
|
176
|
+
- A message that starts with `@handle` still goes to that bot's own conversation.
|
|
177
|
+
|
|
178
|
+
### The watchdog
|
|
179
|
+
|
|
180
|
+
Every 5 minutes Bots checks the tasks in progress by fixed rules; no model judges anything:
|
|
181
|
+
|
|
182
|
+
- A task whose conversation is idle, with nothing running in the background (commands, sub-agents, sub-tasks), and
|
|
183
|
+
that has had no news for 20 minutes is asked once for a status report. With still no report 20 minutes later, it is
|
|
184
|
+
**Stuck**, and the bot that asked is told.
|
|
185
|
+
- After a step fails with a temporary error (HTTP 408, 429 or 5xx, a dropped or refused connection), the task is told
|
|
186
|
+
to continue 15 seconds later, then 30, then 60. A fourth such failure in a row, or any other error, and it has
|
|
187
|
+
**Failed**; the bot that asked is told.
|
|
188
|
+
- When every task a bot asked for the reports of has settled (done, failed, stopped or stuck) and that bot has said
|
|
189
|
+
nothing since (an answer marked **Not sent** doesn't count), it gets one reminder to tell whoever asked. Tasks that
|
|
190
|
+
answered the person themselves need no reminder. A task that asked for
|
|
191
|
+
sub-tasks and has ended since gets none.
|
|
192
|
+
- After Harness restarts, a task that was in the middle of its work gets a note: check what was already done (files,
|
|
193
|
+
commands, messages sent), don't repeat it, then go on. A task whose conversation is gone starts again from its
|
|
194
|
+
assignment with the same note, and one whose assignment never reached its conversation gets it again. Queued tasks
|
|
195
|
+
start, and messages waiting for a place are handed over, as places free up; no message is handed over twice.
|
|
196
|
+
|
|
197
|
+
### When a bot asks you a question
|
|
198
|
+
|
|
199
|
+
A bot can stop and ask you a multiple-choice question (Harness's `ask_user_question`). The question shows as a card
|
|
200
|
+
above the message box, in the bot's Chat and on the task's page, and the bot or task is marked as needing you. Pick an
|
|
201
|
+
option or type your own answer; answering in the Harness conversation works too, and whichever answer comes first
|
|
202
|
+
counts. If the work came from a chat app, the bot also posts there that it is waiting for your answer in DeepSeek
|
|
203
|
+
Harness. The answer itself is given in Harness, not in the chat. Permission prompts and plan reviews are answered in
|
|
204
|
+
the conversation; the card links to it. A waiting question does not survive a restart of Harness.
|
|
205
|
+
|
|
59
206
|
## Built on what Harness already does
|
|
60
207
|
|
|
61
|
-
A bot
|
|
208
|
+
A bot works in ordinary Harness conversations, so everything Harness can do, a bot can do:
|
|
62
209
|
|
|
63
210
|
- **Abilities**: web search, files, running commands and code, Office documents, image generation,
|
|
64
211
|
sub-agents and workflows, handing over files… switched per bot on its Profile tab (a reviewer bot
|
|
@@ -95,14 +242,18 @@ A bot is an ordinary Harness conversation, so everything Harness can do, a bot c
|
|
|
95
242
|
| Custom | Any local (stdio) or remote (Streamable HTTP) MCP server |
|
|
96
243
|
|
|
97
244
|
- **Schedules** are ordinary Harness scheduled tasks, also on the Automation page.
|
|
98
|
-
- **AI avatars**: with the [Images plugin](../images), draw a bot's avatar from its persona.
|
|
245
|
+
- **AI avatars**: with the [Images plugin](../images), draw a bot's avatar from its persona. A bot can do it too:
|
|
246
|
+
ask the dispatcher to give the team new avatars and describe the look, or point it at an image file. A bot's
|
|
247
|
+
drawing runs in the background, so it goes on answering you: a ring turns around the avatar while the picture is
|
|
248
|
+
drawn, the new one shows when it is ready, and the bot hears that it is ready (or why it failed) and tells you. A restart of
|
|
249
|
+
Harness drops a drawing under way.
|
|
99
250
|
- **Logos**: each app in the gallery shows its vendor's own logo (the App Store icon where there is an app,
|
|
100
251
|
otherwise the logo from the vendor's site or repository). The logos are their owners' trademarks and
|
|
101
252
|
only identify each service.
|
|
102
253
|
|
|
103
254
|
## Each bot on its own model
|
|
104
255
|
|
|
105
|
-
A bot's **Profile → Model** picks the model its
|
|
256
|
+
A bot's **Profile → Model** picks the model its conversations run on (its tasks' too), grouped by provider, with the
|
|
106
257
|
model's thinking levels when it has them. Besides the models Harness already has, **Model sources** adds:
|
|
107
258
|
|
|
108
259
|
- **Your own endpoint**: any OpenAI-compatible (Chat Completions or Responses), Anthropic-compatible or
|
|
@@ -119,35 +270,41 @@ model's thinking levels when it has them. Besides the models Harness already has
|
|
|
119
270
|
|
|
120
271
|
## Topics: conversations that don't grow forever
|
|
121
272
|
|
|
122
|
-
A bot's conversation is a **topic**. A new topic is a fresh conversation (the old one is archived, the
|
|
273
|
+
A bot's own conversation is a **topic**. A new topic is a fresh conversation (the old one is archived, the
|
|
123
274
|
bot's scheduled tasks move along); what the bot knows carries over in its memory. A new topic starts:
|
|
124
275
|
|
|
125
276
|
- when you send `/new` (or `/clear`, `/新话题`) in the panel or from a chat app — text after it goes to the
|
|
126
277
|
new topic — or click **New topic** under the composer;
|
|
127
|
-
- by itself before the next
|
|
278
|
+
- by itself before the next request, after **6 hours** of quiet, or once the conversation's prompt reached
|
|
128
279
|
**128K tokens** (Settings; 0 turns either off). A big conversation is never cut while a teammate's
|
|
129
280
|
answer may still be coming.
|
|
130
281
|
|
|
131
282
|
Harness still compacts a conversation that nears the model's limit; topics keep every call small and cheap
|
|
132
|
-
long before that.
|
|
283
|
+
long before that. A task's conversation is not a topic: it ends with its task. A task's report reaches the bot
|
|
284
|
+
that asked for it even after that bot started a new topic.
|
|
133
285
|
|
|
134
286
|
## Memory
|
|
135
287
|
|
|
136
288
|
Every bot keeps **notes** that outlast its topics, and the team shares one more list every bot reads:
|
|
137
289
|
|
|
138
|
-
- **After
|
|
139
|
-
came of it) and adds, corrects or removes notes — preferences, people, decisions, procedures, lessons.
|
|
140
|
-
Facts every bot should know go to the team notes.
|
|
290
|
+
- **After each piece of work** a short model call writes one line to the bot's **journal** (what was asked,
|
|
291
|
+
what came of it) and adds, corrects or removes notes — preferences, people, decisions, procedures, lessons.
|
|
292
|
+
Facts every bot should know go to the team notes. In a bot's own conversation this happens after every
|
|
293
|
+
**run** (everything the bot does for one request, until it is idle again); for a task, once, when the task
|
|
294
|
+
ends.
|
|
141
295
|
- **The bot itself** saves notes with `memory_save` when you tell it to remember something, removes them
|
|
142
|
-
with `memory_forget`, and looks through notes, the team journal and
|
|
296
|
+
with `memory_forget`, and looks through notes, the team journal, digests and tasks (their titles and
|
|
297
|
+
reports) with `memory_search`. In a task's conversation it finds, besides the notes, only the journal
|
|
298
|
+
lines and tasks of that task, the task that asked for it and its sub-tasks, and no digests.
|
|
143
299
|
- **Every night** (03:00 by default) memory is **consolidated**: each bot's notes are merged, corrected
|
|
144
300
|
and trimmed with its recent journal, the shared notes too, and the day's work is written up as the
|
|
145
301
|
team's **daily digest**. **Consolidate now** runs it at once.
|
|
146
302
|
- A bot reads its notes, the team notes, its last few journal lines and the latest digest when a topic
|
|
147
|
-
starts, and again at the next
|
|
148
|
-
topic the memory part of its prompt stays the same, so the model's prompt
|
|
149
|
-
keeps working (what it learns in a topic is in that conversation anyway). A
|
|
150
|
-
acknowledgement, a one-line answer to a teammate — gets a journal line without a
|
|
303
|
+
or a task's conversation starts, and again at the next run after you edit memory or the nightly
|
|
304
|
+
consolidation ran. Within a topic the memory part of its prompt stays the same, so the model's prompt
|
|
305
|
+
cache over the conversation keeps working (what it learns in a topic is in that conversation anyway). A
|
|
306
|
+
short exchange — an acknowledgement, a one-line answer to a teammate — gets a journal line without a
|
|
307
|
+
model call.
|
|
151
308
|
- The **Memory** tab of a bot and **Team memory** in the sidebar show everything; add, edit, pin or
|
|
152
309
|
delete notes there. Pinned notes are never changed by the automatic passes. Text that looks like a key
|
|
153
310
|
or token is never stored.
|
|
@@ -159,11 +316,13 @@ Every bot keeps **notes** that outlast its topics, and the team shares one more
|
|
|
159
316
|
|
|
160
317
|
## Usage
|
|
161
318
|
|
|
162
|
-
**Usage** in the sidebar counts every model call the bots make — their conversations, the
|
|
163
|
-
Harness compacting their context — by bot,
|
|
164
|
-
for today), with the change from the period before.
|
|
165
|
-
|
|
166
|
-
|
|
319
|
+
**Usage** in the sidebar counts every model call the bots make — their conversations (tasks' included), the
|
|
320
|
+
memory work and Harness compacting their context — by bot, model, kind of work, scheduled task, task and day
|
|
321
|
+
(or hour, for today), with the change from the period before. **Runs** and **Recent runs** count runs (see
|
|
322
|
+
Memory: one request, from you, a chat app, a schedule or another bot, until the bot is idle again); a task
|
|
323
|
+
takes one run or more, **By task** adds them up, and a task's own page shows its usage. Costs are
|
|
324
|
+
estimates from your own prices or LiteLLM's public price list (**Prices**); a model with no price shows its
|
|
325
|
+
tokens only.
|
|
167
326
|
|
|
168
327
|

|
|
169
328
|
|
|
@@ -280,9 +439,10 @@ one connection. If you change scopes later, reinstall the app to the workspace a
|
|
|
280
439
|
- **Treat a pairing like your own login**: a paired person can ask the bots for anything you could,
|
|
281
440
|
including whatever their abilities and apps allow on this Mac. Pair only yourself or people you trust,
|
|
282
441
|
and turn off risky abilities on the bot that owns the channel if others are paired.
|
|
283
|
-
- **Where replies go**: to the chat
|
|
284
|
-
|
|
285
|
-
|
|
442
|
+
- **Where replies go**: to the chat the request came from, and a task's result to the chat that task was
|
|
443
|
+
asked from (see [Chats and threads](#chats-and-threads)). Write in the panel and the answer stays in the
|
|
444
|
+
panel. Telegram gets plain text (Markdown markers removed); Discord, Slack and Feishu show the Markdown.
|
|
445
|
+
In a Slack channel the answer goes into the thread of your message.
|
|
286
446
|
- **Scheduled reports**: a scheduled task of the bot that owns the channel reports to the first paired
|
|
287
447
|
person (switch it off in the panel), so "every weekday at nine Atlas briefs you" lands on your phone.
|
|
288
448
|
- **One token, one place**: a chat bot token can be connected on one bot of one Harness at a time. If
|
|
@@ -293,23 +453,38 @@ one connection. If you change scopes later, reinstall the app to the workspace a
|
|
|
293
453
|
|
|
294
454
|
## How it works
|
|
295
455
|
|
|
296
|
-
- Each bot owns one ordinary Harness conversation, in the **Bots** workspace
|
|
297
|
-
unless `workdir` is set)
|
|
456
|
+
- Each bot owns one ordinary Harness conversation of its own, in the **Bots** workspace
|
|
457
|
+
(`~/.dsh/bots/workspace` unless `workdir` is set), and one more for each task it works on
|
|
458
|
+
(`ticket-<id>`), in the same workspace. A task's conversation is archived in Harness once the task has
|
|
459
|
+
been over for the hours set in Settings.
|
|
298
460
|
- When it runs, the bot's persona and the team roster join its system prompt; its own skills, ability
|
|
299
|
-
limits and apps apply to
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
461
|
+
limits and apps apply to its conversations only. In a task's conversation the prompt also says which
|
|
462
|
+
task it is, who asked, and how to report. Edits apply at once; a new or changed app connects the next
|
|
463
|
+
time the conversation starts.
|
|
464
|
+
- In Router mode, `bot_send_message` from a bot's own conversation opens a task and returns at once; from
|
|
465
|
+
a task's conversation it reports to whoever asked (with a status) or opens a sub-task. In Hands-on mode,
|
|
466
|
+
from a bot's own conversation, it puts the text into the other bot's inbox and wakes it, as in 0.7. Two
|
|
467
|
+
bots may exchange at most 16 messages in 10 minutes (new tasks and messages added to tasks count), so
|
|
468
|
+
conversations end.
|
|
469
|
+
- Every conversation gets `bot_list`, `bot_create`, `bot_update`, `bot_delete`, `bot_send_message`,
|
|
470
|
+
`bot_reply`, `bot_recall`, `bot_ticket` and `bot_schedule` to manage bots and tasks, and `memory_save`,
|
|
471
|
+
`memory_forget` and `memory_search`. `bot_reply` sends an answer to a named chat; `bot_recall` reads a
|
|
472
|
+
task, its reports or its conversation, or a chat thread, a page at a time, so a bot looks things up
|
|
473
|
+
instead of guessing; `bot_ticket` stops, closes or retries a task the bot asked for, or asks it for a
|
|
474
|
+
status report. [API.md](API.md) lists their parameters. A sub-agent started in a bot's or a task's
|
|
475
|
+
conversation uses them as that bot or task; one that cannot be traced back to where it started (that
|
|
476
|
+
conversation is gone) is refused.
|
|
477
|
+
- A bot's memory is a section of its system prompt, read when a topic or a task's conversation starts
|
|
478
|
+
(and at the next run after a memory edit in the panel or the nightly consolidation), never in the middle
|
|
479
|
+
of a run. A run ends when the bot's Agent is idle; its transcript (prompts, replies, tool calls, short
|
|
480
|
+
tool results), or for a task the transcript of its runs, is what the memory pass reads. Usage comes
|
|
481
|
+
from the `assistant/message` and `compaction/summary` events of the bots' conversations, plus the
|
|
482
|
+
plugin's own memory calls.
|
|
310
483
|
- A chat app is not an MCP server: the Host keeps one connection per chat app (long polling for Telegram,
|
|
311
484
|
the gateway for Discord, Socket Mode for Slack, the long connection for Feishu), starts and stops it as you add, change, switch off or remove the
|
|
312
|
-
app, and hands paired people's messages to the bot as user prompts headed
|
|
485
|
+
app, and hands paired people's messages to the bot as user prompts headed
|
|
486
|
+
`[Telegram · Name] (thread <key>)`, or to the tasks of that thread (see
|
|
487
|
+
[Chats and threads](#chats-and-threads)). The thread key is what `bot_reply` names.
|
|
313
488
|
|
|
314
489
|
## Open Computer Use
|
|
315
490
|
|
|
@@ -319,17 +494,20 @@ permission and restart it.
|
|
|
319
494
|
|
|
320
495
|
## What it stores and sends
|
|
321
496
|
|
|
322
|
-
- `~/.dsh/cache/bots/` (`bots.json` and `
|
|
323
|
-
including keys and chat bot tokens entered for apps),
|
|
497
|
+
- `~/.dsh/cache/bots/` (`bots.json`, `channels.json` and `tickets.json` are readable by your user only):
|
|
498
|
+
`bots.json` (bots, including keys and chat bot tokens entered for apps),
|
|
324
499
|
`messages.jsonl` (timeline), `channels.json` (paired people per chat app, and the last message handled
|
|
325
|
-
per chat), `
|
|
326
|
-
|
|
327
|
-
`
|
|
500
|
+
per chat), `tickets.json` (tasks, with what was asked and their reports, and the chat threads they came
|
|
501
|
+
from; the newest 500 archived tasks are kept), `avatars/`, `skills/` (skills imported from GitHub),
|
|
502
|
+
`memory/` (notes, journal, digests), `usage.jsonl` and `tasks.jsonl` (token counts per call and run,
|
|
503
|
+
kept 400 days), `topics.json`, `settings.json`, `price-catalog.json`. If `tickets.json` cannot be read
|
|
504
|
+
(permissions, say), Bots does not start and says why in the Harness log, so the file is never written over;
|
|
505
|
+
a damaged one is kept as `tickets.json.corrupt-<time>` and tasks start empty.
|
|
328
506
|
- Custom endpoints and a borrowed Codex login are written to Harness's own model settings (`llm-pi-ai`) and
|
|
329
507
|
credential store. With the Codex login in use, tokens Harness refreshes are written back to
|
|
330
508
|
`~/.codex/auth.json`.
|
|
331
509
|
- Nothing leaves your machine except through the bots' own conversations (your configured model), the
|
|
332
|
-
memory passes (a task's transcript and the bot's notes, to the bot's model or the memory model), the
|
|
510
|
+
memory passes (a run's or a task's transcript and the bot's notes, to the bot's model or the memory model), the
|
|
333
511
|
LiteLLM price list (downloaded from GitHub weekly), the apps you connect, the image model when you generate an avatar, GitHub when you import skills, and the
|
|
334
512
|
Feishu / Lark, Telegram, Slack or Discord API when you connect a chat app (the bots' replies to paired
|
|
335
513
|
people, typing indicators, and the one-line note to strangers).
|
|
@@ -353,10 +531,42 @@ git+https://github.com/kadaliao/dsh-plugins.git#main&path:/plugins/bots
|
|
|
353
531
|
|
|
354
532
|
Refresh the page once after installing. For AI avatars, install [Images](../images) too.
|
|
355
533
|
|
|
534
|
+
## Upgrading from 0.8
|
|
535
|
+
|
|
536
|
+
- Nothing to do: bots, tasks, memory, schedules, chat apps and pairings stay as they are. The timeline in
|
|
537
|
+
`messages.jsonl` gains fields for topics; older messages stay in the main timeline.
|
|
538
|
+
- A task opened before the upgrade that came from a chat or the panel now answers the person itself when it
|
|
539
|
+
reports, like new ones.
|
|
540
|
+
- The dispatcher in **Router** mode loses web search in its own conversation (it hands searches to a task, its own
|
|
541
|
+
if no teammate fits); **Turn back on** under its **Abilities** gives it back.
|
|
542
|
+
|
|
543
|
+
## Upgrading from 0.7
|
|
544
|
+
|
|
545
|
+
- Bots, memory, scheduled tasks, topics, chat apps and pairings stay as they are. 0.8 adds `tickets.json`
|
|
546
|
+
for tasks.
|
|
547
|
+
- A team that already had bots switches to **Router**: the dispatcher stops doing work itself and loses the
|
|
548
|
+
tools listed under [The dispatcher as a router](#the-dispatcher-as-a-router) in its own conversation, and
|
|
549
|
+
work handed from one bot to another becomes a task. The Bots panel says so once, with **Open its profile**
|
|
550
|
+
and **Got it**; the notice waits until the team has a bot besides the dispatcher.
|
|
551
|
+
- To go back, open the dispatcher's **Profile** and pick **Hands-on** under **How it works**. It applies at
|
|
552
|
+
once, to the whole team; tasks already open keep going and report as before. Picking a mode also clears
|
|
553
|
+
the notice.
|
|
554
|
+
- Replies to chat apps follow the request they answer ([Chats and threads](#chats-and-threads)); in 0.7 they
|
|
555
|
+
went to the chat of the latest request.
|
|
556
|
+
- In **Usage**, what 0.7 called tasks are runs now (**Runs**, **Recent runs**), with the same numbers.
|
|
557
|
+
**By task** starts with the first task after the upgrade.
|
|
558
|
+
|
|
356
559
|
## Limits
|
|
357
560
|
|
|
358
561
|
- Web UI only.
|
|
359
|
-
- Group chats between bots are not there yet; bots
|
|
562
|
+
- Group chats between bots are not there yet; bots work together through tasks and direct messages.
|
|
563
|
+
- In a group chat a bot hears only messages that @mention it (or reply to it); it does not listen to the
|
|
564
|
+
rest of the conversation. 0.8 does not change that.
|
|
565
|
+
- Thread history starts with 0.8: messages from before the upgrade belong to no thread, so reading a chat
|
|
566
|
+
thread with `bot_recall` shows only what was said there since. Panel topics start with 0.9.
|
|
567
|
+
- Topics are in the panel only. In a chat app, threads, topics and reply chains play that part where the app has
|
|
568
|
+
them; a private chat stays one conversation, where a new message goes to the dispatcher.
|
|
569
|
+
- The watchdog goes by time and status only; it does not judge whether a task is heading the right way.
|
|
360
570
|
- Costs are estimates. Gateways, subscriptions and discounts bill differently; set your own prices.
|
|
361
571
|
- Only the Codex CLI's login can be borrowed so far; other subscriptions sign in from Harness Settings →
|
|
362
572
|
Models where Harness supports them.
|