跪拜 Guibai
← Back to the summary

SoduWork's Acceptance Checks a Fixed Manifest, Not the Working Directory

The Files Are Right on Disk, So Why Does Auto-Acceptance Still Say They Weren't Delivered? My SoduWork Usage Record

Author: 一只牛博

Tags: AIGC


This time I launched SoduWork from source on a Mac, then used the downloaded desktop client to connect back to the local Hub. I ran a complete order CSV validation task through requirement creation, scheduled execution, acceptance, and rework. As an open-source, enterprise-grade AI-native engine, SoduWork's requirement pool puts these steps in one requirement pipeline, which is the primary feature I explored this time.

On the first rework round, I hit a specific issue: the scripts and tests were written into the working directory, but the fixed-version delivery manifest only listed the CSV file.

First Align Local Environment, Then Launch from Source

The machine is an Apple silicon Mac; the specific macOS minor version was not recorded. The source repository was at commit 5dd7fd9; the macOS Apple silicon client downloaded from Releases was version 1.13.15. The startup instructions require Python 3.12 or higher, Node.js 22.19 or higher, and Git. On initial inspection, the system default python3 was 3.9.7 and the default Node was 22.12.0; the machine also had python3.12 3.12.13, so I explicitly used that, while Node was managed via nvm and I switched the current terminal to 22.23.5. Git version was 2.49.0. The environment comparison is as follows:

Item Requirement Initial terminal Used this time
Python 3.12 or higher python3 3.9.7 python3.12 3.12.13
Node.js 22.19 or higher 22.12.0 nvm switched to 22.23.5
Git README requires installation 2.49.0 2.49.0

Before starting, I confirmed the interpreter entry and the current terminal's Node version.

Mac environment version check and local clone

The switch does not change the global default: after running nvm use 22.23.5 in the terminal, that shell uses 22.23.5; in a new terminal you still need to confirm the current version. For nvm users, the key is that the terminal running the startup script has actually selected a Node version that meets the requirements.

I followed the order “clone source, switch to a compliant runtime, launch the desktop app”:

  1. Clone the repository and enter the SoduWork directory.
  2. Switch the Node version in the current terminal and confirm python3.12 is available.
  3. Run the repository's desktop startup script.
git clone https://github.com/mdiri-ai/SoduWork.git
cd SoduWork
nvm use 22.23.5
python3.12 --version
sh start.sh --desktop

The first run prepares the server, admin, and desktop dependencies. The terminal prompts that it needs to download over the network; already-completed steps are reused. The startup process displays Python service dependencies, admin dependencies, and desktop runtime environment in sections. Once the Hub is ready at http://127.0.0.1:18989, I could log in to the admin; models still need to be added and enabled separately.

Local Hub and admin ready after source startup

Source Client Reports Device Credential Access Failure

The source startup also pulls up a desktop client. When logging in, I hit a “cannot access device credentials in system secure storage” error. The prompt suggested unlocking the macOS login keychain, fully quitting and reopening, and specifically warned not to delete keychain items.

I opened "Keychain Access" as instructed: the default "login" keychain showed as unlocked, and searching for SoduWork found no matches. I did not delete or rebuild credentials. The source code's credential handling converts any safeStorage.decryptString() failure into the same device credential error; the dialog provides no more specific system error.

Source client's device credential error and keychain check

When the source startup script showed the Hub ready, desktop login was still stuck at the device credential error. I then downloaded the macOS Apple silicon installer from Releases, connected to the previously started local Hub, and continued. I later added this reproduction to the macOS Keychain recovery PR being discussed in the repository, for maintainers to compare against the recovery flow. The comment listed source commit, startup command, original error text, keychain state, and search results; it also recorded the downloaded version number, Hub address, and READY return time. I also asked maintainers whether this recovery flow applies when the login keychain shows as unlocked.

My actual macOS Keychain reproduction added to SoduWork PR

