An organizational operating system for DeepSeek Harness — combining IM routing, persistent hybrid teams, and the "never DIY" dispatch philosophy into one open-source plugin.

dsh-orgos lets you build and run an organized team on top of DeepSeek Harness (DSH): virtual employees (agents) and human employees live in the same org tree, IM is the front door, dispatch is disciplined, and one model spans everything from a three-person squad to a multi-BG conglomerate.

中文文档见 README.zh-CN.md。

None of the capabilities above is a pile of isolated features — they are the direct products of one architecture. The design premise is plain: what runs today must not be rebuilt as the team grows. One model spans squad to conglomerate, and scaling up means swapping providers, never rewriting.

The org tree org → bg → dept → team → positions has arbitrary depth; the three scales are just three shapes of the same tree:

• Squad = org → team (works from a handful of people);
• Department / company = org → dept → team ×N;
• Conglomerate = org → bg → dept → team (multi-BG federation).

Coordination mechanics are scale-independent: each layer may appoint an orchestrator (delegations land where one exists, bubble up where none does); receipts fold upward as per-layer digests (member report → team → dept → BG → org; the top only reads conclusions); members are lazily activated (on standby at zero cost, woken on dispatch). Adding an org layer is adding config, not complexity.

packages/core/
├── domain/   # Pure domain kernel: org tree / routing / delegation state machine /
│             # scope projection / digest / memory — zero DSH imports, zero Node IO;
│             # portable as a whole to another host (harness/framework)
└── dsh/      # DSH binding layer: TeamService / member runtime / persistence /
              # extension API — thin, only wires the environment

The domain kernel answers "how an organization runs"; the binding layer answers "how it lands on DSH". Over 80% of unit-test coverage lives in the domain kernel, so its verification travels with it when the host changes.

Every external dependency converges to an interface; implementations are swappable providers:

Inheriting DSH's "everything is a plugin" mindset: orgos extension points are ordinary DSH plugin rows. A third-party plugin gets the Orgos Extension API via ctx.get('teamService'):

• registerDocumentProvider / listDocumentProviders — document library registry;
• setFederation — conglomerate federation injection;
• onTeamEvent — subscribe to team events (a throwing subscriber never blocks the event bus);
• options.store — storage provider injection point.

Third-party capabilities (Jira sync, calendars, CRM, code platforms, document libraries) ship as standalone npm packages + a cordis row — written exactly like a DSH plugin. One ecosystem, one way of writing plugins.

JSONL flow records (delegations/tasks/mail/memory/runs) have been stable, replayable fact logs from day one: cold starts recover state from them, SQLite/federation backends migrate from them in one pass. The format never changes, so historical data stays valid forever.

# 1. Install (DSH plugin protocol)
dsh plugin add dsh-orgos

# 2. Start dsh: role presets auto-seed; open a new Web session as "dispatch center (orchestrator)"

# 3. Initialize your team (send in the "dispatch center" session)
Initialize with team_setup (action=init, scale=small)

# 4. Configure IM (Feishu example)
#    - Put credentials into DSH credentials (key of your choice, value format appId:appSecret)
#    - Enable the team-im-feishu row in your profile and configure channels
#    - @-mention the bot in a group to talk; bind group→position with team_setup bind

One model covers every scale; only team_setup init's scale and later customization differ:

scale is only a starting template — edit team.yml anytime after starting at any scale. The org tree is declarative config, not code.

The team config is one declarative YAML file at ${DSH_HOME}/team-state/team/team.yml (edit and restart; team_setup bind/unbind/replace go through the safe path: backup → validate → atomic replace, auto-rollback on failure):

org: my-org                        # org name
nodes:                             # governance node tree (org/bg/dept/team, any depth)
  - id: my-org
    kind: org
    orchestratorPosition: head     # optional orchestrator per layer (delegations land where one exists, bubble up otherwise)
    children: [team-a, team-b]
  - id: team-a
    kind: team
    orchestratorPosition: lead-a
    children: []
positions:                         # position = stable entity; occupants are swappable
  - id: lead-a                     # orchestrator position
    occupant: { kind: agent, preset: orgos-orchestrator }
  - id: dev-1
    teamId: team-a
    occupant: { kind: agent, preset: orgos-coder }          # virtual employee
  - id: designer-1
    teamId: team-a
    occupant: { kind: human, im: { channel: feishu, userId: ou_xxx } }  # human
    handover: { inheritMemory: team, reassignOpenTasks: transfer }      # handover policy on replacement
routes:                            # IM routing: (channel, group/session) → position or node
  - { channel: feishu, peerId: oc_xxx, target: team-a }
acl:                               # governance rules
  delegationDepthMax: 3            # delegation depth cap
  allowCrossTeam:                  # cross-team collaboration whitelist (cross-team denied by default)
    - { from: team-a, to: team-b, scopes: [note, result] }
roles:                             # per-preset override of the five-dimension scope
  orgos-coder: { visibility: team, authority: self, memory: [private, team], subscription: [team, self] }

Full samples live in examples/ (squad / department / conglomerate / multi-bot groups); field semantics are annotated next to each field.

Five built-in role presets (auto-seeded into the user directory on install; shipped DSH presets are never touched):

• Swapping people: any occupant can switch to a human (kind: human) or another preset at any time; team_setup replace generates a handover list, handles in-flight tasks per the handover policy, and injects the new occupant's initial memory;
• Custom roles: write your own DSH agent preset (persona/tools/model) and reference it in occupant.preset — orgos does not lock the role system.

The orchestrator is the main entrance, but not the only one:

Today: works out of the box, zero performance debt. The org model, coordination mechanics, and lazy activation carry teams of dozens to hundreds of positions on a single machine; JSONL storage prioritizes correctness and recoverability, and the data format doubles as the migration contract.

Long term: conglomerate scale = swapping providers. SQLite → document providers → cross-instance federation plug in one by one, each touching a single seam and never the org model or the domain kernel. Interfaces first, implementations on demand — exactly what the "Capability seams" section above promises.

packages/
├── core/          # domain/ (pure domain kernel, harness-agnostic) + dsh/ (DSH binding layer + extension API)
├── im-gateway/    # MessageGateway seam + message normalization
├── im-feishu/     # Feishu adapter (WS long connection, verified)
├── im-telegram/ wecom/ dingtalk/ slack/ discord/ whatsapp/
├── tools/         # Team tools (delegate/status/mail/task/memory/setup (incl. replace)/doctor/run/doc_*)
├── doc-git/       # git wiki document provider (B stage: md backend of the team knowledge base)
├── doc-feishu/    # Feishu Bitable document provider (one team_doc_* backend)
├── doc-feishu-docs/ # Feishu cloud docx document provider (B stage)
├── ui/            # Client half (Team Room view)
└── bundle/        # dsh-orgos bundle (dsh.bundle manifest)
examples/          # Team config samples (squad/department/conglomerate/multi-bot groups)

Internal design & decision documents (PRD / tech design / ADRs / security) live outside this repository.

See CONTRIBUTING.md. Core conventions: a new IM adapter = a standalone package + fixture tests; unit-test coverage ≥ 80% with Given-When-Then on critical paths; docs stay in sync with code.

MIT © shisan13