Carry the constraints across a handoff
A handoff is a new boundary. Compare the receiving brief with the constraints that made the original task meaningful.
Delegation often preserves the noun and loses the conditions. “Summarize this” reaches the next worker while “three bullets, plain language, keep the caveat” disappears. The receiver can then complete a different task perfectly. A handoff should carry the constraints that define success, not merely a shorter version of the request.
The technique is to separate requirements that must survive from preferences that should survive, then compare the incoming handoff with the original lists. This is a transport check, not a judgement about whether the constraints themselves are wise. If a requirement needs to change, record that as a new decision rather than silently dropping it.
01 / State the predicate
Let M₀,M₁ be ordered lists of required constraints before and after handoff, S₀,S₁ optional lists, and t₁ the receiving task label. Define V ≔ M₁=M₀ ∧ S₀⊆S₁ ∧ nonempty(t₁). Equality on M is positional; ⊆ means every original optional item remains somewhere in the receiving list.
The typed domains are M,S : string[] and t : string. The assumptions are that exact strings are the appropriate identity for this synthetic brief and that adding optional notes is allowed. In prose: all must-have constraints stay in the same order, every should-have constraint remains, and the receiver still has a task to perform.
02 / Give the agent a bounded task
A bounded handoff can be written like this:
Original task: summarize the note.
Must: three bullets; plain language.
Should: keep caveat.
Handoff: preserve these fields exactly and add the receiving task label.
The receiver may add context, but it cannot replace a must-have constraint with a vague synonym and call the work equivalent. If the human owner changes the brief, update the original record first so the comparison has a current source.
03 / Run the independent check
Save preserve-task-constraints-during-handoff.mjs and invoke it with node --input-type=module -e 'import("./preserve-task-constraints-during-handoff.mjs").then(({evaluate}) => console.log(evaluate({original:{task:"summarize",must:["three bullets","plain language"],should:["keep caveat"]},handoff:{task:"summarize",must:["three bullets","plain language"],should:["keep caveat"]}})))'.
export function evaluate(input) {
const original = input?.original;
const handoff = input?.handoff;
const sameList = (left, right) => Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => item === right[index]);
const checks = [];
checks.push({name: "must-preserved", pass: sameList(original?.must, handoff?.must)});
const optional = Array.isArray(original?.should) && Array.isArray(handoff?.should);
checks.push({name: "optional-preserved", pass: optional && original.should.every(item => handoff.should.includes(item))});
checks.push({name: "handoff-has-task", pass: typeof handoff?.task === "string" && handoff.task.length > 0});
const pass = checks.every(check => check.pass);
return {pass, summary: pass ? "The handoff carries the task constraints needed for review." : "The handoff dropped or changed a declared task constraint.", checks};
}
The initial fixture passes all three checks. The exact expected result is the complete returned object with must-preserved, optional-preserved, and handoff-has-task all true.
04 / Try the counterexample
Delete plain language from the receiving must list. The optional note still survives and the task label still exists, but must-preserved fails. This is the useful shape of a failure: it points to the boundary that changed instead of declaring the entire handoff mysterious.
Change the input. Inspect the result.
Loading example
Synthetic input. No model call. No data leaves this page.
05 / Keep the claim bounded
A pass establishes list preservation for the supplied synthetic strings. It does not establish that a receiver interpreted a phrase correctly, that a constraint is complete, or that the original task was authorized. Exact matching can be too strict for a real system; if normalization or aliases are needed, specify them and test them separately. Do not hide a human change inside normalization.
Source and formulation note
This is an original handoff predicate informed by the public risk-management idea that roles, context and constraints should remain reviewable. NIST’s AI Risk Management Framework is a contextual public source, not a source for this exact list comparison. All examples are synthetic, and the module performs no routing or external action.