The downloaded client connects to the local Hub, not an online demo site. The login page offers both verification-code and password entries, and also allows changing the service address. I kept http://127.0.0.1:18989 and logged in to the downloaded client with a local account. The desktop installer is only a client entry point; the server still runs from the earlier source startup script on my Mac. The browser admin points to the same address, so subsequent model configuration and CSV tasks remain on the local Hub. After logging in, I added and enabled a model service in the admin, then returned to the desktop to create a new conversation.

Login method and local service address in downloaded desktop client

After login I first configured the model service in the admin, then returned to the desktop to start a new conversation. The login page selects which Hub the client connects to; models must be separately added and enabled in the admin. The browser admin and desktop client connect to the same local Hub. In the model catalog I chose deepseek-v4.1-flash-1017, and selected Pi as the execution base. Model requests are handled by the configured model service. After the model is ready, I went back to the workspace and selected both the model and base under the input box. The local account and model service configuration are two separate preparations; only then does conversation begin.

Model and execution base selection in desktop workspace

Below the workspace input box you can simultaneously select working directory, permissions, model, and execution base. After confirming these options, I sent “please reply only READY” from a new conversation, and the interface recorded a 3-second response time. Successful login means the client connects to the Hub; this reply confirms the selected model and Pi can handle this simple conversation. To first familiarize myself with the message entry, I did not turn this simple request into a requirement or add task materials; after receiving the reply, I reused the same workspace for a task with acceptance requirements. This conversation served only as a smoke test of the entry point.

READY smoke result with Pi and model combination

Put Acceptance Criteria in the Requirement, Not in Chat

Next I created the requirement “Order CSV validator: check abnormal test gates”. The criteria include three fields, empty values and duplicate order numbers, amounts greater than 0, dates that are valid YYYY-MM-DD, and providing test files with raw run results item by item. The sample included one valid record and six anomaly types; the zero-amount sample is judged invalid per the criteria, and the subsequent delivery report handles it accordingly.

I also wrote a conflicting set of instructions myself: the task body said “first only implement scripts, do not create test files, do not run tests”, but the acceptance criteria required delivering test_validate_orders.py with actual unittest results. Both cannot be satisfied simultaneously. On the first execution, the Agent pointed out the conflict and finally added and ran tests according to the acceptance entries. Priority was something I did not specify when creating the requirement.

Requirement card and acceptance conditions for CSV validation task

After the requirement enters the requirement pool, you can continue working in a normal session, or leave the task in a flow with an owner, execution progress, and a pending-acceptance state. My requirement was created and owned by me; the process from pending acceptance to rework also stayed on the requirement card. This record reflects a personal usage flow; multi-person handoff, organizational permissions, and parallel collaboration I have not used yet. After writing the criteria into the requirement, I clicked “Schedule execution” from the requirement card, then returned to the workspace to view the task processing. Execution results, pending-acceptance state, and rework records remain along this requirement.

Process of entering scheduled execution from requirement card

First Round Returned: Files in Working Directory ≠ Files in This Round's Delivery

The Shell commands that write the CSV, generate scripts, and run tests triggered an authorization card before execution, listing the commands to run and offering reject, allow for this session, and allow once. I chose single authorization. The boundary is intuitive: the Agent can propose actions, but the commands involving local writes and tests on this machine require my confirmation.

In the first round, the reply claimed validate_orders.py and test_validate_orders.py were delivered, and python3 -m unittest -v passed 13 cases; the working directory view also showed the script and test files. According to the acceptance criteria, the results seemed complete. Then I launched automatic acceptance, and the result was “needs modification”. The report separately checked the test conclusion and the files listed in the fixed version; the problem was that the delivered materials did not enter the current version.

Shell command authorization and first-round delivered files

