fusion-suite
Skill0 starsChanged 51 days agoMITView on GitHub
Work through a whole suite of converted test scenarios in the Oracle Fusion TEST pod, in a loop, session after session, correcting as it goes. Reads the state of the suite, chooses the values the scripts left open, runs each part of each chain, repairs renamed labels, applies PICK criteria, recognises a script that is badly designed and rebuilds it from what it sets out to prove, parks what needs a person, and hands over the evidence. Use when asked to run, continue or calibrate the test suite or the regression battery, or to work through the converted scripts. One scenario on its own is fusion-test. Never production.
In this repository12 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- smoke-checkSkill
- fusion-instanceSkill
- fusion-referenceSkill
- fusion-testSkill
- hcm-architectureSkill
- hcm-configurationSkill
- hcm-debuggingSkill
- jira-ticket-ingestionSkill
- triage-batchSkill
- triageSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
15 rules. About 0 are common, 9 are distinctive, and 6 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈9
Distinctive · estimate
This author's own choices. Worth a look.
6
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 19
Every scenario ends in one of three states, and none of them is "green at any cost":
- Distinctive: line 36
Before the first loop, show the user the intents, one ticket at a time: the scenario names in chain order, the description of each (the …
- Distinctive: line 43
Start every session, and every iteration, with the state on disk, never with memory:
- Very specific: line 57
Check who is signed in from the page header (snapshot) rather than assuming.
- Very specific: line 60
After the last part of a chain, the evidence: evidence <run-id of each part>, one document per ticket.
- Very specific: line 75
When it is a person's work by nature (a file dialog, a code sent by email, a grid of quantities, a drag), ask the user to do it in the …
- Distinctive: line 84
The script is wrong: when, as the right person, on the right page:
- Distinctive: line 101
Before every rebuild, ask: *if the system had the defect this ticket is about, would the rebuilt plan still fail?* If not, the rebuild has …
- Very specific: line 110
Rewrite the steps in the same file: Keep the comments, add # rebuilt <date>: <reason> above what changed, keep the scenario name, the chain …
- Distinctive: line 129
never setup, security, profile options or page rules: a test proves a transaction, it does not change the configuration the other testers …
- Distinctive: line 146
When the right value depends on business knowledge the pod does not hold, park it with the question.
- Very specific: line 157
Keep sessions short (fusion-test step 7): one person's runnable parts, or about ten scenarios, per session.
- Distinctive: line 176
Never production, never a credential, never a sign in on the user's behalf.
- Very specific: line 179
Never change a verify to agree with what the system did.
- Distinctive: line 180
Never commit anything outside a run of an approved or declared plan.
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Working through the suite, in a loop
The suite is a set of blueprints converted from manual test scripts. The scripts are of variable quality: they show an intent and a workflow more than a strict, formal scenario. A step can be wrong, missing or in the wrong order, and a value can be a placeholder. The work is not to replay them as written: it is to prove, for each scenario, what it sets out to prove, and to leave evidence the client can read.
fusion-test is the mechanics of one run: read it first. This skill is the loop around it. The
window, the sign in and the production guard are those of fusion-instance.
What done means
Every scenario ends in one of three states, and none of them is "green at any cost":
- PASSED: the run proved the intent. Its evidence document exists.
- FAILED, a result: Oracle refused a legitimate transaction, or showed something other than the expected result. That is a finding about the system, reported verbatim, never worked around.
- PARKED: it needs the user (a person's action, a business choice, a question the pod cannot
answer), written in
fusion/suite-log.mdwith what exactly is needed.
The two approvals
- A plan approval (D23,
approve <scenario>) covers the steps exactly as written. Only a label repair or a PICK stays inside it. - An intent approval (D27,
approve <scenario>... --intent) covers what each scenario sets out to prove: its description and its ticket. Under it you may choose the values the script left open and rebuild the steps when the script is wrong, declaring each rebuild with its reason. This is the approval the loop runs on.
Before the first loop, show the user the intents, one ticket at a time: the scenario names in chain
order, the description of each (the expected result), the person to sign in as, and what the run will
create in the pod. Get an explicit yes for that list, then approve it with --intent. Never approve a
scenario the user did not see in that list.
The loop
Start every session, and every iteration, with the state on disk, never with memory:
npm run fusion -- suite # counts, stopped runs, what can run now by person
npm run fusion -- suite --all # one line per scenario, when you need the detailThen, in this order:
- A stopped run first. Deal with it (below) before starting anything new: a stopped run holds a window in a known state and values already drawn.
- Values to fill in the scenarios you are about to run (section "Choosing values").
- The runnable parts of the person signed in. Signing in is the one thing only the user does, so
work by person: tell the user "sign in as
<person>; I will run<parts>", then run all of them. Check who is signed in from the page header (snapshot) rather than assuming. - A chain in order. Part n runs with
--afterthe run that finished part n-1:suiteprints the exact command. Never run part n on the values of anything else. - After the last part of a chain, the evidence:
evidence <run-id of each part>, one document per ticket.
Reading a stop
| Exit | First question | Then |
| 3, a label | Renamed, ambiguous, or a PICK? | Renamed: repair (fusion-test step 4). PICK: see below. |
| 4, Oracle refused | Did the script ask for something legitimate? | Yes: a result, report it. No, the script was wrong (a value, an order, a missing field): rebuild. |
| 5, signed out | Ask the user to sign in, then resume. | |
| 6, a step failed | Is the expected result wrong, or the system? | See "Badly designed, or a finding?". |
PICK steps. A PICK label names a criterion ("PICK the time card period that contains the
absence"). When the criterion is objective, find the row that meets it on the page, then repair
with that row's label: the approval covers it, and the blueprint keeps the criterion for the next run.
When it is a person's work by nature (a file dialog, a code sent by email, a grid of quantities, a
drag), ask the user to do it in the window, then resume <run-id> --from <the next step>: the journal
and the evidence record it as done by the tester.
Badly designed, or a finding?
This is the judgement the loop exists for. Read the step, the page as it is (snapshot), the
description, and the ticket named in source:.
The script is wrong when, as the right person, on the right page:
- it asks for a control or a function this flow does not have, and nothing similar exists (not a rename: the step belongs to another flow, or to an older release of the page);
- its order cannot happen (a verify before the action that produces it, an approval before the submission, a search for a record a later part creates);
- a value cannot exist on this pod (a placeholder, a code from another environment, a date in the past where the flow wants a future one);
- its expected text is not what the page shows for the same outcome (wording, not meaning);
- a step is missing that the page requires (a mandatory field the script never names), and filling it is part of doing what the scenario describes.
It is a finding, not a script defect, when the system does not do what the ticket expects: a transaction refused, an approval that does not route, a value not offered to a role that should have it, a result that differs in meaning. Report it, with the Oracle text verbatim, and move on.
When in doubt, it is a finding. The danger of this loop is rebuilding a test until it passes. Before every rebuild, ask: if the system had the defect this ticket is about, would the rebuilt plan still fail? If not, the rebuild has emptied the test: do not do it, park the scenario and ask.
Rebuilding from the intent
- Understand the intent: the description (the expected result), the ticket, what the parts before and after this one create and expect.
- Learn the real flow without committing anything:
goto,snapshot, clicks that only open or navigate. A click that saves, submits or approves happens only inside a run of a declared plan. - Rewrite the steps in the same file. Keep the comments, add
# rebuilt <date>: <reason>above what changed, keep the scenario name, the chain position and the description. Keep everyverifythat encodes the expected result: change its text only for wording, never to match what the system did instead. Declare it, then check and run:
npm run fusion -- rebuild <scenario> --reason "<what was wrong in the script, and what changed>" npm run fusion -- plan <scenario> npm run fusion -- resume <run-id> --from N # or run, if nothing useful is left in the windowrunrefuses a scenario that changed without a declaration. Every run keeps a copy of the plan it followed, and the evidence document says the steps were rebuilt, and why.
Boundaries of a rebuild (D27), checked by rebuild where it can be:
- the test pod only, and only the transaction the intent describes;
- what the run creates is named with
{{run_id}}wherever the page lets you name it; - never setup, security, profile options or page rules: a test proves a transaction, it does not change the configuration the other testers rely on;
- nothing is deleted outside an approved
cleanupsection; - at most three rebuilds per scenario. After that, park it: the script is not the problem, or the intent is not clear enough to act on.
Choosing values
A profile value marked FILL was never named by the script. Choose it from the pod, never invent it:
read it (rest GET, snapshot of a search), choose the value that fits the intent (a test person
already used by the suite, a business unit the persona can reach), write it in the profile, then
declare it for every scenario of that profile:
npm run fusion -- rebuild --profile <profile> --reason "values chosen from the pod: <name> = <how chosen>"When the right value depends on business knowledge the pod does not hold, park it with the question.
The log, and handing over
fusion/suite-log.md is the memory of the suite that suite cannot compute. rebuild writes its
lines there. Add yours:
PARKED <scenario>: <what is needed from the user>FINDING <scenario>, run <run-id>: <the Oracle text or the difference, verbatim>SESSION <date>: <parts run, passed, parked>, at the end of each session.
Keep sessions short (fusion-test step 7): one person's runnable parts, or about ten scenarios, per
session. At the end, run suite, write the SESSION line, and give the user a prompt to paste:
Use fusion-suite. The Fusion window is open (check with `npm run fusion -- status`).
Read `npm run fusion -- suite` and fusion/suite-log.md, then continue the loop.
I will sign in as the person you name. Park what needs me, and give me at the end: passed, findings,
parked (with what you need), rebuilt (to review), and the evidence paths.Reporting to the user
At the end of a session, one line per scenario touched: outcome, run id, evidence path. Then, in this order: findings (verbatim), what is parked and what it needs, the scenarios rebuilt with their reasons (the user reviews these after the fact: that is the price of the intent approval), and what is left in the pod by run id. Never send an evidence document yourself: it shows client screens.
Hard rules
- Never production, never a credential, never a sign in on the user's behalf.
approveonly after an explicit yes in the conversation, for the list shown.- An Oracle error on a legitimate transaction is a result: never repaired, retried or worked around.
- Never change a
verifyto agree with what the system did. - Never commit anything outside a run of an approved or declared plan.
- Blueprints, profiles, runs, evidence and the log stay in the engagement directory.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

