Working together on a project

Pulse connects local tasks, agents and colleagues through a common project. Each person works with their own Git clone. A team of agents within a task and participants in a common project are different entities.

Connect a colleague

  1. In the section Team select your local repository, enter a name, and create a shared project.
  2. Expand Participants, select a role and create an invitation. The code is one-time use, valid for seven days. Pass it on to a colleague.
  3. The colleague logs into their Pulse account, enters the code, and links the project to their clone.
  4. Each participant reveals My local tasks and chooses which statuses to publish. Cards are updated automatically; after the network is disconnected, the application repeats the synchronization. “Remove post” works without a network: the task immediately ceases to be shared, the “removal is pending synchronization” mark appears in the list, and the card is removed from the board the next time you connect.

The owner manages participants and invitations. The participant publishes only his own tasks. An observer reads the board. The server checks rights regardless of the interface.

The board shows the contribution of each participant and the overall result of the published tasks. When deleting a locally published task, deleting the card is queued before connecting.

Pictures are posted on the board local desktop application tasks. A separate 24/7 swarm queue in Postgres is not connected here: merging its MR does not itself change the card and does not create an event in the feed. Sources and consequences are described in task state boundaries.

What goes into the project: choosing a participant

Next to the linked clone there is a choice "Publishing my tasks" - three modes and two separate resolutions. Below the switches there is always a list of what exactly will go away with the current choice: it is visible before you click “Save”, and not after the card appears with your colleagues.

Mode What's leaving
Do not publish nothing: published cards are removed from the board, presence goes out, new cards do not leave
Basic task name, branch, stage, agent state, counters of turns and sessions, time of agents and person
Detailed the same plus the initial prompt and acceptance criteria - texts that you wrote yourself

Separately included cost your tasks and presence. In the “Do not publish” mode, both turn off along with it: the switch, after which something continues to leave, is lying.

Shutting down works without a network and without unlinking a clone: cards are no longer shared immediately, and deletion from the board goes to the server the next time you connect - just like manual “Unpublish”. The clone remains connected, memory and messages continue to work.

Code, diffs, agent responses, notes, file names and local paths are not lost in any mode. The binding made before the switch appeared continues to work in the basic mode: silently stopping to do what was asked is as wrong as starting to do what was not asked. And the texts and presence in it are turned off because no one allowed them.

Detailed mode requires a server that accepts card texts. Until the server announced this possibility, the mode is not available in the window and next to it it says why: the prompt is not sent even “just in case” - the server that throws it away will still see it.

Shared board as a workplace

The lines on the board are addressable. Open your task with the button Open. In someone else's task you can request transfer — the card owner will see the request in the discussion and in the “Requires Attention” list and send the thread as a parcel (see below). If the clone is not yet linked, the board reminds you of this.

The card has responsible and inspector - project participants. They are appointed by the owner or member; the observer only reads. Assignments have their own version: if two people change them at the same time, the second one receives the refusal “Assignments have already been changed. Update the board" rather than overwriting someone else's selection. For the assignee and reviewer, the entry appears in “Requires Attention” on the dashboard.

Discussion cards - notes, transfer requests and review requests. The request is closed by the card owner, post author, or project owner; Notes are not closing. A cardholder with a designated verifier can request review with one button. The discussion is stored on the server and does not contain code.

Receiving a card does not launch someone else's agent and does not give access to its session: the board reports the state, and work continues in your clone after the branch is transferred.

Event feed

Tab Tape the project screen answers the question “what happened,” and the board answers “what now.” The feed includes: who joined and who was removed from the project, publication and removal of the card, hiring, acceptance, agent error, request to transfer the thread and request to check, as well as assembly and receipt of the parcel according to the published card.

The server makes records based on what he saw himself. Therefore, the tape does not start with the history of the project, but from the day when the server started it, and stores the latest records - the old ones are replaced. A task that no one has published does not even appear in the feed by name: the cloud does not know about it. The server takes names and branches from its own snapshot of the card, and not from the words of the application, so it is impossible to replace someone else’s entry.

A card removed from the board disappears from the board, but entries about it remain in the tape: the tape is a journal of what happened, and to clear what happened from it would mean lying by omission.

About parcels, the tape says exactly what is known: “collected parcel” - the file is created, but Pulse does not deliver it itself and does not know who received it; “received a parcel from N” - the name is taken from the manifest. The output about the signature does not go to the feed: the recipient checks the signature himself, and the result of the check is in the log of his task, and not on the server.

Attendance of participants

Next to the participant in the list you can see whether he is working now, whether his agent is waiting for a response, and when the last signal came. The age of the signal is always shown: “working” without time would be read as “right now,” and all that is known is when the person last signaled.

The presence lives for a minute and a half and goes out on its own: a closed application, a sleeping laptop or a lost network - and the line disappears, rather than hanging untrue. Without communication with the cloud, the presence is not shown at all and is not included in the saved snapshot of the board. An empty line does not mean that the person is not at the computer - it means that we do not know it.

Pulse publishes its presence only with permission - with a separate switch in the “What goes into the project” block. Without it, nothing is sent, and the task name is left only if this task has already been published to this project. Shutting down extinguishes the presence immediately, without waiting for the expiration date on the server.

No network and old server

Without a connection to the cloud, the board is shown from the last confirmed photo with a timestamp. Assignments and entries made without a network go into the "Pending Sending" queue and leave in the same order when connected. If the server rejects the action (version conflict, no rights), it remains in the queue with the error text until you decide to “Cancel”; Other people's changes are not silently overwritten.