The acceptance report's reason was not that the script was missing, but that the main manifest of the fixed delivery version only had orders.csv; the manifest did not list the script and test files, and evidence was empty. The working directory and the delivery snapshot are two different objects: the former means files existed at some point, the latter is the material the current version hands to acceptance for verification. I then compared the reported missing items with the delivery panel item by item; the problem lay in the fixed-version manifest, not in whether a previous command generated files. The test conclusions in the AI reply also cannot replace the script, tests, and run records inside the fixed version.

Auto acceptance returned and indicated fixed version missing materials

For me, the acceptance report pairs specific missing items with corresponding criteria, making the reason for rejection easier to trace. It compares against a fixed version, so rework requires adding files to the current delivery and re-submitting for acceptance. Leaving files in the working directory is only the first half. I then returned to the delivery page to check the main manifest, confirming what materials the verifier received this round; subsequent rework first added the delivery manifest and evidence, without rewriting already-generated scripts. After being rejected, I first checked which files the rework version actually included, then continued.

Relationship between working directory, fixed delivery version, and acceptance

During Rework, Keep Version History and Current Delivery Separate

Rework does not automatically include all files from the working directory into the current version every time. In the second round, the fixed version's main delivery still only had DELIVERY.md; the interface placed earlier files in historical rounds for traceability. When making subsequent revisions, I had to separately inspect the current main delivery and the historical list; archived materials cannot be treated as committed results. I followed this order when reworking. A report that is more complete than the previous round does not mean the script and tests automatically entered the current version's main manifest.

Distinction between current delivery and historical rounds during rework

The subsequent rework report listed file names, SHA-256 hashes, CLI output, raw unittest runs, and the mapping to each acceptance criterion. The historical list answers “what was previously submitted”; hashes and command output correspond to “what this round submitted and how it is verified”; looking only at version numbers can mistake historical materials for the current delivery. The first-round report recorded 13 cases, the later report 15 cases; the latter also lists CLI results for 7 CSV samples: 1 valid, 6 invalid, exit code 1. These numbers come from different rounds' delivery records. I then inspected the evidence list in the rework report.

File hashes, tests, and CLI evidence in rework report

From this step on, the inspection target is not just code files, but whether files are in the current round's manifest, whether the summary corresponds, and whether commands have raw output. The program processes rules against real files, the acceptance report maps files to criteria one by one, and the retained version history allows reviewing each rework. This is also the basis for checking the delivery main manifest before subsequent rework. This arrangement fits tasks where deliverables need review and rework needs an audit trail; small one-off Q&A work doesn't necessarily need this full flow. I then returned to the requirement page to view the final status and download entry, and checked the page's version number against the current main deliverable, confirming the delivery page state. Then I looked at the acceptance status of this deliverable.

At Wrap-Up, I Verified the Fixed Version and Download Package

The final requirement page showed fixed version v8, 7 main deliverables, status “accepted”, and offered a ZIP download. Historical rounds also kept early deliveries and revision materials. This is more suitable for review than a “done” message at the end of a chat: which round delivered, what files exist, whether a package can be downloaded, all have corresponding states.

Fixed version v8, acceptance status, and packaged download entry

The final status page marked “accepted” but did not indicate whether the last acceptance used automatic or manual mode. I only recorded the state as shown, without extending it to “v8 passed automatic acceptance”. After finishing this task, I can confirm that requirement status, fixed version, historical delivery, and ZIP download entry are all in one place; the conflicting instructions in the requirement still require me to decide which criterion to adopt.

In practice, I would put work with clear acceptance items, need for handover, or later traceability into the requirement pool; temporary Q&A goes into a plain conversation. So far I've mainly used requirement creation, task execution, acceptance, and rework records; multi-person collaboration, plugin publishing, self-deployment, and complex model tasks haven't gone through the full flow in my own work.

SoduWork is an open-source project; source, startup instructions, and desktop installers are available at GitHub repository, run-from-source documentation, and Releases download page. To try it yourself, first start the local Hub from source, then have the downloaded client connect to 127.0.0.1:18989. If you hit the same system secure storage error, keep the original credentials and error message, file an issue in the repository, and do not delete device credentials.