For appointments and discussions, you need a Pulse Cloud server with migration 0010_team_collaboration; it announces its capabilities, and the old server is shown on the page with an explicit message, and the board and publication work. The board itself needs migration 0009_team_projects, for tape - 0014_project_events. The presence of the table is not required: the server keeps it in memory, and after it is restarted, the presence of everyone goes out until the first new signal. Card texts (texts) is not accepted by any server today - the detailed publishing mode is therefore not available and says so directly. An old server without a feed, presence or texts talks about it in the tab, in the list of participants and in the publication block, and does not pretend that it simply has nothing to show. Local file sharing does not require this API.

Pass code and context

In a task, click Submit task. Enter what is done, how to check and what is left. If the authors worked in separate branches, first merge their results into the issue in the tab Diff → Problem Result.

Package .pulseparcel contains Git bundle and context. The initial prompt is included according to your choice. Unsaved files can be explicitly committed before export. The bundle limit is 64 MB. Transfer the file in a way convenient for the team; Pulse doesn't automatically send it to people.

Reception: three modes

The recipient chooses Importing a parcel... in the “Team” section or in the repository settings, reads the context, indicates your clone and in the block “What to start at home” decides how much Pulse will have on his side:

Mode What appears to the recipient
Branch only commits go to a separate branch parcel/<id> - and nothing more: no working copy, no task card, no session. Look at someone else's work and decide
Branch and task plus a separate working copy and a card with the sender’s report. No session
Branch, task and agent session plus a ready-made session with a report in context. Default - previous reception behavior

The agent's turn does not start itself in any mode. Even in the third, an empty session is created: the first turn is launched by a person, because the product has no right to spend other people’s money after opening the file.

In the “branch only” mode, there is no card, so there is no record of the appointment: there is nowhere to store it, and getting a card for the sake of recording would mean doing something that was not asked for.

The SHA512 check detects content corruption. The sender's name is confirmed by the manifest signature: the package is signed with the device key (Ed25519), the signature is verified up to parsing the content, and the key of a familiar sender is remembered when it is first received. Then three different conclusions are possible, and the product does not mix them up: there is no signature at all (the package is from a version without a signature - the sender is still unverifiable, and that’s what it says), the key is visible for the first time (the signature matches, but Pulse doesn’t know whose key it is) and the key is familiar. Changing the key of a familiar name is a failure: this is what both the new device and the replacement look like, it is impossible to distinguish them from the inside, so the old key can only be forgotten manually and only after checking the fingerprint with a person. Re-importing the same package does not create a second task; a parcel with an already accepted identifier, but with a different commit, is not accepted at all. Extraneous paths and symbolic links in the container are not retrieved.

If there is no base commit

A regular push only carries the commits of a branch on top of the common base. When this base commit is not in the recipient's clone - a common thing after a squash-merge and in a clone that has not been updated for a long time - there is nothing to deploy the package from. Previously, this was where the conversation turned into correspondence.

Now the technique names the missing commit and offers to save request file .pulserequest: it contains the task, the branch, the same commit and the name of the person asking. The sender opens this file with the same “Importing parcels...” — the dialog accepts both types of files. If the request matches a package that the task actually sent, the entry “requesting a complete package” appears in the task log and activity feed, and you can collect it with one button in the “Parcels” panel: the full history of the thread is already marked there. Opening the same file again does not count as a second request. This entry does not go to the general feed of the project: the server would see it from the words of the application, and it does not deal with parcels at all.

The request file is not signed by anyone, and the task identifier is in the manifest of each parcel - which means that a similar file can be collected by anyone who has ever received a parcel from you. Therefore, a request that does not match the sent messages of the task is shown with a reservation and is not written to the log: otherwise, someone else’s file would prompt you to send the entire history of the branch.

Parcels panel

Button Parcels in the task header it opens a log: what was collected, what was accepted, what was added, where there was a conflict, which merge was canceled and who is asking for the full package. The entry has the time, branch, file size and sender name from the manifest - with the same note that it is not confirmed by the signature. Until the request for a full package is closed with a new full package, it hangs on the button with the mark “request for complete”.

The same log goes into a separate section "Parcels" to audit export - both in Markdown and JSON: otherwise, from the report it is impossible to understand where other people’s commits in the task came from and where their own went.

For tasks that existed before the journal appeared, only package identifiers were preserved - no time, no details. Such entries are at the end of the list and directly say “the details have not been preserved”: throwing them out would mean showing an empty list where the parcels were.

What Pulse doesn't do here

  • Neither the package nor the request is delivered. Both files are carried by a person - by mail, instant messenger, flash drive. There is no “send to a colleague” button, because there would be nothing behind it.
  • Doesn't know who the file went to. Parcels do not have an address book. Therefore, both in the log and in the feed it is written “the parcel has been collected”, and not “sent to such and such”.
  • Does not confirm the sender. The name in the manifest and in the request file is an unverified string entered by the sender himself. SHA512 only says that the file was not corrupted along the way, and does not say anything about who collected it.

Reply back

The recipient can export the continued task back. Original author chooses Answer to the problem, after which the result is returned for verification. In the event of a conflict, the merge remains in the working copy - it is either resolved in the task or canceled with a separate button; the task branch is not touched. Importing someone else's branch does not mean accepting the result.

Identity and memory

Clones are linked by the root commits of the current branch's history; simply moving a folder or changing the remote address does not create a new project. A repository with a rewritten independent history is considered a different project.

Linked local clones share the same project memory. The previous records of both clones are preserved when merging. The context selected in the package is transferred between computers; all local memory is not automatically published.

The shared board does not edit other people's local files and does not show the fictitious presence of colleagues: the presence is taken only from live signals and goes out along with them. Automatic parcel delivery, sender signatures and real-time collaborative text editing have not yet been implemented.